diff --git a/.github/workflows/rituals.yaml b/.github/workflows/rituals.yaml index c36b5f7976..408dfabf85 100644 --- a/.github/workflows/rituals.yaml +++ b/.github/workflows/rituals.yaml @@ -169,5 +169,4 @@ jobs: # Execute after pushing, as no updated files will be produced - name: Test TypeScript code run: | - cd srcts yarn test diff --git a/DESCRIPTION b/DESCRIPTION index 71ee20505e..8673684b69 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,7 +1,7 @@ Package: shiny Type: Package Title: Web Application Framework for R -Version: 1.6.0.9021 +Version: 1.6.0.9022 Authors@R: c( person("Winston", "Chang", role = c("aut", "cre"), email = "winston@rstudio.com", comment = c(ORCID = "0000-0002-1576-2126")), person("Joe", "Cheng", role = "aut", email = "joe@rstudio.com"), diff --git a/NAMESPACE b/NAMESPACE index a9b48ab3a8..d8a9104926 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -273,6 +273,7 @@ export(stopApp) export(strong) export(submitButton) export(suppressDependencies) +export(sustainEnvAndQuoted) export(tabPanel) export(tabPanelBody) export(tableOutput) @@ -378,6 +379,7 @@ importFrom(htmltools,tags) importFrom(htmltools,validateCssUnit) importFrom(htmltools,withTags) importFrom(lifecycle,deprecated) +importFrom(lifecycle,is_present) importFrom(promises,"%...!%") importFrom(promises,"%...>%") importFrom(promises,as.promise) @@ -386,10 +388,13 @@ importFrom(promises,promise) importFrom(promises,promise_reject) importFrom(promises,promise_resolve) importFrom(rlang,"%||%") +importFrom(rlang,"fn_body<-") +importFrom(rlang,"fn_fmls<-") importFrom(rlang,as_function) importFrom(rlang,as_quosure) importFrom(rlang,enexpr) importFrom(rlang,enquo) +importFrom(rlang,enquo0) importFrom(rlang,enquos) importFrom(rlang,enquos0) importFrom(rlang,eval_tidy) @@ -408,4 +413,8 @@ importFrom(rlang,new_function) importFrom(rlang,new_quosure) importFrom(rlang,pairlist2) importFrom(rlang,quo) +importFrom(rlang,quo_get_expr) +importFrom(rlang,quo_is_missing) +importFrom(rlang,quo_set_env) +importFrom(rlang,quo_set_expr) importFrom(rlang,zap_srcref) diff --git a/NEWS.md b/NEWS.md index 98b1ae43ad..e747cdf0e8 100644 --- a/NEWS.md +++ b/NEWS.md @@ -1,7 +1,3 @@ -Addresses #2521: Updated the list of TCP ports that will [be rejected](https://chromium.googlesource.com/chromium/src.git/+/refs/heads/main/net/base/port_util.cc) -by default in runapp.R, adding 5060, 5061 and 6566. Added documentation describing the port range (3000:8000) -and which ports are rejected. - shiny 1.6.0.9000 ================ @@ -21,13 +17,17 @@ shiny 1.6.0.9000 * Closed #3322, #3313, #1823, #3321, #3320, #1928, and #2310: Various improvements to `navbarPage()`, `tabsetPanel()`, `tabPanel()`, `navbarMenu()`, etc. Also, these functions are now powered by the `{bslib}` package's new `nav()` API (consider using `{bslib}`'s API to create better looking and more fully featured navs). (#3388) * All uses of `list(...)` have been replaced with `rlang::list2(...)`. This means that you can use trailing `,` without error and use rlang's `!!!` operator to "splice" a list of argument values into `...`. We think this'll be particularly useful for passing a list of `tabPanel()` to their consumers (i.e., `tabsetPanel()`, `navbarPage()`, etc). For example, `tabs <- list(tabPanel("A", "a"), tabPanel("B", "b")); navbarPage(!!!tabs)`. (#3315 and #3328) - + +* `installExprFunction()` and `exprToFunction()` are now able to handle quosures, so `render`-functions which call these functions can now understand quosures, when they are called using `rlang::inject()`. This also means that `render` function no longer need `env` and `quoted` parameters; that information can be embedded into a quosure which is then passed to the `render` function. Additionally, the `getQuosure()` function was added, which makes it easier for developers to create `render` functions which understand quosures. Better documentation was added for how to create `render` functions. (#3462, #3466) + * `icon(lib="fontawesome")` is now powered by the `{fontawesome}` package, which will make it easier to use the latest FA icons in the future (by updating the `{fontawesome}` package). (#3302) * Closed #3397: `renderPlot()` new uses `ggplot2::get_alt_text()` to inform an `alt` text default (for `{ggplot2}` plots). (#3398) * `modalDialog()` gains support for `size = "xl"`. (#3410) +* Addressed #2521: Updated the list of TCP ports that will be rejected by default in runapp.R, adding 5060, 5061 and 6566. Added documentation describing the port range (3000:8000) and which ports are rejected. (#3456) + ### Other improvements * Shiny's core JavaScript code was converted to TypeScript. For the latest development information, please see the [README.md in `./srcts`](https://github.com/rstudio/shiny/tree/master/srcts). (#3296) @@ -42,6 +42,8 @@ shiny 1.6.0.9000 * Closed #3345: Shiny now correctly renders `htmltools::htmlDependency()`(s) with a `list()` of `script` attributes when used in a dynamic UI context. This fairly new `htmlDependency()` feature was added in `{htmltools}` v0.5.1. (#3395) +* Fixed [#2666](https://github.com/rstudio/shiny/issues/2666) and [#2670](https://github.com/rstudio/shiny/issues/2670): `nearPoints()` and `brushedPoints()` weren't properly account for missing values (#2666 was introduced in v1.4.0). ([#2668](https://github.com/rstudio/shiny/pull/2668)) + * Closed #3374: `quoToFunction()` now works correctly with nested quosures; and as a result, quasi-quotation with rendering function (e.g., `renderPrint()`, `renderPlot()`, etc) now works as expected with nested quosures. (#3373) * Exported `register_devmode_option()`. This method was described in the documentation for `devmode()` but was never exported. See `?devmode()` for more details on how to register Shiny Developer options using `register_devmode_option()`. (#3364) diff --git a/R/deprecated.R b/R/deprecated.R index faf99d55fb..92f58674cb 100644 --- a/R/deprecated.R +++ b/R/deprecated.R @@ -9,13 +9,19 @@ #' @param details Additional information to be added after a new line to the displayed message #' @keywords internal shinyDeprecated <- function( - version, what, with = NULL, details = NULL + version, + what, + with = NULL, + details = NULL, + type = c("deprecated", "superseded") ) { if (is_false(getOption("shiny.deprecation.messages"))) { return(invisible()) } - msg <- paste0("`", what, "` is deprecated as of shiny ", version, ".") + type <- match.arg(type) + + msg <- paste0("`", what, "` is ", type, " as of shiny ", version, ".") if (!is.null(with)) { msg <- paste0(msg, "\n", "Please use `", with, "` instead.") } @@ -60,7 +66,7 @@ diskCache <- function( logfile = NULL ) { shinyDeprecated("1.6.0", "diskCache()", "cachem::cache_disk()") - if (lifecycle::is_present(exec_missing)) { + if (is_present(exec_missing)) { shinyDeprecated("1.6.0", "diskCache(exec_missing =)") } @@ -93,7 +99,7 @@ memoryCache <- function( logfile = NULL) { shinyDeprecated("1.6.0", "diskCache()", "cachem::cache_mem()") - if (lifecycle::is_present(exec_missing)) { + if (is_present(exec_missing)) { shinyDeprecated("1.6.0", "diskCache(exec_missing =)") } diff --git a/R/image-interact.R b/R/image-interact.R index 460809888e..fd7d868cf8 100644 --- a/R/image-interact.R +++ b/R/image-interact.R @@ -267,6 +267,7 @@ nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL, stop("nearPoints: `yvar` ('", yvar ,"') not in names of input") # Extract data values from the data frame + coordinfo <- fortifyDiscreteLimits(coordinfo) x <- asNumber(df[[xvar]], coordinfo$domain$discrete_limits$x) y <- asNumber(df[[yvar]], coordinfo$domain$discrete_limits$y) @@ -392,6 +393,7 @@ nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL, # an input brush within_brush <- function(vals, brush, var = "x") { var <- match.arg(var, c("x", "y")) + brush <- fortifyDiscreteLimits(brush) vals <- asNumber(vals, brush$domain$discrete_limits[[var]]) # It's possible for a non-missing data values to not # map to the axis limits, for example: @@ -414,11 +416,43 @@ asNumber <- function(x, levels = NULL) { as.numeric(x) } +# Ensure the discrete limits/levels of a coordmap received +# from the client matches the data structure sent the client. +# +# When we construct the coordmap (in getGgplotCoordmap()), +# we save a character vector which may contain missing values +# (e.g., c("a", "b", NA)). When that same character is received +# from the client, it runs through decodeMessage() which sets +# simplifyVector=FALSE, which means NA are replaced by NULL +# (because jsonlite::fromJSON('["a", "b", null]') -> list("a", "b", NULL)) +# +# Thankfully, it doesn't seem like it's meaningful for limits to +# contains a NULL in the 1st place, so we simply treat NULL like NA. +# For more context, https://github.com/rstudio/shiny/issues/2666 +fortifyDiscreteLimits <- function(coord) { + # Note that discrete_limits$x/y are populated iff + # x/y are discrete mappings + coord$domain$discrete_limits <- lapply( + coord$domain$discrete_limits, + function(var) { + # if there is an 'explicit' NULL, then the limits are NA + if (is.null(var)) return(NA) + vapply(var, function(x) { + if (is.null(x) || isTRUE(is.na(x))) NA_character_ else x + }, character(1)) + } + ) + coord +} + + + # Given a panelvar value and a vector x, return logical vector indicating which # items match the panelvar value. Because the panelvar value is always a # string but the vector could be numeric, it might be necessary to coerce the # panelvar to a number before comparing to the vector. panelMatch <- function(search_value, x) { + if (is.null(search_value)) return(is.na(x)) if (is.numeric(x)) search_value <- as.numeric(search_value) x == search_value } diff --git a/R/map.R b/R/map.R index f2c25e26e8..297a648896 100644 --- a/R/map.R +++ b/R/map.R @@ -1,4 +1,3 @@ -#' @importFrom fastmap fastmap Map <- R6Class( 'Map', portable = FALSE, diff --git a/R/reactives.R b/R/reactives.R index 573bec2213..3840cda45f 100644 --- a/R/reactives.R +++ b/R/reactives.R @@ -945,12 +945,12 @@ Observable <- R6Class( #' See the [Shiny tutorial](https://shiny.rstudio.com/tutorial/) for #' more information about reactive expressions. #' -#' @param x For `reactive`, an expression (quoted or unquoted). For +#' @param x TODO-barret docs; For `reactive`, an expression (quoted or unquoted). For #' `is.reactive`, an object to test. -#' @param env The parent environment for the reactive expression. By default, +#' @param env TODO-barret docs; The parent environment for the reactive expression. By default, #' this is the calling environment, the same as when defining an ordinary #' non-reactive expression. -#' @param quoted Is the expression quoted? By default, this is `FALSE`. +#' @param quoted TODO-barret docs; Is the expression quoted? By default, this is `FALSE`. #' This is useful when you want to use an expression that is stored in a #' variable; to do so, it must be quoted with `quote()`. #' @param label A label for the reactive expression, useful for debugging. @@ -961,6 +961,7 @@ Observable <- R6Class( #' @return a function, wrapped in a S3 class "reactive" #' #' @examples +#' # TODO-barret docs; with quosures, not env / quoted #' values <- reactiveValues(A=1) #' #' reactiveB <- reactive({ @@ -979,7 +980,10 @@ Observable <- R6Class( #' isolate(reactiveC()) #' isolate(reactiveD()) #' @export -reactive <- function(x, env = parent.frame(), quoted = FALSE, +reactive <- function( + x, + env = deprecated(), + quoted = deprecated(), ..., label = NULL, domain = getDefaultReactiveDomain(), @@ -987,20 +991,19 @@ reactive <- function(x, env = parent.frame(), quoted = FALSE, { check_dots_empty() - x <- get_quosure(x, env, quoted) - fun <- as_function(x) - # as_function returns a function that takes `...`. We need one that takes no - # args. - formals(fun) <- list() + q <- enquo0(x) + q <- sustainEnvAndQuotedInternal(q, x, env, quoted) + fun <- quoToSimpleFunction(q) # Attach a label and a reference to the original user source for debugging - label <- exprToLabel(get_expr(x), "reactive", label) + q_expr <- quo_get_expr(q) + label <- exprToLabel(q_expr, "reactive", label) o <- Observable$new(fun, label, domain, ..stacktraceon = ..stacktraceon) structure( o$getValue, observable = o, - cacheHint = list(userExpr = zap_srcref(get_expr(x))), + cacheHint = list(userExpr = zap_srcref(q_expr)), class = c("reactiveExpr", "reactive", "function") ) } @@ -1325,10 +1328,10 @@ Observer <- R6Class( #' #' @param x An expression (quoted or unquoted). Any return value will be #' ignored. -#' @param env The parent environment for the reactive expression. By default, +#' @param env TODO-barret docs; The parent environment for the reactive expression. By default, #' this is the calling environment, the same as when defining an ordinary #' non-reactive expression. -#' @param quoted Is the expression quoted? By default, this is `FALSE`. +#' @param quoted TODO-barret docs; Is the expression quoted? By default, this is `FALSE`. #' This is useful when you want to use an expression that is stored in a #' variable; to do so, it must be quoted with `quote()`. #' @param label A label for the observer, useful for debugging. @@ -1383,6 +1386,7 @@ Observer <- R6Class( #' } #' #' @examples +#' # TODO-barret docs; examples are outdated #' values <- reactiveValues(A=1) #' #' obsB <- observe({ @@ -1400,7 +1404,10 @@ Observer <- R6Class( #' # are at the console, you can force a flush with flushReact() #' shiny:::flushReact() #' @export -observe <- function(x, env = parent.frame(), quoted = FALSE, +observe <- function( + x, + env = deprecated(), + quoted = deprecated(), ..., label = NULL, suspended = FALSE, @@ -1411,14 +1418,12 @@ observe <- function(x, env = parent.frame(), quoted = FALSE, { check_dots_empty() - x <- get_quosure(x, env, quoted) - fun <- as_function(x) - # as_function returns a function that takes `...`. We need one that takes no - # args. - formals(fun) <- list() + q <- enquo0(x) + q <- sustainEnvAndQuotedInternal(q, x, env, quoted) + fun <- quoToSimpleFunction(q) if (is.null(label)) { - label <- sprintf('observe(%s)', paste(deparse(get_expr(x)), collapse='\n')) + label <- sprintf('observe(%s)', paste(deparse(quo_get_expr(q)), collapse='\n')) } o <- Observer$new( @@ -2146,17 +2151,17 @@ maskReactiveContext <- function(expr) { #' scope. #' @param event.env The parent environment for `eventExpr`. By default, #' this is the calling environment. -#' @param event.quoted Is the `eventExpr` expression quoted? By default, +#' @param event.quoted TODO-barret docs; Is the `eventExpr` expression quoted? By default, #' this is `FALSE`. This is useful when you want to use an expression #' that is stored in a variable; to do so, it must be quoted with #' `quote()`. -#' @param handler.env The parent environment for `handlerExpr`. By default, +#' @param handler.env TODO-barret docs; The parent environment for `handlerExpr`. By default, #' this is the calling environment. -#' @param handler.quoted Is the `handlerExpr` expression quoted? By +#' @param handler.quoted TODO-barret docs; Is the `handlerExpr` expression quoted? By #' default, this is `FALSE`. This is useful when you want to use an #' expression that is stored in a variable; to do so, it must be quoted with #' `quote()`. -#' @param value.env The parent environment for `valueExpr`. By default, +#' @param value.env TODO-barret docs; The parent environment for `valueExpr`. By default, #' this is the calling environment. #' @param value.quoted Is the `valueExpr` expression quoted? By default, #' this is `FALSE`. This is useful when you want to use an expression @@ -2265,8 +2270,8 @@ maskReactiveContext <- function(expr) { #' } #' @export observeEvent <- function(eventExpr, handlerExpr, - event.env = parent.frame(), event.quoted = FALSE, - handler.env = parent.frame(), handler.quoted = FALSE, + event.env = deprecated(), event.quoted = deprecated(), + handler.env = deprecated(), handler.quoted = deprecated(), ..., label = NULL, suspended = FALSE, priority = 0, domain = getDefaultReactiveDomain(), autoDestroy = TRUE, @@ -2274,15 +2279,17 @@ observeEvent <- function(eventExpr, handlerExpr, { check_dots_empty() - eventExpr <- get_quosure(eventExpr, event.env, event.quoted) - handlerExpr <- get_quosure(handlerExpr, handler.env, handler.quoted) + eventQ <- enquo0(eventExpr) + handlerQ <- enquo0(handlerExpr) + eventQ <- sustainEnvAndQuotedInternal(eventQ, eventExpr, event.env, event.quoted) + handlerQ <- sustainEnvAndQuotedInternal(handlerQ, handlerExpr, handler.env, handler.quoted) if (is.null(label)) { - label <- sprintf('observeEvent(%s)', paste(deparse(get_expr(eventExpr)), collapse='\n')) + label <- sprintf('observeEvent(%s)', paste(deparse(get_expr(eventQ)), collapse='\n')) } handler <- inject(observe( - !!handlerExpr, + !!handlerQ, label = label, suspended = suspended, priority = priority, @@ -2296,7 +2303,7 @@ observeEvent <- function(eventExpr, handlerExpr, ignoreInit = ignoreInit, once = once, label = label, - !!eventExpr, + !!eventQ, x = handler )) @@ -2306,27 +2313,29 @@ observeEvent <- function(eventExpr, handlerExpr, #' @rdname observeEvent #' @export eventReactive <- function(eventExpr, valueExpr, - event.env = parent.frame(), event.quoted = FALSE, - value.env = parent.frame(), value.quoted = FALSE, + event.env = deprecated(), event.quoted = deprecated(), + value.env = deprecated(), value.quoted = deprecated(), ..., label = NULL, domain = getDefaultReactiveDomain(), ignoreNULL = TRUE, ignoreInit = FALSE) { check_dots_empty() - eventExpr <- get_quosure(eventExpr, event.env, event.quoted) - valueExpr <- get_quosure(valueExpr, value.env, value.quoted) + eventQ <- enquo0(eventExpr) + valueQ <- enquo0(valueExpr) + eventQ <- sustainEnvAndQuotedInternal(eventQ, eventExpr, event.env, event.quoted) + valueQ <- sustainEnvAndQuotedInternal(valueQ, valueExpr, value.env, value.quoted) if (is.null(label)) { - label <- sprintf('eventReactive(%s)', paste(deparse(get_expr(eventExpr)), collapse='\n')) + label <- sprintf('eventReactive(%s)', paste(deparse(get_expr(eventQ)), collapse='\n')) } invisible(inject(bindEvent( ignoreNULL = ignoreNULL, ignoreInit = ignoreInit, label = label, - !!eventExpr, - x = reactive(!!valueExpr, domain = domain, label = label) + !!eventQ, + x = reactive(!!valueQ, domain = domain, label = label) ))) } diff --git a/R/render-plot.R b/R/render-plot.R index 7b36931a53..0815f41fb2 100644 --- a/R/render-plot.R +++ b/R/render-plot.R @@ -46,8 +46,8 @@ #' decorative images. #' @param ... Arguments to be passed through to [grDevices::png()]. #' These can be used to set the width, height, background color, etc. -#' @param env The environment in which to evaluate `expr`. -#' @param quoted Is `expr` a quoted expression (with `quote()`)? This +#' @param env TODO-barret docs; The environment in which to evaluate `expr`. +#' @param quoted TODO-barret docs; Is `expr` a quoted expression (with `quote()`)? This #' is useful if you want to save an expression in a variable. #' @param execOnResize If `FALSE` (the default), then when a plot is #' resized, Shiny will *replay* the plot drawing commands with @@ -61,14 +61,15 @@ #' @export renderPlot <- function(expr, width = 'auto', height = 'auto', res = 72, ..., alt = NA, - env = parent.frame(), quoted = FALSE, + env = deprecated(), quoted = deprecated(), execOnResize = FALSE, outputArgs = list() ) { - expr <- get_quosure(expr, env, quoted) + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) # This ..stacktraceon is matched by a ..stacktraceoff.. when plotFunc # is called - func <- quoToFunction(expr, "renderPlot", ..stacktraceon = TRUE) + func <- quoToFunction(q, "renderPlot", ..stacktraceon = TRUE) args <- list(...) @@ -186,7 +187,7 @@ renderPlot <- function(expr, width = 'auto', height = 'auto', res = 72, ..., outputFunc, renderFunc, outputArgs, - cacheHint = list(userExpr = get_expr(expr), res = res) + cacheHint = list(userExpr = get_expr(q), res = res) ) class(markedFunc) <- c("shiny.renderPlot", class(markedFunc)) markedFunc diff --git a/R/render-table.R b/R/render-table.R index 01a86d242b..e2566fa2a5 100644 --- a/R/render-table.R +++ b/R/render-table.R @@ -42,8 +42,8 @@ #' (i.e. they either evaluate to `NA` or `NaN`). #' @param ... Arguments to be passed through to [xtable::xtable()] #' and [xtable::print.xtable()]. -#' @param env The environment in which to evaluate `expr`. -#' @param quoted Is `expr` a quoted expression (with `quote()`)? +#' @param env TODO-barret docs; The environment in which to evaluate `expr`. +#' @param quoted TODO-barret docs; Is `expr` a quoted expression (with `quote()`)? #' This is useful if you want to save an expression in a variable. #' @param outputArgs A list of arguments to be passed through to the #' implicit call to [tableOutput()] when `renderTable` is @@ -71,11 +71,12 @@ renderTable <- function(expr, striped = FALSE, hover = FALSE, width = "auto", align = NULL, rownames = FALSE, colnames = TRUE, digits = NULL, na = "NA", ..., - env = parent.frame(), quoted = FALSE, + env = deprecated(), quoted = deprecated(), outputArgs=list()) { - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderTable") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderTable") if (!is.function(spacing)) spacing <- match.arg(spacing) diff --git a/R/shiny-package.R b/R/shiny-package.R index 63d03affda..5c6b8611d3 100644 --- a/R/shiny-package.R +++ b/R/shiny-package.R @@ -2,7 +2,7 @@ ## usethis namespace: start ## usethis namespace: end -#' @importFrom lifecycle deprecated +#' @importFrom lifecycle deprecated is_present #' @importFrom grDevices dev.set dev.cur #' @importFrom fastmap fastmap #' @importFrom promises %...!% @@ -11,11 +11,13 @@ #' promise promise_resolve promise_reject is.promising #' as.promise #' @importFrom rlang -#' quo enquo as_function get_expr get_env new_function enquos +#' quo enquo enquo0 as_function get_expr get_env new_function enquos #' eval_tidy expr pairlist2 new_quosure enexpr as_quosure is_quosure inject +#' quo_set_env quo_set_expr quo_get_expr #' enquos0 zap_srcref %||% is_na #' is_false list2 #' missing_arg is_missing maybe_missing +#' quo_is_missing fn_fmls<- fn_body<- #' @importFrom ellipsis #' check_dots_empty check_dots_unnamed #' @import htmltools diff --git a/R/shinywrappers.R b/R/shinywrappers.R index d8c276b029..10e6319c94 100644 --- a/R/shinywrappers.R +++ b/R/shinywrappers.R @@ -8,6 +8,12 @@ utils::globalVariables('func', add = TRUE) #' function. This can be used in R Markdown documents to create complete output #' widgets out of just the render function. #' +#' Note that it is generally preferable to use [createRenderFunction()] instead +#' of `markRenderFunction()`. It essentially wraps up the user-provided +#' expression in the `transform` function passed to it, then pases the resulting +#' function to `markRenderFunction()`. It also provides a simpler calling +#' interface. +#' #' @param uiFunc A function that renders Shiny UI. Must take a single argument: #' an output ID. #' @param renderFunc A function that is suitable for assigning to a Shiny output @@ -136,7 +142,8 @@ print.shiny.render.function <- function(x, ...) { #' Implement render functions #' #' This function is a wrapper for [markRenderFunction()] which provides support -#' for async computation via promises. +#' for async computation via promises. It is recommended to use +#' `createRenderFunction()` instead of `markRenderFunction()`. #' #' @param func A function without parameters, that returns user data. If the #' returned value is a promise, then the render function will proceed in async @@ -153,16 +160,12 @@ print.shiny.render.function <- function(x, ...) { #' @return An annotated render function, ready to be assigned to an #' `output` slot. #' -#' @seealso [quoToFunction()], [markRenderFunction()]. +#' @seealso [quoToFunction()], [markRenderFunction()], [rlang::enquo()]. #' #' @examples #' # A very simple render function -#' renderTriple <- function(x) { -#' x <- substitute(x) -#' if (!rlang::is_quosure(x)) { -#' x <- rlang::new_quosure(x, env = parent.frame()) -#' } -#' func <- quoToFunction(x, "renderTriple") +#' renderTriple <- function(expr) { +#' func <- quoToFunction(rlang::enquo0(expr)) #' #' createRenderFunction( #' func, @@ -175,9 +178,10 @@ print.shiny.render.function <- function(x, ...) { #' #' # Test render function from the console #' a <- 1 -#' r <- renderTriple({ a + 1 }) +#' r <- renderTriple({ a * 10 }) #' a <- 2 #' r() +#' # [1] "20, 20, 20" #' @export createRenderFunction <- function( func, @@ -316,8 +320,8 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL, #' the output, see [plotPNG()]. #' #' @param expr An expression that returns a list. -#' @param env The environment in which to evaluate `expr`. -#' @param quoted Is `expr` a quoted expression (with `quote()`)? This +#' @param env TODO-barret docs; The environment in which to evaluate `expr`. +#' @param quoted TODO-barret docs; Is `expr` a quoted expression (with `quote()`)? This #' is useful if you want to save an expression in a variable. #' @param deleteFile Should the file in `func()$src` be deleted after #' it is sent to the client browser? Generally speaking, if the image is a @@ -397,11 +401,12 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL, #' #' shinyApp(ui, server) #' } -renderImage <- function(expr, env=parent.frame(), quoted=FALSE, +renderImage <- function(expr, env = deprecated(), quoted = deprecated(), deleteFile, outputArgs=list()) { - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderImage") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderImage") # missing() must be used directly within the function with the given arg if (missing(deleteFile)) { @@ -523,8 +528,8 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) { #' function return [invisible()]. #' #' @param expr An expression to evaluate. -#' @param env The environment in which to evaluate `expr`. For expert use only. -#' @param quoted Is `expr` a quoted expression (with `quote()`)? This +#' @param env TODO-barret docs; The environment in which to evaluate `expr`. For expert use only. +#' @param quoted TODO-barret docs; Is `expr` a quoted expression (with `quote()`)? This #' is useful if you want to save an expression in a variable. #' @param width Width of printed output. #' @param outputArgs A list of arguments to be passed through to the implicit @@ -533,11 +538,12 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) { #' #' @example res/text-example.R #' @export -renderPrint <- function(expr, env = parent.frame(), quoted = FALSE, +renderPrint <- function(expr, env = deprecated(), quoted = deprecated(), width = getOption('width'), outputArgs=list()) { - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderPrint") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderPrint") # Set a promise domain that sets the console width # and captures output @@ -569,7 +575,7 @@ renderPrint <- function(expr, env = parent.frame(), quoted = FALSE, outputArgs, cacheHint = list( label = "renderPrint", - origUserExpr = get_expr(expr) + origUserExpr = get_expr(q) ) ) } @@ -619,11 +625,12 @@ createRenderPrintPromiseDomain <- function(width) { #' element. #' @export #' @rdname renderPrint -renderText <- function(expr, env=parent.frame(), quoted=FALSE, +renderText <- function(expr, env = deprecated(), quoted = deprecated(), outputArgs=list(), sep=" ") { - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderText") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderText") createRenderFunction( func, @@ -644,8 +651,8 @@ renderText <- function(expr, env=parent.frame(), quoted=FALSE, #' #' @param expr An expression that returns a Shiny tag object, [HTML()], #' or a list of such objects. -#' @param env The environment in which to evaluate `expr`. -#' @param quoted Is `expr` a quoted expression (with `quote()`)? This +#' @param env TODO-barret docs; The environment in which to evaluate `expr`. +#' @param quoted TODO-barret docs; Is `expr` a quoted expression (with `quote()`)? This #' is useful if you want to save an expression in a variable. #' @param outputArgs A list of arguments to be passed through to the implicit #' call to [uiOutput()] when `renderUI` is used in an @@ -672,11 +679,12 @@ renderText <- function(expr, env=parent.frame(), quoted=FALSE, #' shinyApp(ui, server) #' } #' -renderUI <- function(expr, env = parent.frame(), quoted = FALSE, +renderUI <- function(expr, env = deprecated(), quoted = deprecated(), outputArgs = list()) { - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderUI") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderUI") createRenderFunction( func, @@ -755,6 +763,8 @@ downloadHandler <- function(filename, content, contentType=NA, outputArgs=list() #' Table output with the JavaScript DataTables library #' #' @description +#' `r lifecycle::badge("superseded")` Please use [`DT::renderDataTable()`]. (Shiny 0.11.1) +#' #' Makes a reactive version of the given function that returns a data frame (or #' matrix), which will be rendered with the [DataTables](https://datatables.net) #' library. Paging, searching, filtering, and sorting can be done on the R side @@ -818,7 +828,7 @@ downloadHandler <- function(filename, content, contentType=NA, outputArgs=list() #' } renderDataTable <- function(expr, options = NULL, searchDelay = 500, callback = 'function(oTable) {}', escape = TRUE, - env = parent.frame(), quoted = FALSE, + env = deprecated(), quoted = deprecated(), outputArgs=list()) { @@ -829,8 +839,9 @@ renderDataTable <- function(expr, options = NULL, searchDelay = 500, ) } - expr <- get_quosure(expr, env, quoted) - func <- quoToFunction(expr, "renderDataTable") + q <- enquo0(expr) + q <- sustainEnvAndQuotedInternal(q, expr, env, quoted) + func <- quoToFunction(q, "renderDataTable") renderFunc <- function(shinysession, name, ...) { if (is.function(options)) options <- options() diff --git a/R/utils-lang.R b/R/utils-lang.R index 2237a90ee3..3cf6f4915d 100644 --- a/R/utils-lang.R +++ b/R/utils-lang.R @@ -51,60 +51,463 @@ formalsAndBody <- function(x) { } -# This function is to be called from functions like `reactive()`, `observe()`, +#' Convert a quosure to a function for a Shiny render function +#' +#' This takes a quosure and label, and wraps them into a function that should be +#' passed to [createRenderFunction()] or [markRenderFunction()]. +#' +#' This function was added in Shiny 1.6.0. Previously, it was recommended to use +#' [installExprFunction()] or [exprToFunction()] in render functions, but now we +#' recommend using [quoToFunction()], because it does not require `env` and +#' `quoted` arguments -- that information is captured by quosures provided by +#' \pkg{rlang}. +#' +#' @param q A quosure. +#' @inheritParams installExprFunction +#' @seealso [createRenderFunction()] for example usage. +#' +#' @export +quoToFunction <- function(q, + label = sys.call(-1)[[1]], + ..stacktraceon = FALSE) +{ + q <- as_quosure(q) + func <- quoToSimpleFunction(q) + wrapFunctionLabel(func, updateFunctionLabel(label), ..stacktraceon = ..stacktraceon) +} +updateFunctionLabel <- function(label) { + # browser() + if (all(is.language(label))) { + # Prevent immediately invoked functions like as.language(a()()) + if (is.language(label) && length(label) > 1) { + return("wrappedFunction") + } + label <- deparse(label, width.cutoff = 500L) + } + label <- as.character(label) + # Prevent function calls that are over one line; (Assignments are hard to perform) + # Prevent immediately invoked functions like "a()()" + if (length(label) > 1 || grepl("(", label, fixed = TRUE)) { + return("wrappedFunction") + } + if (label == "NULL") { + return("wrappedFunction") + } + label +} + +quoToSimpleFunction <- function(q) { + # Should not use `new_function(list(), get_expr(q), get_env(q))` as extra logic + # is done by rlang to convert the quosure to a function within `as_function(q)` + fun <- as_function(q) + + # If the quosure is empty, then the returned function can not be called. + # https://github.com/r-lib/rlang/issues/1244 + if (quo_is_missing(q)) { + fn_body(fun) <- quote({}) + return(fun) + } + # as_function returns a function that takes `...`. We need one that takes no + # args. + fn_fmls(fun) <- list() + fun +} + + +#' Convert expressions and quosures to functions +#' +#' `handleEnvAndQuoted()` and `quoToFunction()` are meant to be used together in a +#' `render` function, to capture user expressions or quosures and convert them +#' to functions. They are meant to replace the older functions +#' [installExprFunction()] and [exprToFunction()] (although those will continue +#' to work in the future). See the examples in [installExprFunction()] for +#' information on how to migrate to `getQuosure()` and `quoToFunction()`. +#' +#' Although `getQuosure()` can take `env` and `quoted` parameters, it is +#' recommended that they not be used, except for backward compatibility. +#' The recommended usage of `getQuosure()` and `quoToFunction()` does not +#' include use of the `env` and `quoted` parameters. If it is necessary to +#' use quoted expressions and/or custom environments for evaluating, it can be +#' done with quosures and [rlang::inject()]. The examples below demonstrate how +#' to do this. +#' +#' If you are updating from [installExprFunction()] or [exprToFunction()] to +#' these functions, see the examples in the documentation for the old functions +#' for how to migrate them. +#' +#' @param x An expression or quosure. +#' @param env An environment. This is provided for backward compatibility. +#' @param quoted A boolean indicating whether or not `env` is quoted. This is +#' provided for backward compatibility. +#' +#' @examples +#' # Example of a new renderer, similar to renderText. +#' # This is something that toolkit authors will do. +#' renderTriple <- function(expr) { +#' # Convert expr to a quosure, and then to a function +#' func <- quoToFunction(rlang::enquo0(expr)) +#' +#' # Wrap up func, with another function which takes the value of func() +#' # and modifies it. +#' createRenderFunction( +#' func, +#' transform = function(value, session, name, ...) { +#' paste(rep(value, 3), collapse=", ") +#' }, +#' # The outputFunc can be used by rmarkdown shiny apps to automatically +#' # generate outputs. +#' outputFunc = textOutput +#' ) +#' } +#' +#' +#' # Example of using the renderer. +#' # This is something that app authors will do. +#' values <- reactiveValues(A="text") +#' +#' \dontrun{ +#' # Create an output object +#' output$tripleA <- renderTriple({ +#' values$A +#' }) +#' } +#' +#' # At the R console, you can experiment with the renderer using isolate() +#' tripleA <- renderTriple({ +#' values$A +#' }) +#' +#' isolate(tripleA()) +#' # "text, text, text" +#' +#' +#' # If you want to use a quoted expression, use rlang:inject(). +#' a <- 1 +#' expr <- quote({ values$A }) +#' tripleA <- rlang::inject(renderTriple(!!expr)) +#' isolate(tripleA()) +#' # "text, text, text" +#' +#' # Capturing an expression and an environment, using a quosure and rlang::inject(): +#' e <- new.env() +#' e$vals <- reactiveValues(A="hello") +#' # Create a quosure that captures both the expression and environment. +#' myquo <- rlang::new_quosure(quote({ vals$A }), env = e) +#' tripleA <- rlang::inject(renderTriple(!!myquo)) +#' isolate(tripleA()) +#' # "hello, hello, hello" +#' +#' +#' @rdname quoToFunction +#' @export +sustainEnvAndQuoted <- function(q, x, env, quoted) { + ## To avoid possible boilerplate with `deprecated()`... + env_is_present <- + if (!is_present(env)) { + # If `env` is `deprecated()`, set to the parent frame of the caller + env <- parent.frame(2) + + FALSE # env_is_present + } else { + # check of parent frame had a missing _`env`_ param + eval(substitute(!missing(env)), parent.frame()) + } + quoted_is_present <- + if (!is_present(quoted)) { + # If `quoted` is deprecated(), set to `FALSE` + quoted <- FALSE + + FALSE # quoted_is_present + } else { + # check of parent frame had a missing _`quoted`_ param + eval(substitute(!missing(quoted)), parent.frame()) + } + ## + # This is TRUE when the user called `inject(renderFoo(!!q))` + x_is_quosure <- is_quosure(eval(substitute(substitute(x)), parent.frame())) + + sustainEnvAndQuoted_( + q = q, env = env, quoted = quoted, + env_is_present = env_is_present, + quoted_is_present = quoted_is_present, + x_is_quosure = x_is_quosure, + verbose = TRUE + ) +} + +# `sustainEnvAndQuotedInternal()` is to be called from functions like `reactive()`, `observe()`, # and the various render functions. It handles the following cases: # - The typical case where x is an unquoted expression, and `env` and `quoted` # are not used. # - New-style metaprogramming cases, where rlang::inject() is used to inline a # quosure into the AST, as in `inject(reactive(!!x))`. # - Old-style metaprogramming cases, where `env` and/or `quoted` are used. -# -# Much of the complexity is handling old-style metaprogramming cases. The code -# in this function is more complicated because it needs to look at unevaluated -# expressions in the _calling_ function. If this code were put directly in the -# calling function, it would look like this: -# -# if (!missing(env) || !missing(quoted)) { -# deprecatedEnvQuotedMessage() -# if (!quoted) x <- substitute(x) -# x <- new_quosure(x, env) -# -# } else { -# x <- substitute(x) -# if (!is_quosure(x)) { -# x <- new_quosure(x, env = parent.frame()) -# } -# } -# -# In the future, the calling functions will not need to have the `env` and -# `quoted` arguments -- `rlang::inject()` and quosures can be used instead. -# Instead of using this function, `get_quosure()`, the caller can instead use -# just the following code: -# -# x <- substitute(x) -# if (!is_quosure(x)) { -# x <- new_quosure(x, env = parent.frame()) +# Same as `sustainEnvAndQuoted()`, but quiet +# Under assumption that `env = deprecated()` and `quoted = deprecated()` +sustainEnvAndQuotedInternal <- function(q, x, env, quoted) { + ## Can leverage the fact that we know all `env` and `quoted` args are set to `deprecated()` + env_is_present <- is_present(env) # eval(substitute(!missing(env)), parent.frame()) + quoted_is_present <- is_present(quoted) # eval(substitute(!missing(quoted)), parent.frame()) + x_is_quosure <- is_quosure(eval(substitute(substitute(x)), parent.frame())) + if (!env_is_present) env <- parent.frame(2) + if (!quoted_is_present) quoted <- FALSE + + sustainEnvAndQuoted_( + q = q, + env = env, + quoted = quoted, + env_is_present = env_is_present, + quoted_is_present = quoted_is_present, + x_is_quosure = x_is_quosure, + verbose = FALSE + ) +} +# # Reaches up three calls to check if env / quoted were provided. +# # Can not leverage `is_present()` logic like in `sustainEnvAndQuotedInternal()` + +# # This is similar to `sustainEnvAndQuotedInternal()`, but it is intended to be used only by +# # `installExprFunction()` and `exprToFunction()`. Whereas `sustainEnvAndQuotedInternal()` reaches +# # 2 calls back to find the expression passed in, this function reaches 3 calls +# # back, and it is only used internally within Shiny. +# sustainEnvAndQuoted3Internal <- function(q, x, env, quoted) { +# ## To avoid possible boilerplate with `deprecated()`... +# env_is_present <- +# if (!is_present(env)) { +# # If `env` is `deprecated()`, set to the parent frame of the caller +# env <- parent.frame(3) + +# FALSE # env_is_present +# } else { +# # check of parent frame of the caller had a missing _`env`_ param +# eval(eval(substitute(substitute(!missing(env))), parent.frame()), parent.frame(2)) +# } +# quoted_is_present <- +# if (!is_present(quoted)) { +# # If `quoted` is deprecated(), set to `FALSE` +# quoted <- FALSE + +# FALSE # quoted_is_present +# } else { +# # check of parent frame had a missing _`quoted`_ param +# eval(eval(substitute(substitute(!missing(quoted))), parent.frame()), parent.frame(2)) +# } +# ## +# x_is_quosure <- is_quosure(eval(eval(substitute(substitute(x)), parent.frame()), parent.frame(2))) + +# sustainEnvAndQuoted_( +# q = q, env = env, quoted = quoted, +# env_is_present = env_is_present, +# quoted_is_present = quoted_is_present, +# x_is_quosure = x_is_quosure, +# verbose = FALSE +# ) # } -# -get_quosure <- function(x, env, quoted) { - if (!eval(substitute(missing(env)), parent.frame()) || - !eval(substitute(missing(quoted)), parent.frame())) - { - deprecatedEnvQuotedMessage() - if (!quoted) { - x <- eval(substitute(substitute(x)), parent.frame()) - } - x <- new_quosure(x, env) +sustainEnvAndQuoted_ <- function( + q, env, quoted, + env_is_present, quoted_is_present, x_is_quosure, + verbose = TRUE +) { + if ( + env_is_present || + quoted_is_present + ) { + if (verbose) deprecatedEnvQuotedMessage() + # browser() - } else { - x <- eval(substitute(substitute(x)), parent.frame()) + # Can't have x be a quosure and use env/quoted. + if (x_is_quosure) { + stop( + "Can not use a `quosure()` with either the `env` or `quoted` parameters.\n", + "Please alter your quosure before the shiny function call and ", + "do not supply any `env` or `quoted` parameters.\n", + "To use your `quosure()` object directly, use `inject()` mixed with `!!`.\n", + "Ex: `inject(renderText(!!q))`" + ) + } - # At this point, x can be a quosure if rlang::inject() is used, but the - # typical case is that x is not a quosure. - if (!is_quosure(x)) { - x <- new_quosure(x, env = parent.frame(2L)) + # In this code path, x is NOT a literal quosure object + if (isTRUE(quoted)) { + q <- quo_set_expr(q, eval_tidy(q)) } + if (env_is_present) { + q <- quo_set_env(q, env) + } + } + q +} + + + +#' Convert an expression to a function +#' +#' @description +#' `r lifecycle::badge("superseded")` Please see [`quoToFunction()`] for updated usage. (Shiny 1.7.0) +#' +#' Note: as of Shiny 1.7.0, it is +#' recommended to use [`quoToFunction()`] (and if necessary, [`sustainEnvAndQuoted()`]) instead of +#' `exprToFunction()` and `installExprFunction()`. See the examples for +#' information on how to migrate to `getQuosure()` and `quoToFunction()`. +#' +#' This is to be called from another function, because it will attempt to get +#' an unquoted expression from two calls back. +#' +#' For `exprToFunction()`: +#' If `expr` is a quoted expression, then this just converts it to a function. +#' If `expr` is a function, then this simply returns expr (and prints a +#' deprecation message). +#' If `expr` was a non-quoted expression from two calls back, then this will +#' quote the original expression and convert it to a function. +#' +#' `installExprFunction` installs an expression in the given environment as a +#' function, and registers debug hooks so that breakpoints may be set in the +#' function. +#' +#' `installExprFunction` can replace `exprToFunction` as follows: we may use +#' `func <- exprToFunction(expr)` if we do not want the debug hooks, or +#' `installExprFunction(expr, "func")` if we do. Both approaches create a +#' function named `func` in the current environment. +#' +#' +#' @param expr A quoted or unquoted expression, or a quosure. +#' @param env The desired environment for the function. Defaults to the +#' calling environment two steps back. +#' @param quoted Is the expression quoted? +#' +#' @examples +#' # These examples demonstrate the old method, with exprToFunction() and +#' # installExprFunction(), as well as how to replace them, with getQuosure(). +#' +#' # Version 1: exprToFunction() +#' # The old way of converting the expression to a quosure, with exprToFunction() +#' renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) { +#' # Convert expr to a function +#' func <- exprToFunction(expr, env, quoted) +#' +#' function() { +#' value <- func() +#' paste(rep(value, 3), collapse=", ") +#' } +#' } +#' +#' # Version 2: installExprFunction() +#' # The not-quite-as-old way of converting the expression to a quosure, with +#' # installExprFunction() +#' renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) { +#' # Convert expr to a function +#' installExprFunction(expr, "func", env, quoted) +#' +#' function() { +#' value <- func() +#' paste(rep(value, 3), collapse=", ") +#' } +#' } +#' +#' # Version 3: Replacing the old functions with getQuosure() and quoToFunction() +#' # This keeps the `env` and `quoted` arguments, in case they are needed for +#' # backward compatibility +#' renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) { +#' # Convert expr to a quosure, and then to a function +#' q <- rlang::enquo0(expr) +#' q <- sustainEnvAndQuoted(q, expr, env, quoted) +#' func <- quoToFunction(q) +#' +#' function() { +#' value <- func() +#' paste(rep(value, 3), collapse=", ") +#' } +#' } +#' +#' +#' # Version 4: getQuosure() +#' # This is the recommended way to use getQuosure() and quoToFunction(), and +#' # it discards `env` and `quoted`, for simplicity. +#' renderTriple <- function(expr) { +#' # Convert expr to a quosure, and then to a function +#' func <- quoToFunction(rlang::enquo0(expr)) +#' +#' function() { +#' value <- func() +#' paste(rep(value, 3), collapse=", ") +#' } +#' } +#' +#' # Example of using the renderer. +#' # This is something that app authors will do. +#' values <- reactiveValues(A="text") +#' +#' \dontrun{ +#' # Create an output object +#' output$tripleA <- renderTriple({ +#' values$A +#' }) +#' } +#' +#' # At the R console, you can experiment with the renderer using isolate() +#' tripleA <- renderTriple({ +#' values$A +#' }) +#' +#' isolate(tripleA()) +#' # "text, text, text" +#' @export +exprToFunction <- function(expr, env = parent.frame(), quoted = FALSE) { + if (!quoted) { + expr <- eval(substitute(substitute(expr)), parent.frame()) + } + + # expr is a quoted expression + new_function(list(), body = expr, env = env) +} + +#' @rdname exprToFunction +#' +#' @param name The name the function should be given +#' @param eval.env The desired environment for the function. Defaults to the +#' calling environment two steps back. +#' @param assign.env The environment in which the function should be assigned. +#' @param label A label for the object to be shown in the debugger. Defaults to +#' the name of the calling function. +#' @param wrappedWithLabel,..stacktraceon Advanced use only. For stack manipulation purposes; see +#' [stacktrace()]. +#' @export +installExprFunction <- function(expr, name, eval.env = parent.frame(2), + quoted = FALSE, + assign.env = parent.frame(1), + label = sys.call(-1)[[1]], + wrappedWithLabel = TRUE, + ..stacktraceon = FALSE) { + if (!quoted) { + quoted <- TRUE + expr <- eval(substitute(substitute(expr)), parent.frame()) } - x + func <- exprToFunction(expr, eval.env, quoted) + if (length(label) > 1) { + # Just in case the deparsed code is more complicated than we imagine. If we + # have a label with length > 1 it causes warnings in wrapFunctionLabel. + label <- paste0(label, collapse = "\n") + } + if (wrappedWithLabel) { + func <- wrapFunctionLabel(func, updateFunctionLabel(label), ..stacktraceon = ..stacktraceon) + } else { + registerDebugHook(name, assign.env, label) + } + assign(name, func, envir = assign.env) +} + +# Utility function for creating a debugging label, given an expression. +# `expr` is a quoted expression. +# `function_name` is the name of the calling function. +# `label` is an optional user-provided label. If NULL, it will be inferred. +exprToLabel <- function(expr, function_name, label = NULL) { + srcref <- attr(expr, "srcref", exact = TRUE) + if (is.null(label)) { + label <- rexprSrcrefToLabel( + srcref[[1]], + sprintf('%s(%s)', function_name, paste(deparse(expr), collapse = '\n')) + ) + } + if (length(srcref) >= 2) attr(label, "srcref") <- srcref[[2]] + attr(label, "srcfile") <- srcFileOfRef(srcref[[1]]) + label } diff --git a/R/utils.R b/R/utils.R index 39cca5f3f9..49f1a16c66 100644 --- a/R/utils.R +++ b/R/utils.R @@ -404,165 +404,6 @@ getContentType <- function(file, defaultType = 'application/octet-stream') { mime::guess_type(file, unknown = defaultType, subtype = subtype) } -# Create a zero-arg function from a quoted expression and environment -# @examples -# makeFunction(body=quote(print(3))) -makeFunction <- function(args = pairlist(), body, env = parent.frame()) { - eval(call("function", args, body), env) -} - -#' Convert an expression to a function -#' -#' This is to be called from another function, because it will attempt to get -#' an unquoted expression from two calls back. Note: as of Shiny 1.6.0, it is -#' recommended to use [quoToFunction()] instead. -#' -#' If expr is a quoted expression, then this just converts it to a function. -#' If expr is a function, then this simply returns expr (and prints a -#' deprecation message). -#' If expr was a non-quoted expression from two calls back, then this will -#' quote the original expression and convert it to a function. -# -#' @param expr A quoted or unquoted expression, or a function. -#' @param env The desired environment for the function. Defaults to the -#' calling environment two steps back. -#' @param quoted Is the expression quoted? -#' -#' @examples -#' # Example of a new renderer, similar to renderText -#' # This is something that toolkit authors will do -#' renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) { -#' # Convert expr to a function -#' func <- shiny::exprToFunction(expr, env, quoted) -#' -#' function() { -#' value <- func() -#' paste(rep(value, 3), collapse=", ") -#' } -#' } -#' -#' -#' # Example of using the renderer. -#' # This is something that app authors will do. -#' values <- reactiveValues(A="text") -#' -#' \dontrun{ -#' # Create an output object -#' output$tripleA <- renderTriple({ -#' values$A -#' }) -#' } -#' -#' # At the R console, you can experiment with the renderer using isolate() -#' tripleA <- renderTriple({ -#' values$A -#' }) -#' -#' isolate(tripleA()) -#' # "text, text, text" -#' @export -exprToFunction <- function(expr, env=parent.frame(), quoted=FALSE) { - if (!quoted) { - expr <- eval(substitute(substitute(expr)), parent.frame()) - } - - # expr is a quoted expression - makeFunction(body=expr, env=env) -} - -#' Install an expression as a function -#' -#' Installs an expression in the given environment as a function, and registers -#' debug hooks so that breakpoints may be set in the function. Note: as of -#' Shiny 1.6.0, it is recommended to use [quoToFunction()] instead. -#' -#' This function can replace `exprToFunction` as follows: we may use -#' `func <- exprToFunction(expr)` if we do not want the debug hooks, or -#' `installExprFunction(expr, "func")` if we do. Both approaches create a -#' function named `func` in the current environment. -#' -#' @seealso Wraps [exprToFunction()]; see that method's documentation -#' for more documentation and examples. -#' -#' @param expr A quoted or unquoted expression -#' @param name The name the function should be given -#' @param eval.env The desired environment for the function. Defaults to the -#' calling environment two steps back. -#' @param quoted Is the expression quoted? -#' @param assign.env The environment in which the function should be assigned. -#' @param label A label for the object to be shown in the debugger. Defaults to -#' the name of the calling function. -#' @param wrappedWithLabel,..stacktraceon Advanced use only. For stack manipulation purposes; see -#' [stacktrace()]. -#' @export -installExprFunction <- function(expr, name, eval.env = parent.frame(2), - quoted = FALSE, - assign.env = parent.frame(1), - label = deparse(sys.call(-1)[[1]]), - wrappedWithLabel = TRUE, - ..stacktraceon = FALSE) { - if (!quoted) { - quoted <- TRUE - expr <- eval(substitute(substitute(expr)), parent.frame()) - } - - func <- exprToFunction(expr, eval.env, quoted) - if (length(label) > 1) { - # Just in case the deparsed code is more complicated than we imagine. If we - # have a label with length > 1 it causes warnings in wrapFunctionLabel. - label <- paste0(label, collapse = "\n") - } - if (wrappedWithLabel) { - func <- wrapFunctionLabel(func, label, ..stacktraceon = ..stacktraceon) - } else { - registerDebugHook(name, assign.env, label) - } - assign(name, func, envir = assign.env) -} - -#' Convert a quosure to a function for a Shiny render function -#' -#' This takes a quosure and label, and wraps them into a function that should be -#' passed to [createRenderFunction()] or [markRenderFunction()]. -#' -#' This function was added in Shiny 1.6.0. Previously, it was recommended to use -#' [installExprFunction()] or [exprToFunction()] in render functions, but now we -#' recommend using [quoToFunction()], because it does not require `env` and -#' `quoted` arguments -- that information is captured by quosures provided by -#' \pkg{rlang}. -#' -#' @param q A quosure. -#' @inheritParams installExprFunction -#' @seealso [createRenderFunction()] for example usage. -#' -#' @export -quoToFunction <- function(q, label, ..stacktraceon = FALSE) { - q <- as_quosure(q) - func <- as_function(q) - # as_function returns a function that takes `...`. We want one that takes no - # args. - formals(func) <- list() - wrapFunctionLabel(func, label, ..stacktraceon = ..stacktraceon) -} - - -# Utility function for creating a debugging label, given an expression. -# `expr` is a quoted expression. -# `function_name` is the name of the calling function. -# `label` is an optional user-provided label. If NULL, it will be inferred. -exprToLabel <- function(expr, function_name, label = NULL) { - srcref <- attr(expr, "srcref", exact = TRUE) - if (is.null(label)) { - label <- rexprSrcrefToLabel( - srcref[[1]], - sprintf('%s(%s)', function_name, paste(deparse(expr), collapse = '\n')) - ) - } - if (length(srcref) >= 2) attr(label, "srcref") <- srcref[[2]] - attr(label, "srcfile") <- srcFileOfRef(srcref[[1]]) - label -} - #' Parse a GET query string from a URL #' #' Returns a named list of key-value pairs. diff --git a/inst/www/shared/shiny-autoreload.js b/inst/www/shared/shiny-autoreload.js index c4df3d090f..6010fc1d24 100644 --- a/inst/www/shared/shiny-autoreload.js +++ b/inst/www/shared/shiny-autoreload.js @@ -1,3 +1,3 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ (function(){var t="ws:";window.location.protocol==="https:"&&(t="wss:");var o=window.location.pathname;/\/$/.test(o)||(o+="/");o+="autoreload/";var n=new WebSocket(t+"//"+window.location.host+o);n.onmessage=function(a){a.data==="autoreload"&&window.location.reload()};})(); //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjdHMvZXh0cmFzL3NoaW55LWF1dG9yZWxvYWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIGVzbGludC1kaXNhYmxlIHVuaWNvcm4vZmlsZW5hbWUtY2FzZSAqL1xudmFyIHByb3RvY29sID0gXCJ3czpcIjtcbmlmICh3aW5kb3cubG9jYXRpb24ucHJvdG9jb2wgPT09IFwiaHR0cHM6XCIpIHByb3RvY29sID0gXCJ3c3M6XCI7XG52YXIgZGVmYXVsdFBhdGggPSB3aW5kb3cubG9jYXRpb24ucGF0aG5hbWU7XG5pZiAoIS9cXC8kLy50ZXN0KGRlZmF1bHRQYXRoKSkgZGVmYXVsdFBhdGggKz0gXCIvXCI7XG5kZWZhdWx0UGF0aCArPSBcImF1dG9yZWxvYWQvXCI7XG52YXIgd3MgPSBuZXcgV2ViU29ja2V0KHByb3RvY29sICsgXCIvL1wiICsgd2luZG93LmxvY2F0aW9uLmhvc3QgKyBkZWZhdWx0UGF0aCk7XG5cbndzLm9ubWVzc2FnZSA9IGZ1bmN0aW9uIChldmVudCkge1xuICBpZiAoZXZlbnQuZGF0YSA9PT0gXCJhdXRvcmVsb2FkXCIpIHtcbiAgICB3aW5kb3cubG9jYXRpb24ucmVsb2FkKCk7XG4gIH1cbn07XG5cbmV4cG9ydCB7fTsiXSwKICAibWFwcGluZ3MiOiAiO1lBQ0EsR0FBSSxHQUFXLE1BQ2YsQUFBSSxPQUFPLFNBQVMsV0FBYSxVQUFVLEdBQVcsUUFDdEQsR0FBSSxHQUFjLE9BQU8sU0FBUyxTQUNsQyxBQUFLLE1BQU0sS0FBSyxJQUFjLElBQWUsS0FDN0MsR0FBZSxjQUNmLEdBQUksR0FBSyxHQUFJLFdBQVUsRUFBVyxLQUFPLE9BQU8sU0FBUyxLQUFPLEdBRWhFLEVBQUcsVUFBWSxTQUFVLEVBQU8sQ0FDOUIsQUFBSSxFQUFNLE9BQVMsY0FDakIsT0FBTyxTQUFTIiwKICAibmFtZXMiOiBbXQp9Cg== diff --git a/inst/www/shared/shiny-showcase.css b/inst/www/shared/shiny-showcase.css index 50ff493bfa..1355a3d7e0 100644 --- a/inst/www/shared/shiny-showcase.css +++ b/inst/www/shared/shiny-showcase.css @@ -1,2 +1,2 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ #showcase-well{border-radius:0}.shiny-code{background-color:#fff;margin-bottom:0}.shiny-code code{font-family:Menlo,Consolas,"Courier New",monospace}.shiny-code-container{margin-top:20px;clear:both}.shiny-code-container h3{display:inline;margin-right:15px}.showcase-header{font-size:16px;font-weight:normal}.showcase-code-link{text-align:right;padding:15px}#showcase-app-container{vertical-align:top}#showcase-code-tabs{margin-right:15px}#showcase-code-tabs pre{border:none;line-height:1em}#showcase-code-tabs .nav{margin-bottom:0}#showcase-code-tabs ul{margin-bottom:0}#showcase-code-tabs .tab-content{border-style:solid;border-color:#e5e5e5;border-width:0px 1px 1px 1px;overflow:auto;border-bottom-right-radius:4px;border-bottom-left-radius:4px}#showcase-app-code{width:100%}#showcase-code-position-toggle{float:right}#showcase-sxs-code{padding-top:20px;vertical-align:top}.showcase-code-license{display:block;text-align:right}#showcase-code-content pre{background-color:#fff} diff --git a/inst/www/shared/shiny-showcase.js b/inst/www/shared/shiny-showcase.js index 0fe87bc964..dd405c844e 100644 --- a/inst/www/shared/shiny-showcase.js +++ b/inst/www/shared/shiny-showcase.js @@ -1,3 +1,3 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ (function(){var en=Object.create;var ee=Object.defineProperty;var rn=Object.getOwnPropertyDescriptor;var tn=Object.getOwnPropertyNames;var nn=Object.getPrototypeOf,an=Object.prototype.hasOwnProperty;var on=function(e){return ee(e,"__esModule",{value:!0})};var l=function(e,r){return function(){return r||e((r={exports:{}}).exports,r),r.exports}};var ln=function(e,r,t){if(r&&typeof r=="object"||typeof r=="function")for(var n=tn(r),i=0,a=n.length,o;i0?gi:pi)(e)}});var me=l(function(qo,Ur){var yi=_(),hi=Math.min;Ur.exports=function(e){return e>0?hi(yi(e),9007199254740991):0}});var Wr=l(function(So,kr){var bi=_(),xi=Math.max,mi=Math.min;kr.exports=function(e,r){var t=bi(e);return t<0?xi(t+r,0):mi(t,r)}});var Kr=l(function(wo,Gr){var Ei=B(),qi=me(),Si=Wr(),Hr=function(e){return function(r,t,n){var i=Ei(r),a=qi(i.length),o=Si(n,a),s;if(e&&t!=t){for(;a>o;)if(s=i[o++],s!=s)return!0}else for(;a>o;o++)if((e||o in i)&&i[o]===t)return e||o||0;return!e&&-1}};Gr.exports={includes:Hr(!0),indexOf:Hr(!1)}});var Xr=l(function(Io,zr){var Ee=m(),wi=B(),Ii=Kr().indexOf,Pi=ve();zr.exports=function(e,r){var t=wi(e),n=0,i=[],a;for(a in t)!Ee(Pi,a)&&Ee(t,a)&&i.push(a);for(;r.length>n;)Ee(t,a=r[n++])&&(~Ii(i,a)||i.push(a));return i}});var Jr=l(function(Po,Yr){Yr.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]});var Qr=l(function(Zr){var Oi=Xr(),ji=Jr(),Ti=ji.concat("length","prototype");Zr.f=Object.getOwnPropertyNames||function(r){return Oi(r,Ti)}});var et=l(function(Vr){Vr.f=Object.getOwnPropertySymbols});var tt=l(function(To,rt){var _i=xe(),Ci=Qr(),Ri=et(),Ai=j();rt.exports=_i("Reflect","ownKeys")||function(r){var t=Ci.f(Ai(r)),n=Ri.f;return n?t.concat(n(r)):t}});var it=l(function(_o,nt){var Ni=m(),Di=tt(),Mi=le(),Bi=se();nt.exports=function(e,r){for(var t=Di(r),n=Bi.f,i=Mi.f,a=0;a0&&(!t.multiline||t.multiline&&r[t.lastIndex-1]!=="\n")&&(f="(?: "+f+")",c=" "+c,v++),i=new RegExp("^(?:"+f+")",u)),Ie&&(i=new RegExp("^"+f+"$(?!\\s)",u)),we&&(n=t.lastIndex),a=G.call(s?i:t,c),s?a?(a.input=a.input.slice(v),a[0]=a[0].slice(v),a.index=t.lastIndex,t.lastIndex+=a[0].length):t.lastIndex=0:we&&a&&(t.lastIndex=t.global?a.index+a[0].length:n),Ie&&a&&a.length>1&&Vi.call(a[0],i,function(){for(o=1;o=74)&&(h=Oe.match(/Chrome\/(\d+)/),h&&(z=h[1])));wt.exports=z&&+z});var je=l(function($o,Ot){var Pt=It(),ia=b();Ot.exports=!!Object.getOwnPropertySymbols&&!ia(function(){var e=Symbol();return!String(e)||!(Object(e)instanceof Symbol)||!Symbol.sham&&Pt&&Pt<41})});var Tt=l(function(Uo,jt){var aa=je();jt.exports=aa&&!Symbol.sham&&typeof Symbol.iterator=="symbol"});var At=l(function(ko,Rt){var oa=g(),la=k(),_t=m(),sa=fe(),Ct=je(),ua=Tt(),R=la("wks"),A=oa.Symbol,ca=ua?A:A&&A.withoutSetter||sa;Rt.exports=function(e){return(!_t(R,e)||!(Ct||typeof R[e]=="string"))&&(Ct&&_t(A,e)?R[e]=A[e]:R[e]=ca("Symbol."+e)),R[e]}});var Ft=l(function(Wo,Lt){"use strict";Pe();var Nt=ye(),fa=K(),X=b(),Te=At(),va=q(),da=Te("species"),_e=RegExp.prototype,pa=!X(function(){var e=/./;return e.exec=function(){var r=[];return r.groups={a:"7"},r},"".replace(e,"$")!=="7"}),Dt=function(){return"a".replace(/./,"$0")==="$0"}(),Mt=Te("replace"),Bt=function(){return/./[Mt]?/./[Mt]("a","$0")==="":!1}(),ga=!X(function(){var e=/(?:)/,r=e.exec;e.exec=function(){return r.apply(this,arguments)};var t="ab".split(e);return t.length!==2||t[0]!=="a"||t[1]!=="b"});Lt.exports=function(e,r,t,n){var i=Te(e),a=!X(function(){var c={};return c[i]=function(){return 7},""[e](c)!=7}),o=a&&!X(function(){var c=!1,d=/a/;return e==="split"&&(d={},d.constructor={},d.constructor[da]=function(){return d},d.flags="",d[i]=/./[i]),d.exec=function(){return c=!0,null},d[i](""),!c});if(!a||!o||e==="replace"&&!(pa&&Dt&&!Bt)||e==="split"&&!ga){var s=/./[i],u=t(i,""[e],function(c,d,y,N,S){var p=d.exec;return p===fa||p===_e.exec?a&&!S?{done:!0,value:s.call(d,y,N)}:{done:!0,value:c.call(y,d,N)}:{done:!1}},{REPLACE_KEEPS_$0:Dt,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:Bt}),f=u[0],v=u[1];Nt(String.prototype,e,f),Nt(_e,i,r==2?function(c,d){return v.call(c,this,d)}:function(c){return v.call(c,this)})}n&&va(_e[i],"sham",!0)}});var kt=l(function(Ho,Ut){var ya=_(),ha=P(),$t=function(e){return function(r,t){var n=String(ha(r)),i=ya(t),a=n.length,o,s;return i<0||i>=a?e?"":void 0:(o=n.charCodeAt(i),o<55296||o>56319||i+1===a||(s=n.charCodeAt(i+1))<56320||s>57343?e?n.charAt(i):o:e?n.slice(i,i+2):(o-55296<<10)+(s-56320)+65536)}};Ut.exports={codeAt:$t(!1),charAt:$t(!0)}});var Ht=l(function(Go,Wt){"use strict";var ba=kt().charAt;Wt.exports=function(e,r,t){return r+(t?ba(e,r).length:1)}});var Kt=l(function(Ko,Gt){var xa=ie(),ma=Math.floor,Ea="".replace,qa=/\$([$&'`]|\d{1,2}|<[^>]*>)/g,Sa=/\$([$&'`]|\d{1,2})/g;Gt.exports=function(e,r,t,n,i,a){var o=t+e.length,s=n.length,u=Sa;return i!==void 0&&(i=xa(i),u=qa),Ea.call(a,u,function(f,v){var c;switch(v.charAt(0)){case"$":return"$";case"&":return e;case"`":return r.slice(0,t);case"'":return r.slice(o);case"<":c=i[v.slice(1,-1)];break;default:var d=+v;if(d===0)return f;if(d>s){var y=ma(d/10);return y===0?f:y<=s?n[y-1]===void 0?v.charAt(1):n[y-1]+v.charAt(1):f}c=n[d-1]}return c===void 0?"":c})}});var Xt=l(function(zo,zt){var wa=te(),Ia=K();zt.exports=function(e,r){var t=e.exec;if(typeof t=="function"){var n=t.call(e,r);if(typeof n!="object")throw TypeError("RegExp exec method returned something other than an Object or null");return n}if(wa(e)!=="RegExp")throw TypeError("RegExp#exec called on incompatible receiver");return Ia.call(e,r)}});var Jo=sn(Pe());"use strict";var Pa=Ft(),Oa=j(),ja=me(),Ta=_(),_a=P(),Ca=Ht(),Ra=Kt(),Aa=Xt(),Na=Math.max,Da=Math.min,Ma=function(e){return e===void 0?e:String(e)};Pa("replace",2,function(e,r,t,n){var i=n.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,a=n.REPLACE_KEEPS_$0,o=i?"$":"$0";return[function(u,f){var v=_a(this),c=u==null?void 0:u[e];return c!==void 0?c.call(u,v,f):r.call(String(v),u,f)},function(s,u){if(!i&&a||typeof u=="string"&&u.indexOf(o)===-1){var f=t(r,s,this,u);if(f.done)return f.value}var v=Oa(s),c=String(this),d=typeof u=="function";d||(u=String(u));var y=v.global;if(y){var N=v.unicode;v.lastIndex=0}for(var S=[];;){var p=Aa(v,c);if(p===null||(S.push(p),!y))break;var Vt=String(p[0]);Vt===""&&(v.lastIndex=Ca(c,ja(v.lastIndex),N))}for(var Ne="",D=0,Y=0;Y=D&&(Ne+=c.slice(D,w)+Me,D=w+J.length)}return Ne+c.slice(D)}]});var Yt=400;function Ce(e,r){var t=0;if(e.nodeType===3){var n=e.nodeValue.replace(/\n/g,"").length;if(n>=r)return{element:e,offset:r};t+=n}else if(e.nodeType===1&&e.firstChild){var i=Ce(e.firstChild,r);if(i.element!==null)return i;t+=i.offset}return e.nextSibling?Ce(e.nextSibling,r-t):{element:null,offset:t}}function Re(e,r,t){for(var n=0,i=0;i show below':' show with app'}),r&&$(document.body).animate({scrollTop:0},n),Ae=r,Zt(r&&t),$(window).trigger("resize")};function Zt(e){var r=960,t=r,n=1,i=document.getElementById("showcase-app-code").offsetWidth;i/2>r?t=i/2:i*.66>r?t=960:(t=i*.66,n=t/r);var a=document.getElementById("showcase-app-container");$(a).animate({width:t+"px",zoom:n*100+"%"},e?Yt:0)}var La=function(){Jt(!Ae,!0)},Fa=function(){document.body.offsetWidth>1350&&Jt(!0,!1)};function Qt(){document.getElementById("showcase-code-content").style.height=$(window).height()+"px"}function $a(){var e=document.getElementById("showcase-markdown-content");if(e!==null){var r=e.innerText||e.innerHTML,t=window.Showdown.converter;document.getElementById("readme-md").innerHTML=new t().makeHtml(r)}}$(window).resize(function(){Ae&&(Zt(!1),Qt())});window.toggleCodePosition=La;$(window).on("load",Fa);$(window).on("load",$a);window.hljs&&window.hljs.initHighlightingOnLoad();})(); //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../node_modules/core-js/internals/global.js", "../../../node_modules/core-js/internals/fails.js", "../../../node_modules/core-js/internals/descriptors.js", "../../../node_modules/core-js/internals/object-property-is-enumerable.js", "../../../node_modules/core-js/internals/create-property-descriptor.js", "../../../node_modules/core-js/internals/classof-raw.js", "../../../node_modules/core-js/internals/indexed-object.js", "../../../node_modules/core-js/internals/require-object-coercible.js", "../../../node_modules/core-js/internals/to-indexed-object.js", "../../../node_modules/core-js/internals/is-object.js", "../../../node_modules/core-js/internals/to-primitive.js", "../../../node_modules/core-js/internals/to-object.js", "../../../node_modules/core-js/internals/has.js", "../../../node_modules/core-js/internals/document-create-element.js", "../../../node_modules/core-js/internals/ie8-dom-define.js", "../../../node_modules/core-js/internals/object-get-own-property-descriptor.js", "../../../node_modules/core-js/internals/an-object.js", "../../../node_modules/core-js/internals/object-define-property.js", "../../../node_modules/core-js/internals/create-non-enumerable-property.js", "../../../node_modules/core-js/internals/set-global.js", "../../../node_modules/core-js/internals/shared-store.js", "../../../node_modules/core-js/internals/inspect-source.js", "../../../node_modules/core-js/internals/native-weak-map.js", "../../../node_modules/core-js/internals/is-pure.js", "../../../node_modules/core-js/internals/shared.js", "../../../node_modules/core-js/internals/uid.js", "../../../node_modules/core-js/internals/shared-key.js", "../../../node_modules/core-js/internals/hidden-keys.js", "../../../node_modules/core-js/internals/internal-state.js", "../../../node_modules/core-js/internals/redefine.js", "../../../node_modules/core-js/internals/path.js", "../../../node_modules/core-js/internals/get-built-in.js", "../../../node_modules/core-js/internals/to-integer.js", "../../../node_modules/core-js/internals/to-length.js", "../../../node_modules/core-js/internals/to-absolute-index.js", "../../../node_modules/core-js/internals/array-includes.js", "../../../node_modules/core-js/internals/object-keys-internal.js", "../../../node_modules/core-js/internals/enum-bug-keys.js", "../../../node_modules/core-js/internals/object-get-own-property-names.js", "../../../node_modules/core-js/internals/object-get-own-property-symbols.js", "../../../node_modules/core-js/internals/own-keys.js", "../../../node_modules/core-js/internals/copy-constructor-properties.js", "../../../node_modules/core-js/internals/is-forced.js", "../../../node_modules/core-js/internals/export.js", "../../../node_modules/core-js/internals/regexp-flags.js", "../../../node_modules/core-js/internals/regexp-sticky-helpers.js", "../../../node_modules/core-js/internals/regexp-exec.js", "../../../node_modules/core-js/modules/es.regexp.exec.js", "../../../node_modules/core-js/internals/engine-user-agent.js", "../../../node_modules/core-js/internals/engine-v8-version.js", "../../../node_modules/core-js/internals/native-symbol.js", "../../../node_modules/core-js/internals/use-symbol-as-uid.js", "../../../node_modules/core-js/internals/well-known-symbol.js", "../../../node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js", "../../../node_modules/core-js/internals/string-multibyte.js", "../../../node_modules/core-js/internals/advance-string-index.js", "../../../node_modules/core-js/internals/get-substitution.js", "../../../node_modules/core-js/internals/regexp-exec-abstract.js", "../../../srcts/extras/shiny-showcase.ts", "../../../node_modules/core-js/modules/es.string.replace.js"],
  "sourcesContent": ["var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n", "module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n", "var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n", "'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n", "module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n", "var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n", "var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n", "// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n", "// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n", "module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n", "var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n", "var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n", "var toObject = require('../internals/to-object');\n\nvar hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty.call(toObject(it), key);\n};\n", "var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n", "var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n", "var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n", "var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n", "var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n", "var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n", "var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n", "var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n", "var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n", "var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n", "module.exports = false;\n", "var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.14.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '\u00A9 2021 Denis Pushkarev (zloirock.ru)'\n});\n", "var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n", "var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n", "module.exports = {};\n", "var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n", "var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var state;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) {\n      createNonEnumerableProperty(value, 'name', key);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n", "var global = require('../internals/global');\n\nmodule.exports = global;\n", "var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n", "var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.es/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n", "var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n", "var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n", "var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n", "var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n", "// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n", "var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n", "// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n", "var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n", "var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n", "var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n", "var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n", "'use strict';\nvar anObject = require('../internals/an-object');\n\n// `RegExp.prototype.flags` getter implementation\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags\nmodule.exports = function () {\n  var that = anObject(this);\n  var result = '';\n  if (that.global) result += 'g';\n  if (that.ignoreCase) result += 'i';\n  if (that.multiline) result += 'm';\n  if (that.dotAll) result += 's';\n  if (that.unicode) result += 'u';\n  if (that.sticky) result += 'y';\n  return result;\n};\n", "'use strict';\n\nvar fails = require('./fails');\n\n// babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError,\n// so we use an intermediate function.\nfunction RE(s, f) {\n  return RegExp(s, f);\n}\n\nexports.UNSUPPORTED_Y = fails(function () {\n  // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError\n  var re = RE('a', 'y');\n  re.lastIndex = 2;\n  return re.exec('abcd') != null;\n});\n\nexports.BROKEN_CARET = fails(function () {\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687\n  var re = RE('^r', 'gy');\n  re.lastIndex = 2;\n  return re.exec('str') != null;\n});\n", "'use strict';\n/* eslint-disable regexp/no-assertion-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */\n/* eslint-disable regexp/no-useless-quantifier -- testing */\nvar regexpFlags = require('./regexp-flags');\nvar stickyHelpers = require('./regexp-sticky-helpers');\nvar shared = require('./shared');\n\nvar nativeExec = RegExp.prototype.exec;\nvar nativeReplace = shared('native-string-replace', String.prototype.replace);\n\nvar patchedExec = nativeExec;\n\nvar UPDATES_LAST_INDEX_WRONG = (function () {\n  var re1 = /a/;\n  var re2 = /b*/g;\n  nativeExec.call(re1, 'a');\n  nativeExec.call(re2, 'a');\n  return re1.lastIndex !== 0 || re2.lastIndex !== 0;\n})();\n\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y || stickyHelpers.BROKEN_CARET;\n\n// nonparticipating capturing group, copied from es5-shim's String#split patch.\nvar NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;\n\nvar PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y;\n\nif (PATCH) {\n  patchedExec = function exec(str) {\n    var re = this;\n    var lastIndex, reCopy, match, i;\n    var sticky = UNSUPPORTED_Y && re.sticky;\n    var flags = regexpFlags.call(re);\n    var source = re.source;\n    var charsAdded = 0;\n    var strCopy = str;\n\n    if (sticky) {\n      flags = flags.replace('y', '');\n      if (flags.indexOf('g') === -1) {\n        flags += 'g';\n      }\n\n      strCopy = String(str).slice(re.lastIndex);\n      // Support anchored sticky behavior.\n      if (re.lastIndex > 0 && (!re.multiline || re.multiline && str[re.lastIndex - 1] !== '\\n')) {\n        source = '(?: ' + source + ')';\n        strCopy = ' ' + strCopy;\n        charsAdded++;\n      }\n      // ^(? + rx + ) is needed, in combination with some str slicing, to\n      // simulate the 'y' flag.\n      reCopy = new RegExp('^(?:' + source + ')', flags);\n    }\n\n    if (NPCG_INCLUDED) {\n      reCopy = new RegExp('^' + source + '$(?!\\\\s)', flags);\n    }\n    if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;\n\n    match = nativeExec.call(sticky ? reCopy : re, strCopy);\n\n    if (sticky) {\n      if (match) {\n        match.input = match.input.slice(charsAdded);\n        match[0] = match[0].slice(charsAdded);\n        match.index = re.lastIndex;\n        re.lastIndex += match[0].length;\n      } else re.lastIndex = 0;\n    } else if (UPDATES_LAST_INDEX_WRONG && match) {\n      re.lastIndex = re.global ? match.index + match[0].length : lastIndex;\n    }\n    if (NPCG_INCLUDED && match && match.length > 1) {\n      // Fix browsers whose `exec` methods don't consistently return `undefined`\n      // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/\n      nativeReplace.call(match[0], reCopy, function () {\n        for (i = 1; i < arguments.length - 2; i++) {\n          if (arguments[i] === undefined) match[i] = undefined;\n        }\n      });\n    }\n\n    return match;\n  };\n}\n\nmodule.exports = patchedExec;\n", "'use strict';\nvar $ = require('../internals/export');\nvar exec = require('../internals/regexp-exec');\n\n// `RegExp.prototype.exec` method\n// https://tc39.es/ecma262/#sec-regexp.prototype.exec\n$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {\n  exec: exec\n});\n", "var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n", "var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  version = match[0] < 4 ? 1 : match[0] + match[1];\n} else if (userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = match[1];\n  }\n}\n\nmodule.exports = version && +version;\n", "/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n", "/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n", "var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n", "'use strict';\n// TODO: Remove from `core-js@4` since it's moved to entry points\nrequire('../modules/es.regexp.exec');\nvar redefine = require('../internals/redefine');\nvar regexpExec = require('../internals/regexp-exec');\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar SPECIES = wellKnownSymbol('species');\nvar RegExpPrototype = RegExp.prototype;\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n  // #replace needs built-in support for named groups.\n  // #match works fine because it just return the exec results, even if it has\n  // a \"grops\" property.\n  var re = /./;\n  re.exec = function () {\n    var result = [];\n    result.groups = { a: '7' };\n    return result;\n  };\n  return ''.replace(re, '$<a>') !== '7';\n});\n\n// IE <= 11 replaces $0 with the whole match, as if it was $&\n// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0\nvar REPLACE_KEEPS_$0 = (function () {\n  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing\n  return 'a'.replace(/./, '$0') === '$0';\n})();\n\nvar REPLACE = wellKnownSymbol('replace');\n// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string\nvar REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {\n  if (/./[REPLACE]) {\n    return /./[REPLACE]('a', '$0') === '';\n  }\n  return false;\n})();\n\n// Chrome 51 has a buggy \"split\" implementation when RegExp#exec !== nativeExec\n// Weex JS has frozen built-in prototypes, so use try / catch wrapper\nvar SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {\n  // eslint-disable-next-line regexp/no-empty-group -- required for testing\n  var re = /(?:)/;\n  var originalExec = re.exec;\n  re.exec = function () { return originalExec.apply(this, arguments); };\n  var result = 'ab'.split(re);\n  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';\n});\n\nmodule.exports = function (KEY, length, exec, sham) {\n  var SYMBOL = wellKnownSymbol(KEY);\n\n  var DELEGATES_TO_SYMBOL = !fails(function () {\n    // String methods call symbol-named RegEp methods\n    var O = {};\n    O[SYMBOL] = function () { return 7; };\n    return ''[KEY](O) != 7;\n  });\n\n  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {\n    // Symbol-named RegExp methods call .exec\n    var execCalled = false;\n    var re = /a/;\n\n    if (KEY === 'split') {\n      // We can't use real regex here since it causes deoptimization\n      // and serious performance degradation in V8\n      // https://github.com/zloirock/core-js/issues/306\n      re = {};\n      // RegExp[@@split] doesn't call the regex's exec method, but first creates\n      // a new one. We need to return the patched regex when creating the new one.\n      re.constructor = {};\n      re.constructor[SPECIES] = function () { return re; };\n      re.flags = '';\n      re[SYMBOL] = /./[SYMBOL];\n    }\n\n    re.exec = function () { execCalled = true; return null; };\n\n    re[SYMBOL]('');\n    return !execCalled;\n  });\n\n  if (\n    !DELEGATES_TO_SYMBOL ||\n    !DELEGATES_TO_EXEC ||\n    (KEY === 'replace' && !(\n      REPLACE_SUPPORTS_NAMED_GROUPS &&\n      REPLACE_KEEPS_$0 &&\n      !REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE\n    )) ||\n    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)\n  ) {\n    var nativeRegExpMethod = /./[SYMBOL];\n    var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {\n      var $exec = regexp.exec;\n      if ($exec === regexpExec || $exec === RegExpPrototype.exec) {\n        if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n          // The native String method already delegates to @@method (this\n          // polyfilled function), leasing to infinite recursion.\n          // We avoid it by directly calling the native @@method method.\n          return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };\n        }\n        return { done: true, value: nativeMethod.call(str, regexp, arg2) };\n      }\n      return { done: false };\n    }, {\n      REPLACE_KEEPS_$0: REPLACE_KEEPS_$0,\n      REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE: REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE\n    });\n    var stringMethod = methods[0];\n    var regexMethod = methods[1];\n\n    redefine(String.prototype, KEY, stringMethod);\n    redefine(RegExpPrototype, SYMBOL, length == 2\n      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)\n      // 21.2.5.11 RegExp.prototype[@@split](string, limit)\n      ? function (string, arg) { return regexMethod.call(string, this, arg); }\n      // 21.2.5.6 RegExp.prototype[@@match](string)\n      // 21.2.5.9 RegExp.prototype[@@search](string)\n      : function (string) { return regexMethod.call(string, this); }\n    );\n  }\n\n  if (sham) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);\n};\n", "var toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.{ codePointAt, at }` methods implementation\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = String(requireObjectCoercible($this));\n    var position = toInteger(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = S.charCodeAt(position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING ? S.charAt(position) : first\n        : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n", "'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\n\n// `AdvanceStringIndex` abstract operation\n// https://tc39.es/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n  return index + (unicode ? charAt(S, index).length : 1);\n};\n", "var toObject = require('../internals/to-object');\n\nvar floor = Math.floor;\nvar replace = ''.replace;\nvar SUBSTITUTION_SYMBOLS = /\\$([$&'`]|\\d{1,2}|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&'`]|\\d{1,2})/g;\n\n// `GetSubstitution` abstract operation\n// https://tc39.es/ecma262/#sec-getsubstitution\nmodule.exports = function (matched, str, position, captures, namedCaptures, replacement) {\n  var tailPos = position + matched.length;\n  var m = captures.length;\n  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n  if (namedCaptures !== undefined) {\n    namedCaptures = toObject(namedCaptures);\n    symbols = SUBSTITUTION_SYMBOLS;\n  }\n  return replace.call(replacement, symbols, function (match, ch) {\n    var capture;\n    switch (ch.charAt(0)) {\n      case '$': return '$';\n      case '&': return matched;\n      case '`': return str.slice(0, position);\n      case \"'\": return str.slice(tailPos);\n      case '<':\n        capture = namedCaptures[ch.slice(1, -1)];\n        break;\n      default: // \\d\\d?\n        var n = +ch;\n        if (n === 0) return match;\n        if (n > m) {\n          var f = floor(n / 10);\n          if (f === 0) return match;\n          if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);\n          return match;\n        }\n        capture = captures[n - 1];\n    }\n    return capture === undefined ? '' : capture;\n  });\n};\n", "var classof = require('./classof-raw');\nvar regexpExec = require('./regexp-exec');\n\n// `RegExpExec` abstract operation\n// https://tc39.es/ecma262/#sec-regexpexec\nmodule.exports = function (R, S) {\n  var exec = R.exec;\n  if (typeof exec === 'function') {\n    var result = exec.call(R, S);\n    if (typeof result !== 'object') {\n      throw TypeError('RegExp exec method returned something other than an Object or null');\n    }\n    return result;\n  }\n\n  if (classof(R) !== 'RegExp') {\n    throw TypeError('RegExp#exec called on incompatible receiver');\n  }\n\n  return regexpExec.call(R, S);\n};\n\n", "import \"core-js/modules/es.regexp.exec.js\";\nimport \"core-js/modules/es.string.replace.js\";\n\n/* eslint-disable unicorn/filename-case */\nimport \"./globalShiny\";\nvar animateMs = 400; // Given a DOM node and a column (count of characters), walk recursively\n// through the node's siblings counting characters until the given number\n// of characters have been found.\n//\n// If the given count is bigger than the number of characters contained by\n// the node and its siblings, returns a null node and the number of\n// characters found.\n\nfunction findTextColPoint(node, col) {\n  var cols = 0;\n\n  if (node.nodeType === 3) {\n    var nchar = node.nodeValue.replace(/\\n/g, \"\").length;\n\n    if (nchar >= col) {\n      return {\n        element: node,\n        offset: col\n      };\n    } else {\n      cols += nchar;\n    }\n  } else if (node.nodeType === 1 && node.firstChild) {\n    var ret = findTextColPoint(node.firstChild, col);\n\n    if (ret.element !== null) {\n      return ret;\n    } else {\n      cols += ret.offset;\n    }\n  }\n\n  if (node.nextSibling) return findTextColPoint(node.nextSibling, col - cols);else return {\n    element: null,\n    offset: cols\n  };\n} // Returns an object indicating the element containing the given line and\n// column of text, and the offset into that element where the text was found.\n//\n// If the given line and column are not found, returns a null element and\n// the number of lines found.\n\n\nfunction findTextPoint(el, line, col) {\n  var newlines = 0;\n\n  for (var childId = 0; childId < el.childNodes.length; childId++) {\n    var child = el.childNodes[childId]; // If this is a text node, count the number of newlines it contains.\n\n    if (child.nodeType === 3) {\n      // TEXT_NODE\n      var newlinere = /\\n/g;\n      var match = void 0;\n\n      while ((match = newlinere.exec(child.nodeValue)) !== null) {\n        newlines++; // Found the desired line, now find the column.\n\n        if (newlines === line) {\n          return findTextColPoint(child, match.index + col + 1);\n        }\n      }\n    } // If this is not a text node, descend recursively to see how many\n    // lines it contains.\n    else if (child.nodeType === 1) {\n        // ELEMENT_NODE\n        var ret = findTextPoint(child, line - newlines, col);\n        if (ret.element !== null) return ret;else newlines += ret.offset;\n      }\n  }\n\n  return {\n    element: null,\n    offset: newlines\n  };\n} // Draw a highlight effect for the given source ref. srcref is assumed to be\n// an integer array of length 6, following the standard R format for source\n// refs.\n\n\nfunction highlightSrcref(srcref, srcfile) {\n  // Check to see if the browser supports text ranges (IE8 doesn't)\n  if (!document.createRange) return; // Check to see if we already have a marker for this source ref\n\n  var el = document.getElementById(\"srcref_\" + srcref);\n\n  if (!el) {\n    // We don't have a marker, create one\n    el = document.createElement(\"span\");\n    el.id = \"srcref_\" + srcref;\n    var ref = srcref;\n    var code = document.getElementById(srcfile.replace(/\\./g, \"_\") + \"_code\"); // if there is no code file (might be a shiny file), quit early\n\n    if (!code) return;\n    var start = findTextPoint(code, ref[0], ref[4]);\n    var end = findTextPoint(code, ref[2], ref[5]); // If the insertion point can't be found, bail out now\n\n    if (start.element === null || end.element === null) return;\n    var range = document.createRange(); // If the text points are inside different <SPAN>s, we may not be able to\n    // surround them without breaking apart the elements to keep the DOM tree\n    // intact. Just move the selection points to encompass the contents of\n    // the SPANs.\n\n    if (start.element.parentNode.nodeName === \"SPAN\" && start.element !== end.element) {\n      range.setStartBefore(start.element.parentNode);\n    } else {\n      range.setStart(start.element, start.offset);\n    }\n\n    if (end.element.parentNode.nodeName === \"SPAN\" && start.element !== end.element) {\n      range.setEndAfter(end.element.parentNode);\n    } else {\n      range.setEnd(end.element, end.offset);\n    }\n\n    range.surroundContents(el);\n  } // End any previous highlight before starting this one\n\n\n  $(el).stop(true, true).effect(\"highlight\", null, 1600);\n} // If this is the main Shiny window, wire up our custom message handler.\n// TODO-barret, this should work\n\n\nif (Shiny) {\n  Shiny.addCustomMessageHandler(\"showcase-src\", function (message) {\n    if (message.srcref && message.srcfile) {\n      highlightSrcref(message.srcref, message.srcfile);\n    }\n  });\n}\n\nvar isCodeAbove = false;\n\nvar setCodePosition = function setCodePosition(above, animate) {\n  var animateCodeMs = animate ? animateMs : 1; // set the source and targets for the tab move\n\n  var newHostElement = above ? document.getElementById(\"showcase-sxs-code\") : document.getElementById(\"showcase-code-inline\");\n  var currentHostElement = above ? document.getElementById(\"showcase-code-inline\") : document.getElementById(\"showcase-sxs-code\");\n  var metadataElement = document.getElementById(\"showcase-app-metadata\");\n\n  if (metadataElement === null) {\n    // if there's no app metadata, show and hide the entire well container\n    // when the code changes position\n    var wellElement = $(\"#showcase-well\");\n\n    if (above) {\n      wellElement.fadeOut(animateCodeMs);\n    } else {\n      wellElement.fadeIn(animateCodeMs);\n    }\n  } // hide the new element before doing anything to it\n\n\n  $(newHostElement).hide();\n  $(currentHostElement).fadeOut(animateCodeMs, function () {\n    var tabs = document.getElementById(\"showcase-code-tabs\");\n    currentHostElement.removeChild(tabs);\n    newHostElement.appendChild(tabs); // remove or set the height of the code\n\n    if (above) {\n      setCodeHeightFromDocHeight();\n    } else {\n      document.getElementById(\"showcase-code-content\").removeAttribute(\"style\");\n    }\n\n    $(newHostElement).fadeIn(animateCodeMs);\n\n    if (!above) {\n      // remove the applied width and zoom on the app container, and\n      // scroll smoothly down to the code's new home\n      document.getElementById(\"showcase-app-container\").removeAttribute(\"style\");\n      if (animate) $(document.body).animate({\n        scrollTop: $(newHostElement).offset().top\n      });\n    } // if there's a readme, move it either alongside the code or beneath\n    // the app\n\n\n    var readme = document.getElementById(\"readme-md\");\n\n    if (readme !== null) {\n      readme.parentElement.removeChild(readme);\n\n      if (above) {\n        currentHostElement.appendChild(readme);\n        $(currentHostElement).fadeIn(animateCodeMs);\n      } else document.getElementById(\"showcase-app-metadata\").appendChild(readme);\n    } // change the text on the toggle button to reflect the new state\n\n\n    document.getElementById(\"showcase-code-position-toggle\").innerHTML = above ? '<i class=\"fa fa-level-down\"></i> show below' : '<i class=\"fa fa-level-up\"></i> show with app';\n  });\n\n  if (above) {\n    $(document.body).animate({\n      scrollTop: 0\n    }, animateCodeMs);\n  }\n\n  isCodeAbove = above;\n  setAppCodeSxsWidths(above && animate);\n  $(window).trigger(\"resize\");\n};\n\nfunction setAppCodeSxsWidths(animate) {\n  var appTargetWidth = 960;\n  var appWidth = appTargetWidth;\n  var zoom = 1.0;\n  var totalWidth = document.getElementById(\"showcase-app-code\").offsetWidth;\n\n  if (totalWidth / 2 > appTargetWidth) {\n    // If the app can use only half the available space and still meet its\n    // target, take half the available space.\n    appWidth = totalWidth / 2;\n  } else if (totalWidth * 0.66 > appTargetWidth) {\n    // If the app can meet its target by taking up more space (up to 66%\n    // of its container), take up more space.\n    appWidth = 960;\n  } else {\n    // The space is too narrow for the app and code to live side-by-side\n    // in a friendly way. Keep the app at 2/3 of the space but scale it.\n    appWidth = totalWidth * 0.66;\n    zoom = appWidth / appTargetWidth;\n  }\n\n  var app = document.getElementById(\"showcase-app-container\");\n  $(app).animate({\n    width: appWidth + \"px\",\n    zoom: zoom * 100 + \"%\"\n  }, animate ? animateMs : 0);\n}\n\nvar toggleCodePosition = function toggleCodePosition() {\n  setCodePosition(!isCodeAbove, true);\n}; // if the browser is sized to wider than 1350px, show the code next to the\n// app by default\n\n\nvar setInitialCodePosition = function setInitialCodePosition() {\n  if (document.body.offsetWidth > 1350) {\n    setCodePosition(true, false);\n  }\n}; // make the code scrollable to about the height of the browser, less space\n// for the tabs\n\n\nfunction setCodeHeightFromDocHeight() {\n  document.getElementById(\"showcase-code-content\").style.height = $(window).height() + \"px\";\n} // if there's a block of markdown content, render it to HTML\n\n\nfunction renderMarkdown() {\n  var mdContent = document.getElementById(\"showcase-markdown-content\");\n\n  if (mdContent !== null) {\n    // IE8 puts the content of <script> tags into innerHTML but\n    // not innerText\n    var content = mdContent.innerText || mdContent.innerHTML;\n    var showdownConverter = window.Showdown.converter;\n    document.getElementById(\"readme-md\").innerHTML = new showdownConverter().makeHtml(content);\n  }\n}\n\n$(window).resize(function () {\n  if (isCodeAbove) {\n    setAppCodeSxsWidths(false);\n    setCodeHeightFromDocHeight();\n  }\n});\nwindow.toggleCodePosition = toggleCodePosition;\n$(window).on(\"load\", setInitialCodePosition);\n$(window).on(\"load\", renderMarkdown);\nif (window.hljs) window.hljs.initHighlightingOnLoad();\nexport {};", "'use strict';\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar anObject = require('../internals/an-object');\nvar toLength = require('../internals/to-length');\nvar toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar getSubstitution = require('../internals/get-substitution');\nvar regExpExec = require('../internals/regexp-exec-abstract');\n\nvar max = Math.max;\nvar min = Math.min;\n\nvar maybeToString = function (it) {\n  return it === undefined ? it : String(it);\n};\n\n// @@replace logic\nfixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative, reason) {\n  var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = reason.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE;\n  var REPLACE_KEEPS_$0 = reason.REPLACE_KEEPS_$0;\n  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';\n\n  return [\n    // `String.prototype.replace` method\n    // https://tc39.es/ecma262/#sec-string.prototype.replace\n    function replace(searchValue, replaceValue) {\n      var O = requireObjectCoercible(this);\n      var replacer = searchValue == undefined ? undefined : searchValue[REPLACE];\n      return replacer !== undefined\n        ? replacer.call(searchValue, O, replaceValue)\n        : nativeReplace.call(String(O), searchValue, replaceValue);\n    },\n    // `RegExp.prototype[@@replace]` method\n    // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace\n    function (regexp, replaceValue) {\n      if (\n        (!REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE && REPLACE_KEEPS_$0) ||\n        (typeof replaceValue === 'string' && replaceValue.indexOf(UNSAFE_SUBSTITUTE) === -1)\n      ) {\n        var res = maybeCallNative(nativeReplace, regexp, this, replaceValue);\n        if (res.done) return res.value;\n      }\n\n      var rx = anObject(regexp);\n      var S = String(this);\n\n      var functionalReplace = typeof replaceValue === 'function';\n      if (!functionalReplace) replaceValue = String(replaceValue);\n\n      var global = rx.global;\n      if (global) {\n        var fullUnicode = rx.unicode;\n        rx.lastIndex = 0;\n      }\n      var results = [];\n      while (true) {\n        var result = regExpExec(rx, S);\n        if (result === null) break;\n\n        results.push(result);\n        if (!global) break;\n\n        var matchStr = String(result[0]);\n        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n      }\n\n      var accumulatedResult = '';\n      var nextSourcePosition = 0;\n      for (var i = 0; i < results.length; i++) {\n        result = results[i];\n\n        var matched = String(result[0]);\n        var position = max(min(toInteger(result.index), S.length), 0);\n        var captures = [];\n        // NOTE: This is equivalent to\n        //   captures = result.slice(1).map(maybeToString)\n        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n        // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n        for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));\n        var namedCaptures = result.groups;\n        if (functionalReplace) {\n          var replacerArgs = [matched].concat(captures, position, S);\n          if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);\n          var replacement = String(replaceValue.apply(undefined, replacerArgs));\n        } else {\n          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n        }\n        if (position >= nextSourcePosition) {\n          accumulatedResult += S.slice(nextSourcePosition, position) + replacement;\n          nextSourcePosition = position + matched.length;\n        }\n      }\n      return accumulatedResult + S.slice(nextSourcePosition);\n    }\n  ];\n});\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/inst/www/shared/shiny-testmode.js b/inst/www/shared/shiny-testmode.js index c9fdb0dd56..3745db3501 100644 --- a/inst/www/shared/shiny-testmode.js +++ b/inst/www/shared/shiny-testmode.js @@ -1,3 +1,3 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ (function(){var a=eval;window.addEventListener("message",function(i){var e=i.data;e.code&&a(e.code)});})(); //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjdHMvc3JjL3V0aWxzL2V2YWwudHMiLCAiLi4vLi4vLi4vc3JjdHMvZXh0cmFzL3NoaW55LXRlc3Rtb2RlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvL2VzYnVpbGQuZ2l0aHViLmlvL2NvbnRlbnQtdHlwZXMvI2RpcmVjdC1ldmFsXG4vL3RsL2RyO1xuLy8gKiBEaXJlY3QgdXNhZ2Ugb2YgYGV2YWwoXCJ4XCIpYCBpcyBiYWQgd2l0aCBidW5kbGVkIGNvZGUuXG4vLyAqIEluc3RlYWQsIHVzZSBpbmRpcmVjdCBjYWxscyB0byBgZXZhbGAgc3VjaCBhcyBgaW5kaXJlY3RFdmFsKFwieFwiKWBcbi8vICAgKiBFdmVuIGp1c3QgcmVuYW1pbmcgdGhlIGZ1bmN0aW9uIHdvcmtzIHdlbGwgZW5vdWdoLlxuLy8gPiBUaGlzIGlzIGtub3duIGFzIFwiaW5kaXJlY3QgZXZhbFwiIGJlY2F1c2UgZXZhbCBpcyBub3QgYmVpbmcgY2FsbGVkIGRpcmVjdGx5LCBhbmQgc28gZG9lcyBub3QgdHJpZ2dlciB0aGUgZ3JhbW1hdGljYWwgc3BlY2lhbCBjYXNlIGZvciBkaXJlY3QgZXZhbCBpbiB0aGUgSmF2YVNjcmlwdCBWTS4gWW91IGNhbiBjYWxsIGluZGlyZWN0IGV2YWwgdXNpbmcgYW55IHN5bnRheCBhdCBhbGwgZXhjZXB0IGZvciBhbiBleHByZXNzaW9uIG9mIHRoZSBleGFjdCBmb3JtIGV2YWwoJ3gnKS4gRm9yIGV4YW1wbGUsIHZhciBldmFsMiA9IGV2YWw7IGV2YWwyKCd4JykgYW5kIFtldmFsXVswXSgneCcpIGFuZCB3aW5kb3cuZXZhbCgneCcpIGFyZSBhbGwgaW5kaXJlY3QgZXZhbCBjYWxscy5cbi8vID4gV2hlbiB5b3UgdXNlIGluZGlyZWN0IGV2YWwsIHRoZSBjb2RlIGlzIGV2YWx1YXRlZCBpbiB0aGUgZ2xvYmFsIHNjb3BlIGluc3RlYWQgb2YgaW4gdGhlIGlubGluZSBzY29wZSBvZiB0aGUgY2FsbGVyLlxudmFyIGluZGlyZWN0RXZhbCA9IGV2YWw7XG5leHBvcnQgeyBpbmRpcmVjdEV2YWwgfTsiLCAiLyogZXNsaW50LWRpc2FibGUgdW5pY29ybi9maWxlbmFtZS1jYXNlICovXG5pbXBvcnQgeyBpbmRpcmVjdEV2YWwgfSBmcm9tIFwiLi4vc3JjL3V0aWxzL2V2YWxcIjsgLy8gTGlzdGVuIGZvciBtZXNzYWdlcyBmcm9tIHBhcmVudCBmcmFtZS4gVGhpcyBmaWxlIGlzIG9ubHkgYWRkZWQgd2hlbiB0aGVcbi8vIHNoaW55LnRlc3Rtb2RlIG9wdGlvbiBpcyBUUlVFLlxuXG53aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcihcIm1lc3NhZ2VcIiwgZnVuY3Rpb24gKGUpIHtcbiAgdmFyIG1lc3NhZ2UgPSBlLmRhdGE7XG4gIGlmIChtZXNzYWdlLmNvZGUpIGluZGlyZWN0RXZhbChtZXNzYWdlLmNvZGUpO1xufSk7Il0sCiAgIm1hcHBpbmdzIjogIjtZQU9BLEdBQUksR0FBZSxLQ0huQixPQUFPLGlCQUFpQixVQUFXLFNBQVUsRUFBRyxDQUM5QyxHQUFJLEdBQVUsRUFBRSxLQUNoQixBQUFJLEVBQVEsTUFBTSxFQUFhLEVBQVEiLAogICJuYW1lcyI6IFtdCn0K diff --git a/inst/www/shared/shiny.js b/inst/www/shared/shiny.js index 3bb529f759..c973dcb9b9 100644 --- a/inst/www/shared/shiny.js +++ b/inst/www/shared/shiny.js @@ -1,4 +1,4 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ (function() { var __create = Object.create; var __defProp = Object.defineProperty; @@ -13263,7 +13263,7 @@ var windowShiny2; function setShiny(windowShiny_) { windowShiny2 = windowShiny_; - windowShiny2.version = "1.6.0.9021"; + windowShiny2.version = "1.6.0.9022"; var _initInputBindings = initInputBindings(), inputBindings = _initInputBindings.inputBindings, fileInputBinding2 = _initInputBindings.fileInputBinding; var _initOutputBindings = initOutputBindings(), outputBindings = _initOutputBindings.outputBindings; setFileInputBinding(fileInputBinding2); diff --git a/inst/www/shared/shiny.min.css b/inst/www/shared/shiny.min.css index a8b7743144..c1f199b284 100644 --- a/inst/www/shared/shiny.min.css +++ b/inst/www/shared/shiny.min.css @@ -1,2 +1,2 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ +/*! shiny 1.6.0.9022 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ pre.shiny-text-output:empty:before{content:" "}pre.shiny-text-output.noplaceholder:empty{margin:0;padding:0;border-width:0;height:0}pre.shiny-text-output{word-wrap:normal}.shiny-image-output img.shiny-scalable,.shiny-plot-output img.shiny-scalable{max-width:100%;max-height:100%}#shiny-disconnected-overlay{position:fixed;top:0;bottom:0;left:0;right:0;background-color:#999;opacity:.5;overflow:hidden;z-index:99998;pointer-events:none}.table.shiny-table>thead>tr>th,.table.shiny-table>thead>tr>td,.table.shiny-table>tbody>tr>th,.table.shiny-table>tbody>tr>td,.table.shiny-table>tfoot>tr>th,.table.shiny-table>tfoot>tr>td{padding-right:12px;padding-left:12px}.shiny-table.spacing-xs>thead>tr>th,.shiny-table.spacing-xs>thead>tr>td,.shiny-table.spacing-xs>tbody>tr>th,.shiny-table.spacing-xs>tbody>tr>td,.shiny-table.spacing-xs>tfoot>tr>th,.shiny-table.spacing-xs>tfoot>tr>td{padding-top:3px;padding-bottom:3px}.shiny-table.spacing-s>thead>tr>th,.shiny-table.spacing-s>thead>tr>td,.shiny-table.spacing-s>tbody>tr>th,.shiny-table.spacing-s>tbody>tr>td,.shiny-table.spacing-s>tfoot>tr>th,.shiny-table.spacing-s>tfoot>tr>td{padding-top:5px;padding-bottom:5px}.shiny-table.spacing-m>thead>tr>th,.shiny-table.spacing-m>thead>tr>td,.shiny-table.spacing-m>tbody>tr>th,.shiny-table.spacing-m>tbody>tr>td,.shiny-table.spacing-m>tfoot>tr>th,.shiny-table.spacing-m>tfoot>tr>td{padding-top:8px;padding-bottom:8px}.shiny-table.spacing-l>thead>tr>th,.shiny-table.spacing-l>thead>tr>td,.shiny-table.spacing-l>tbody>tr>th,.shiny-table.spacing-l>tbody>tr>td,.shiny-table.spacing-l>tfoot>tr>th,.shiny-table.spacing-l>tfoot>tr>td{padding-top:10px;padding-bottom:10px}.shiny-table .NA{color:#909090}.shiny-output-error{color:red;white-space:pre-wrap}.shiny-output-error:before{content:"Error: ";font-weight:bold}.shiny-output-error-validation{color:#888}.shiny-output-error-validation:before{content:"";font-weight:inherit}@supports (-ms-ime-align:auto){.shiny-bound-output{transition:0}}.recalculating{opacity:.3;transition:opacity .25s ease .5s}.slider-animate-container{text-align:right;margin-top:-9px}.slider-animate-button{opacity:.5}.slider-animate-button .pause{display:none}.slider-animate-button.playing .pause{display:inline}.slider-animate-button .play{display:inline}.slider-animate-button.playing .play{display:none}.progress.shiny-file-input-progress{visibility:hidden}.progress.shiny-file-input-progress .progress-bar.bar-danger{transition:none}.shiny-input-container input[type=file]{overflow:hidden;max-width:100%}.shiny-progress-container{position:fixed;top:0px;width:100%;z-index:2000}.shiny-progress .progress{position:absolute;width:100%;top:0px;height:3px;margin:0}.shiny-progress .bar{opacity:.6;transition-duration:.25s}.shiny-progress .progress-text{position:absolute;right:10px;width:240px;background-color:#eef8ff;margin:0;padding:2px 3px;opacity:.85}.shiny-progress .progress-text .progress-message{padding:0 3px;font-weight:bold;font-size:90%}.shiny-progress .progress-text .progress-detail{padding:0 3px;font-size:80%}.shiny-progress-notification .progress{margin-bottom:5px;height:10px}.shiny-progress-notification .progress-text .progress-message{font-weight:bold;font-size:90%}.shiny-progress-notification .progress-text .progress-detail{font-size:80%}.shiny-label-null{display:none}.crosshair{cursor:crosshair}.grabbable{cursor:grab;cursor:-moz-grab;cursor:-webkit-grab}.grabbing{cursor:grabbing;cursor:-moz-grabbing;cursor:-webkit-grabbing}.ns-resize{cursor:ns-resize}.ew-resize{cursor:ew-resize}.nesw-resize{cursor:nesw-resize}.nwse-resize{cursor:nwse-resize}.qt pre,.qt code{font-family:monospace!important}.qt5 .radio input[type=radio],.qt5 .checkbox input[type=checkbox]{margin-top:0}.selectize-control{margin-bottom:10px}.shiny-frame{border:none}.shiny-flow-layout>div{display:inline-block;vertical-align:top;padding-right:12px;width:220px}.shiny-split-layout{width:100%;white-space:nowrap}.shiny-split-layout>div{display:inline-block;vertical-align:top;box-sizing:border-box;overflow:auto}.shiny-input-panel{padding:6px 8px;margin-top:6px;margin-bottom:6px;background-color:#f5f5f5;border:1px solid #e3e3e3;border-radius:2px}.shiny-input-checkboxgroup label~.shiny-options-group,.shiny-input-radiogroup label~.shiny-options-group{margin-top:-10px}.shiny-input-checkboxgroup.shiny-input-container-inline label~.shiny-options-group,.shiny-input-radiogroup.shiny-input-container-inline label~.shiny-options-group{margin-top:-1px}.shiny-input-container:not(.shiny-input-container-inline){width:300px;max-width:100%}.well .shiny-input-container{width:auto}.shiny-input-container>div>select:not(.selectized){width:100%}#shiny-notification-panel{position:fixed;bottom:0;right:0;background-color:#0000;padding:2px;width:250px;z-index:99999}.shiny-notification{background-color:#e8e8e8;color:#333;border:1px solid #ccc;border-radius:3px;opacity:.85;padding:10px 8px 10px 10px;margin:2px}.shiny-notification-message{color:#31708f;background-color:#d9edf7;border:1px solid #bce8f1}.shiny-notification-warning{color:#8a6d3b;background-color:#fcf8e3;border:1px solid #faebcc}.shiny-notification-error{color:#a94442;background-color:#f2dede;border:1px solid #ebccd1}.shiny-notification-close{float:right;font-weight:bold;font-size:18px;bottom:9px;position:relative;padding-left:4px;color:#444;cursor:default}.shiny-notification-close:hover{color:#000}.shiny-notification-content-action a{color:#337ab7;text-decoration:underline;font-weight:bold}.shiny-file-input-active{box-shadow:inset 0 1px 1px #00000013,0 0 8px #66afe999}.shiny-file-input-over{box-shadow:inset 0 1px 1px #00000013,0 0 8px #4cae4c99}.datepicker table tbody tr td.disabled,.datepicker table tbody tr td.disabled:hover,.datepicker table tbody tr td span.disabled,.datepicker table tbody tr td span.disabled:hover{color:#aaa;cursor:not-allowed}.nav-hidden{display:none!important} diff --git a/inst/www/shared/shiny.min.js b/inst/www/shared/shiny.min.js index 606eaa1c29..3661ad3233 100644 --- a/inst/www/shared/shiny.min.js +++ b/inst/www/shared/shiny.min.js @@ -1,3 +1,3 @@ -/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */ -(function(){var xy=Object.create;var Zi=Object.defineProperty;var Oy=Object.getOwnPropertyDescriptor;var Sy=Object.getOwnPropertyNames;var Iy=Object.getPrototypeOf,Ry=Object.prototype.hasOwnProperty;var Py=function(e){return Zi(e,"__esModule",{value:!0})};var v=function(e,t){return function(){return t||e((t={exports:{}}).exports,t),t.exports}};var qy=function(e,t,r){if(t&&typeof t=="object"||typeof t=="function")for(var n=Sy(t),i=0,o=n.length,a;i0?Nh:Ch)(e)}});var fe=v(function($q,Xs){var Ah=ut(),$h=Math.min;Xs.exports=function(e){return e>0?$h(Ah(e),9007199254740991):0}});var Vt=v(function(Mq,Qs){var Mh=ut(),Vh=Math.max,Fh=Math.min;Qs.exports=function(e,t){var r=Mh(e);return r<0?Vh(r+t,0):Fh(r,t)}});var co=v(function(Vq,Zs){var Lh=Te(),zh=fe(),Uh=Vt(),Js=function(e){return function(t,r,n){var i=Lh(t),o=zh(i.length),a=Uh(n,o),u;if(e&&r!=r){for(;o>a;)if(u=i[a++],u!=u)return!0}else for(;o>a;a++)if((e||a in i)&&i[a]===r)return e||a||0;return!e&&-1}};Zs.exports={includes:Js(!0),indexOf:Js(!1)}});var mo=v(function(Fq,el){var po=le(),Hh=Te(),Gh=co().indexOf,Kh=pr();el.exports=function(e,t){var r=Hh(e),n=0,i=[],o;for(o in r)!po(Kh,o)&&po(r,o)&&i.push(o);for(;t.length>n;)po(r,o=t[n++])&&(~Gh(i,o)||i.push(o));return i}});var sn=v(function(Lq,tl){tl.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]});var Ft=v(function(rl){var Wh=mo(),Yh=sn(),Xh=Yh.concat("length","prototype");rl.f=Object.getOwnPropertyNames||function(t){return Wh(t,Xh)}});var vo=v(function(nl){nl.f=Object.getOwnPropertySymbols});var ol=v(function(Hq,il){var Qh=St(),Jh=Ft(),Zh=vo(),eg=Y();il.exports=Qh("Reflect","ownKeys")||function(t){var r=Jh.f(eg(t)),n=Zh.f;return n?r.concat(n(t)):r}});var yo=v(function(Gq,al){var tg=le(),rg=ol(),ng=xt(),ig=de();al.exports=function(e,t){for(var r=rg(t),n=ig.f,i=ng.f,o=0;o>>0||(Pg.test(n)?16:10))}:fn});var xo=v(function(fT,ql){"use strict";var Ng=Y();ql.exports=function(){var e=Ng(this),t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),e.dotAll&&(t+="s"),e.unicode&&(t+="u"),e.sticky&&(t+="y"),t}});var So=v(function(Oo){"use strict";var Tl=M();function El(e,t){return RegExp(e,t)}Oo.UNSUPPORTED_Y=Tl(function(){var e=El("a","y");return e.lastIndex=2,e.exec("abcd")!=null});Oo.BROKEN_CARET=Tl(function(){var e=El("^r","gy");return e.lastIndex=2,e.exec("str")!=null})});var gr=v(function(pT,Cl){"use strict";var Ag=xo(),kl=So(),$g=fr(),cn=RegExp.prototype.exec,Mg=$g("native-string-replace",String.prototype.replace),Bl=cn,Io=function(){var e=/a/,t=/b*/g;return cn.call(e,"a"),cn.call(t,"a"),e.lastIndex!==0||t.lastIndex!==0}(),Dl=kl.UNSUPPORTED_Y||kl.BROKEN_CARET,Ro=/()??/.exec("")[1]!==void 0,Vg=Io||Ro||Dl;Vg&&(Bl=function(t){var r=this,n,i,o,a,u=Dl&&r.sticky,l=Ag.call(r),s=r.source,f=0,c=t;return u&&(l=l.replace("y",""),l.indexOf("g")===-1&&(l+="g"),c=String(t).slice(r.lastIndex),r.lastIndex>0&&(!r.multiline||r.multiline&&t[r.lastIndex-1]!=="\n")&&(s="(?: "+s+")",c=" "+c,f++),i=new RegExp("^(?:"+s+")",l)),Ro&&(i=new RegExp("^"+s+"$(?!\\s)",l)),Io&&(n=r.lastIndex),o=cn.call(u?i:r,c),u?o?(o.input=o.input.slice(f),o[0]=o[0].slice(f),o.index=r.lastIndex,r.lastIndex+=o[0].length):r.lastIndex=0:Io&&o&&(r.lastIndex=r.global?o.index+o[0].length:n),Ro&&o&&o.length>1&&Mg.call(o[0],i,function(){for(a=1;a=74)&&(Ve=Po.match(/Chrome\/(\d+)/),Ve&&(pn=Ve[1])));Ll.exports=pn&&+pn});var dn=v(function(hT,Ul){var zl=br(),Ug=M();Ul.exports=!!Object.getOwnPropertySymbols&&!Ug(function(){var e=Symbol();return!String(e)||!(Object(e)instanceof Symbol)||!Symbol.sham&&zl&&zl<41})});var qo=v(function(gT,Hl){var Hg=dn();Hl.exports=Hg&&!Symbol.sham&&typeof Symbol.iterator=="symbol"});var G=v(function(bT,Wl){var Gg=z(),Kg=fr(),Gl=le(),Wg=on(),Kl=dn(),Yg=qo(),jr=Kg("wks"),wr=Gg.Symbol,Xg=Yg?wr:wr&&wr.withoutSetter||Wg;Wl.exports=function(e){return(!Gl(jr,e)||!(Kl||typeof jr[e]=="string"))&&(Kl&&Gl(wr,e)?jr[e]=wr[e]:jr[e]=Xg("Symbol."+e)),jr[e]}});var _r=v(function(jT,Zl){"use strict";Ie();var Yl=We(),Qg=gr(),mn=M(),To=G(),Jg=Se(),Zg=To("species"),Eo=RegExp.prototype,eb=!mn(function(){var e=/./;return e.exec=function(){var t=[];return t.groups={a:"7"},t},"".replace(e,"$")!=="7"}),Xl=function(){return"a".replace(/./,"$0")==="$0"}(),Ql=To("replace"),Jl=function(){return/./[Ql]?/./[Ql]("a","$0")==="":!1}(),tb=!mn(function(){var e=/(?:)/,t=e.exec;e.exec=function(){return t.apply(this,arguments)};var r="ab".split(e);return r.length!==2||r[0]!=="a"||r[1]!=="b"});Zl.exports=function(e,t,r,n){var i=To(e),o=!mn(function(){var c={};return c[i]=function(){return 7},""[e](c)!=7}),a=o&&!mn(function(){var c=!1,p=/a/;return e==="split"&&(p={},p.constructor={},p.constructor[Zg]=function(){return p},p.flags="",p[i]=/./[i]),p.exec=function(){return c=!0,null},p[i](""),!c});if(!o||!a||e==="replace"&&!(eb&&Xl&&!Jl)||e==="split"&&!tb){var u=/./[i],l=r(i,""[e],function(c,p,m,d,y){var h=p.exec;return h===Qg||h===Eo.exec?o&&!y?{done:!0,value:u.call(p,m,d)}:{done:!0,value:c.call(m,p,d)}:{done:!1}},{REPLACE_KEEPS_$0:Xl,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:Jl}),s=l[0],f=l[1];Yl(String.prototype,e,s),Yl(Eo,i,t==2?function(c,p){return f.call(c,this,p)}:function(c){return f.call(c,this)})}n&&Jg(Eo[i],"sham",!0)}});var ko=v(function(wT,tf){var rb=ut(),nb=Ke(),ef=function(e){return function(t,r){var n=String(nb(t)),i=rb(r),o=n.length,a,u;return i<0||i>=o?e?"":void 0:(a=n.charCodeAt(i),a<55296||a>56319||i+1===o||(u=n.charCodeAt(i+1))<56320||u>57343?e?n.charAt(i):a:e?n.slice(i,i+2):(a-55296<<10)+(u-56320)+65536)}};tf.exports={codeAt:ef(!1),charAt:ef(!0)}});var vn=v(function(_T,rf){"use strict";var ib=ko().charAt;rf.exports=function(e,t,r){return t+(r?ib(e,t).length:1)}});var of=v(function(xT,nf){var ob=be(),ab=Math.floor,ub="".replace,sb=/\$([$&'`]|\d{1,2}|<[^>]*>)/g,lb=/\$([$&'`]|\d{1,2})/g;nf.exports=function(e,t,r,n,i,o){var a=r+e.length,u=n.length,l=lb;return i!==void 0&&(i=ob(i),l=sb),ub.call(o,l,function(s,f){var c;switch(f.charAt(0)){case"$":return"$";case"&":return e;case"`":return t.slice(0,r);case"'":return t.slice(a);case"<":c=i[f.slice(1,-1)];break;default:var p=+f;if(p===0)return s;if(p>u){var m=ab(p/10);return m===0?s:m<=u?n[m-1]===void 0?f.charAt(1):n[m-1]+f.charAt(1):s}c=n[p-1]}return c===void 0?"":c})}});var xr=v(function(OT,af){var fb=Ge(),cb=gr();af.exports=function(e,t){var r=e.exec;if(typeof r=="function"){var n=r.call(e,t);if(typeof n!="object")throw TypeError("RegExp exec method returned something other than an Object or null");return n}if(fb(e)!=="RegExp")throw TypeError("RegExp#exec called on incompatible receiver");return cb.call(e,t)}});var yn=v(function(IT,sf){var xb=G(),Ob=xb("toStringTag"),uf={};uf[Ob]="z";sf.exports=String(uf)==="[object z]"});var Bo=v(function(RT,lf){var Sb=yn(),hn=Ge(),Ib=G(),Rb=Ib("toStringTag"),Pb=hn(function(){return arguments}())=="Arguments",qb=function(e,t){try{return e[t]}catch(r){}};lf.exports=Sb?hn:function(e){var t,r,n;return e===void 0?"Undefined":e===null?"Null":typeof(r=qb(t=Object(e),Rb))=="string"?r:Pb?hn(t):(n=hn(t))=="Object"&&typeof t.callee=="function"?"Arguments":n}});var cf=v(function(PT,ff){"use strict";var Tb=yn(),Eb=Bo();ff.exports=Tb?{}.toString:function(){return"[object "+Eb(this)+"]"}});var vf=v(function(ET,mf){var Fb=z(),Lb=hr().trim,zb=yr(),Co=Fb.parseFloat,Ub=1/Co(zb+"-0")!=-Infinity;mf.exports=Ub?function(t){var r=Lb(String(t)),n=Co(r);return n===0&&r.charAt(0)=="-"?-0:n}:Co});var gf=v(function(BT,hf){var Gb=Ge();hf.exports=function(e){if(typeof e!="number"&&Gb(e)!="Number")throw TypeError("Incorrect invocation");return+e}});var Or=v(function(CT,wf){var Yb=Ge();wf.exports=Array.isArray||function(t){return Yb(t)=="Array"}});var Sr=v(function(NT,_f){"use strict";var Xb=$t(),Qb=de(),Jb=At();_f.exports=function(e,t,r){var n=Xb(t);n in e?Qb.f(e,n,Jb(0,r)):e[n]=r}});var bn=v(function(AT,Of){var Zb=re(),xf=Or(),ej=G(),tj=ej("species");Of.exports=function(e,t){var r;return xf(e)&&(r=e.constructor,typeof r=="function"&&(r===Array||xf(r.prototype))?r=void 0:Zb(r)&&(r=r[tj],r===null&&(r=void 0))),new(r===void 0?Array:r)(t===0?0:t)}});var Lt=v(function($T,Sf){var rj=M(),nj=G(),ij=br(),oj=nj("species");Sf.exports=function(e){return ij>=51||!rj(function(){var t=[],r=t.constructor={};return r[oj]=function(){return{foo:1}},t[e](Boolean).foo!==1})}});var Ir=v(function(LT,kf){var Uj=mo(),Hj=sn();kf.exports=Object.keys||function(t){return Uj(t,Hj)}});var Cf=v(function(UT,Df){var Xj=re(),Qj=Ge(),Jj=G(),Zj=Jj("match");Df.exports=function(e){var t;return Xj(e)&&((t=e[Zj])!==void 0?!!t:Qj(e)=="RegExp")}});var zt=v(function(HT,Nf){Nf.exports=function(e){if(typeof e!="function")throw TypeError(String(e)+" is not a function");return e}});var No=v(function(GT,$f){var Af=Y(),ew=zt(),tw=G(),rw=tw("species");$f.exports=function(e,t){var r=Af(e).constructor,n;return r===void 0||(n=Af(r)[rw])==null?t:ew(n)}});var Uo=v(function(hE,rc){var gw=zt();rc.exports=function(e,t,r){if(gw(e),t===void 0)return e;switch(r){case 0:return function(){return e.call(t)};case 1:return function(n){return e.call(t,n)};case 2:return function(n,i){return e.call(t,n,i)};case 3:return function(n,i,o){return e.call(t,n,i,o)}}return function(){return e.apply(t,arguments)}}});var Gt=v(function(gE,ic){var bw=Uo(),jw=sr(),ww=be(),_w=fe(),xw=bn(),nc=[].push,st=function(e){var t=e==1,r=e==2,n=e==3,i=e==4,o=e==6,a=e==7,u=e==5||o;return function(l,s,f,c){for(var p=ww(l),m=jw(p),d=bw(s,f,3),y=_w(m.length),h=0,g=c||xw,w=t?g(l,y):r||a?g(l,0):void 0,I,_;y>h;h++)if((u||h in m)&&(I=m[h],_=d(I,h,p),e))if(t)w[h]=_;else if(_)switch(e){case 3:return!0;case 5:return I;case 6:return h;case 2:nc.call(w,I)}else switch(e){case 4:return!1;case 7:nc.call(w,I)}return o?-1:n||i?i:w}};ic.exports={forEach:st(0),map:st(1),filter:st(2),some:st(3),every:st(4),find:st(5),findIndex:st(6),filterOut:st(7)}});var ac=v(function(bE,oc){var Ow=pe(),Sw=de(),Iw=Y(),Rw=Ir();oc.exports=Ow?Object.defineProperties:function(t,r){Iw(t);for(var n=Rw(r),i=n.length,o=0,a;i>o;)Sw.f(t,a=n[o++],r[a]);return t}});var sc=v(function(jE,uc){var Pw=St();uc.exports=Pw("document","documentElement")});var Kt=v(function(wE,mc){var qw=Y(),Tw=ac(),lc=sn(),Ew=pr(),kw=sc(),Bw=to(),Dw=cr(),fc=">",cc="<",Ho="prototype",Go="script",pc=Dw("IE_PROTO"),Ko=function(){},dc=function(e){return cc+Go+fc+e+cc+"/"+Go+fc},Cw=function(e){e.write(dc("")),e.close();var t=e.parentWindow.Object;return e=null,t},Nw=function(){var e=Bw("iframe"),t="java"+Go+":",r;return e.style.display="none",kw.appendChild(e),e.src=String(t),r=e.contentWindow.document,r.open(),r.write(dc("document.F=Object")),r.close(),r.F},Wo,xn=function(){try{Wo=document.domain&&new ActiveXObject("htmlfile")}catch(t){}xn=Wo?Cw(Wo):Nw();for(var e=lc.length;e--;)delete xn[Ho][lc[e]];return xn()};Ew[pc]=!0;mc.exports=Object.create||function(t,r){var n;return t!==null?(Ko[Ho]=qw(t),n=new Ko,Ko[Ho]=null,n[pc]=t):n=xn(),r===void 0?n:Tw(n,r)}});var Qo=v(function(_E,vc){var Aw=G(),$w=Kt(),Mw=de(),Yo=Aw("unscopables"),Xo=Array.prototype;Xo[Yo]==null&&Mw.f(Xo,Yo,{configurable:!0,value:$w(null)});vc.exports=function(e){Xo[Yo][e]=!0}});var gc=v(function(OE,hc){var zw=re();hc.exports=function(e){if(!zw(e)&&e!==null)throw TypeError("Can't set "+String(e)+" as a prototype");return e}});var qr=v(function(SE,bc){var Uw=Y(),Hw=gc();bc.exports=Object.setPrototypeOf||("__proto__"in{}?function(){var e=!1,t={},r;try{r=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set,r.call(t,[]),e=t instanceof Array}catch(n){}return function(i,o){return Uw(i),Hw(o),e?r.call(i,o):i.__proto__=o,i}}():void 0)});var Zo=v(function(RE,jc){var Ww=M();jc.exports=!Ww(function(){function e(){}return e.prototype.constructor=null,Object.getPrototypeOf(new e)!==e.prototype})});var Wt=v(function(PE,_c){var Yw=le(),Xw=be(),Qw=cr(),Jw=Zo(),wc=Qw("IE_PROTO"),Zw=Object.prototype;_c.exports=Jw?Object.getPrototypeOf:function(e){return e=Xw(e),Yw(e,wc)?e[wc]:typeof e.constructor=="function"&&e instanceof e.constructor?e.constructor.prototype:e instanceof Object?Zw:null}});var Ic=v(function(TE,Sc){"use strict";var o_=zt(),a_=re(),Oc=[].slice,ea={},u_=function(e,t,r){if(!(t in ea)){for(var n=[],i=0;i=t.length?(e.target=void 0,{value:void 0,done:!0}):r=="keys"?{value:n,done:!1}:r=="values"?{value:t[n],done:!1}:{value:[n,t[n]],done:!1}},"values");Sp.Arguments=Sp.Array;Ra("keys");Ra("values");Ra("entries")});var Pa=v(function(HE,Ep){Ep.exports={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0}});var Vp=v(function(uk,Mp){var Ix=M(),Ap=yr(),$p="\u200B\x85\u180E";Mp.exports=function(e){return Ix(function(){return!!Ap[e]()||$p[e]()!=$p||Ap[e].name!==e})}});var Gp=v(function(Ok,Hp){var $x=re(),Up=qr();Hp.exports=function(e,t,r){var n,i;return Up&&typeof(n=t.constructor)=="function"&&n!==r&&$x(i=n.prototype)&&i!==r.prototype&&Up(e,i),e}});var pm=v(function(fN,cm){cm.exports=Object.is||function(t,r){return t===r?t!==0||1/t==1/r:t!=t&&r!=r}});var _m=v(function(zN,wm){var NI=pe(),AI=Ir(),$I=Te(),MI=en().f,jm=function(e){return function(t){for(var r=$I(t),n=AI(r),i=n.length,o=0,a=[],u;i>o;)u=n[o++],(!NI||MI.call(r,u))&&a.push(e?[u,r[u]]:r[u]);return a}};wm.exports={entries:jm(!0),values:jm(!1)}});var Om=v(function(HN,xm){var LI=Y();xm.exports=function(e){var t=e.return;if(t!==void 0)return LI(t.call(e)).value}});var Im=v(function(GN,Sm){var zI=Y(),UI=Om();Sm.exports=function(e,t,r,n){try{return n?t(zI(r)[0],r[1]):t(r)}catch(i){throw UI(e),i}}});var Pm=v(function(KN,Rm){var HI=G(),GI=Jt(),KI=HI("iterator"),WI=Array.prototype;Rm.exports=function(e){return e!==void 0&&(GI.Array===e||WI[KI]===e)}});var Tm=v(function(WN,qm){var YI=Bo(),XI=Jt(),QI=G(),JI=QI("iterator");qm.exports=function(e){if(e!=null)return e[JI]||e["@@iterator"]||XI[YI(e)]}});var Bm=v(function(YN,km){"use strict";var ZI=Uo(),e0=be(),t0=Im(),r0=Pm(),n0=fe(),Em=Sr(),i0=Tm();km.exports=function(t){var r=e0(t),n=typeof this=="function"?this:Array,i=arguments.length,o=i>1?arguments[1]:void 0,a=o!==void 0,u=i0(r),l=0,s,f,c,p,m,d;if(a&&(o=ZI(o,i>2?arguments[2]:void 0,2)),u!=null&&!(n==Array&&r0(u)))for(p=u.call(r),m=p.next,f=new n;!(c=m.call(p)).done;l++)d=a?t0(p,o,[c.value,l],!0):c.value,Em(f,l,d);else for(s=n0(r.length),f=new n(s);s>l;l++)d=a?o(r[l],l):r[l],Em(f,l,d);return f.length=l,f}});var $m=v(function(XN,Am){var o0=G(),Dm=o0("iterator"),Cm=!1;try{Nm=0,su={next:function(){return{done:!!Nm++}},return:function(){Cm=!0}},su[Dm]=function(){return this},Array.from(su,function(){throw 2})}catch(e){}var Nm,su;Am.exports=function(e,t){if(!t&&!Cm)return!1;var r=!1;try{var n={};n[Dm]=function(){return{next:function(){return{done:r=!0}}}},e(n)}catch(i){}return r}});var Cu=v(function(iF,jv){jv.exports=typeof ArrayBuffer!="undefined"&&typeof DataView!="undefined"});var _v=v(function(oF,wv){var WR=We();wv.exports=function(e,t,r){for(var n in t)WR(e,n,t[n],r);return e}});var Ov=v(function(aF,xv){xv.exports=function(e,t,r){if(!(e instanceof t))throw TypeError("Incorrect "+(r?r+" ":"")+"invocation");return e}});var Iv=v(function(uF,Sv){var YR=ut(),XR=fe();Sv.exports=function(e){if(e===void 0)return 0;var t=YR(e),r=XR(t);if(t!==r)throw RangeError("Wrong length or index");return r}});var Pv=v(function(sF,Rv){var QR=Math.abs,rt=Math.pow,JR=Math.floor,ZR=Math.log,eP=Math.LN2,tP=function(e,t,r){var n=new Array(r),i=r*8-t-1,o=(1<>1,u=t===23?rt(2,-24)-rt(2,-77):0,l=e<0||e===0&&1/e<0?1:0,s=0,f,c,p;for(e=QR(e),e!=e||e===Infinity?(c=e!=e?1:0,f=o):(f=JR(ZR(e)/eP),e*(p=rt(2,-f))<1&&(f--,p*=2),f+a>=1?e+=u/p:e+=u*rt(2,1-a),e*p>=2&&(f++,p/=2),f+a>=o?(c=0,f=o):f+a>=1?(c=(e*p-1)*rt(2,t),f=f+a):(c=e*rt(2,a-1)*rt(2,t),f=0));t>=8;n[s++]=c&255,c/=256,t-=8);for(f=f<0;n[s++]=f&255,f/=256,i-=8);return n[--s]|=l*128,n},rP=function(e,t){var r=e.length,n=r*8-t-1,i=(1<>1,a=n-7,u=r-1,l=e[u--],s=l&127,f;for(l>>=7;a>0;s=s*256+e[u],u--,a-=8);for(f=s&(1<<-a)-1,s>>=-a,a+=t;a>0;f=f*256+e[u],u--,a-=8);if(s===0)s=1-o;else{if(s===i)return f?NaN:l?-Infinity:Infinity;f=f+rt(2,t),s=s-o}return(l?-1:1)*f*rt(2,s-t)};Rv.exports={pack:tP,unpack:rP}});var Ev=v(function(lF,Tv){"use strict";var nP=be(),qv=Vt(),iP=fe();Tv.exports=function(t){for(var r=nP(this),n=iP(r.length),i=arguments.length,o=qv(i>1?arguments[1]:void 0,n),a=i>2?arguments[2]:void 0,u=a===void 0?n:qv(a,n);u>o;)r[o++]=t;return r}});var Yi=v(function(fF,Kv){"use strict";var Nu=z(),Au=pe(),oP=Cu(),aP=Se(),kv=_v(),$u=M(),Fi=Ov(),uP=ut(),sP=fe(),Li=Iv(),Bv=Pv(),lP=Wt(),Dv=qr(),fP=Ft().f,cP=de().f,pP=Ev(),Cv=Tr(),Nv=Mt(),ur=Nv.get,Av=Nv.set,zi="ArrayBuffer",Ui="DataView",Xr="prototype",dP="Wrong length",$v="Wrong index",$e=Nu[zi],Oe=$e,Me=Nu[Ui],Hi=Me&&Me[Xr],Mv=Object.prototype,Gi=Nu.RangeError,Vv=Bv.pack,Fv=Bv.unpack,Lv=function(e){return[e&255]},zv=function(e){return[e&255,e>>8&255]},Uv=function(e){return[e&255,e>>8&255,e>>16&255,e>>24&255]},Hv=function(e){return e[3]<<24|e[2]<<16|e[1]<<8|e[0]},mP=function(e){return Vv(e,23,4)},vP=function(e){return Vv(e,52,8)},Ki=function(e,t){cP(e[Xr],t,{get:function(){return ur(this)[t]}})},jt=function(e,t,r,n){var i=Li(r),o=ur(e);if(i+t>o.byteLength)throw Gi($v);var a=ur(o.buffer).bytes,u=i+o.byteOffset,l=a.slice(u,u+t);return n?l:l.reverse()},wt=function(e,t,r,n,i,o){var a=Li(r),u=ur(e);if(a+t>u.byteLength)throw Gi($v);for(var l=ur(u.buffer).bytes,s=a+u.byteOffset,f=n(+i),c=0;ci)throw Gi("Wrong offset");if(n=n===void 0?i-o:sP(n),o+n>i)throw Gi(dP);Av(this,{buffer:t,byteLength:n,byteOffset:o}),Au||(this.buffer=t,this.byteLength=n,this.byteOffset=o)},Au&&(Ki(Oe,"byteLength"),Ki(Me,"buffer"),Ki(Me,"byteLength"),Ki(Me,"byteOffset")),kv(Me[Xr],{getInt8:function(t){return jt(this,1,t)[0]<<24>>24},getUint8:function(t){return jt(this,1,t)[0]},getInt16:function(t){var r=jt(this,2,t,arguments.length>1?arguments[1]:void 0);return(r[1]<<8|r[0])<<16>>16},getUint16:function(t){var r=jt(this,2,t,arguments.length>1?arguments[1]:void 0);return r[1]<<8|r[0]},getInt32:function(t){return Hv(jt(this,4,t,arguments.length>1?arguments[1]:void 0))},getUint32:function(t){return Hv(jt(this,4,t,arguments.length>1?arguments[1]:void 0))>>>0},getFloat32:function(t){return Fv(jt(this,4,t,arguments.length>1?arguments[1]:void 0),23)},getFloat64:function(t){return Fv(jt(this,8,t,arguments.length>1?arguments[1]:void 0),52)},setInt8:function(t,r){wt(this,1,t,Lv,r)},setUint8:function(t,r){wt(this,1,t,Lv,r)},setInt16:function(t,r){wt(this,2,t,zv,r,arguments.length>2?arguments[2]:void 0)},setUint16:function(t,r){wt(this,2,t,zv,r,arguments.length>2?arguments[2]:void 0)},setInt32:function(t,r){wt(this,4,t,Uv,r,arguments.length>2?arguments[2]:void 0)},setUint32:function(t,r){wt(this,4,t,Uv,r,arguments.length>2?arguments[2]:void 0)},setFloat32:function(t,r){wt(this,4,t,mP,r,arguments.length>2?arguments[2]:void 0)},setFloat64:function(t,r){wt(this,8,t,vP,r,arguments.length>2?arguments[2]:void 0)}});else{if(!$u(function(){$e(1)})||!$u(function(){new $e(-1)})||$u(function(){return new $e,new $e(1.5),new $e(NaN),$e.name!=zi})){for(Oe=function(t){return Fi(this,Oe),new $e(Li(t))},Gv=Oe[Xr]=$e[Xr],Mu=fP($e),Vu=0;Mu.length>Vu;)(Wi=Mu[Vu++])in Oe||aP(Oe,Wi,$e[Wi]);Gv.constructor=Oe}Dv&&lP(Hi)!==Mv&&Dv(Hi,Mv),Qr=new Me(new Oe(2)),Fu=Hi.setInt8,Qr.setInt8(0,2147483648),Qr.setInt8(1,2147483649),(Qr.getInt8(0)||!Qr.getInt8(1))&&kv(Hi,{setInt8:function(t,r){Fu.call(this,t,r<<24>>24)},setUint8:function(t,r){Fu.call(this,t,r<<24>>24)}},{unsafe:!0})}var Gv,Mu,Vu,Wi,Qr,Fu;Cv(Oe,zi);Cv(Me,Ui);Kv.exports={ArrayBuffer:Oe,DataView:Me}});var Xv=v(function(cF,Yv){"use strict";var yP=St(),hP=de(),gP=G(),bP=pe(),Wv=gP("species");Yv.exports=function(e){var t=yP(e),r=hP.f;bP&&t&&!t[Wv]&&r(t,Wv,{configurable:!0,get:function(){return this}})}});var oy=v(function(vF,iy){var BP=zt(),DP=be(),CP=sr(),NP=fe(),ny=function(e){return function(t,r,n,i){BP(r);var o=DP(t),a=CP(o),u=NP(o.length),l=e?u-1:0,s=e?-1:1;if(n<2)for(;;){if(l in a){i=a[l],l+=s;break}if(l+=s,e?l<0:u<=l)throw TypeError("Reduce of empty array with no initial value")}for(;e?l>=0:u>l;l+=s)l in a&&(i=r(i,a[l],l,o));return i}};iy.exports={left:ny(!1),right:ny(!0)}});var uy=v(function(yF,ay){var AP=Ge(),$P=z();ay.exports=AP($P.process)=="process"});var Uu=v(function(gF,ly){"use strict";var HP=Gt().forEach,GP=vr(),KP=GP("forEach");ly.exports=KP?[].forEach:function(t){return HP(this,t,arguments.length>1?arguments[1]:void 0)}});var Yu=j(E());function Xu(){(0,Yu.default)(document).on("submit","form:not([action])",function(e){e.preventDefault()})}var Qu=j(E());function Ju(){var e=window.history.pushState;window.history.pushState=function(){for(var t=arguments.length,r=new Array(t),n=0;n1?arguments[1]:void 0)}});var Tg=A(),hl=yl();Tg({global:!0,forced:parseInt!=hl},{parseInt:hl});var wo=j(E());var gl=!1,bl=!1,jl=-1;function jo(e){gl=e}function wl(e){bl=e}function _l(e){jl=e}function xl(){return gl}function It(){return bl}function Ol(){return jl}var je;function Sl(e){je=e}function Eg(){var e=je.indexOf("MSIE ");if(It()&&e>0)return parseInt(je.substring(e+5,je.indexOf(".",e)),10);var t=je.indexOf("Trident/");if(t>0){var r=je.indexOf("rv:");return parseInt(je.substring(r+3,je.indexOf(".",r)),10)}return-1}function Il(){/\bQt\//.test(je)?((0,wo.default)(document.documentElement).addClass("qt"),jo(!0)):jo(!1),/\bQt\/5/.test(je)&&/Linux/.test(je)&&(0,wo.default)(document.documentElement).addClass("qt5"),wl(/MSIE|Trident|Edge/.test(je)),_l(Eg())}function Rl(){return window.Shiny||(window.Shiny={}),window.Shiny}var hy=j(E());var kg=pe(),Bg=de().f,_o=Function.prototype,Dg=_o.toString,Cg=/^\s*function ([^ (]*)/,Pl="name";kg&&!(Pl in _o)&&Bg(_o,Pl,{configurable:!0,get:function(){try{return Dg.call(this).match(Cg)[1]}catch(e){return""}}});var QT=j(Ie());"use strict";var pb=_r(),db=Y(),mb=fe(),vb=ut(),yb=Ke(),hb=vn(),gb=of(),bb=xr(),jb=Math.max,wb=Math.min,_b=function(e){return e===void 0?e:String(e)};pb("replace",2,function(e,t,r,n){var i=n.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,o=n.REPLACE_KEEPS_$0,a=i?"$":"$0";return[function(l,s){var f=yb(this),c=l==null?void 0:l[e];return c!==void 0?c.call(l,f,s):t.call(String(f),l,s)},function(u,l){if(!i&&o||typeof l=="string"&&l.indexOf(a)===-1){var s=r(t,u,this,l);if(s.done)return s.value}var f=db(u),c=String(this),p=typeof l=="function";p||(l=String(l));var m=f.global;if(m){var d=f.unicode;f.lastIndex=0}for(var y=[];;){var h=bb(f,c);if(h===null||(y.push(h),!m))break;var g=String(h[0]);g===""&&(f.lastIndex=hb(c,mb(f.lastIndex),d))}for(var w="",I=0,_=0;_=I&&(w+=c.slice(I,D)+ge,I=D+P.length)}return w+c.slice(I)}]});var kb=yn(),Bb=We(),Db=cf();kb||Bb(Object.prototype,"toString",Db,{unsafe:!0});"use strict";var Cb=We(),Nb=Y(),Ab=M(),$b=xo(),Do="toString",pf=RegExp.prototype,df=pf[Do],Mb=Ab(function(){return df.call({source:"a",flags:"b"})!="/a/b"}),Vb=df.name!=Do;(Mb||Vb)&&Cb(RegExp.prototype,Do,function(){var t=Nb(this),r=String(t.source),n=t.flags,i=String(n===void 0&&t instanceof RegExp&&!("flags"in pf)?$b.call(t):n);return"/"+r+"/"+i},{unsafe:!0});var Hb=A(),yf=vf();Hb({global:!0,forced:parseFloat!=yf},{parseFloat:yf});"use strict";var Kb=A(),bf=M(),jf=gf(),gn=1 .toPrecision,Wb=bf(function(){return gn.call(1,void 0)!=="1"})||!bf(function(){gn.call({})});Kb({target:"Number",proto:!0,forced:Wb},{toPrecision:function(t){return t===void 0?gn.call(jf(this)):gn.call(jf(this),t)}});"use strict";var aj=A(),uj=M(),sj=Or(),lj=re(),fj=be(),cj=fe(),If=Sr(),pj=bn(),dj=Lt(),mj=G(),vj=br(),Rf=mj("isConcatSpreadable"),Pf=9007199254740991,qf="Maximum allowed index exceeded",yj=vj>=51||!uj(function(){var e=[];return e[Rf]=!1,e.concat()[0]!==e}),hj=dj("concat"),gj=function(e){if(!lj(e))return!1;var t=e[Rf];return t!==void 0?!!t:sj(e)},bj=!yj||!hj;aj({target:"Array",proto:!0,forced:bj},{concat:function(t){var r=fj(this),n=pj(r,0),i=0,o,a,u,l,s;for(o=-1,u=arguments.length;oPf)throw TypeError(qf);for(a=0;a=Pf)throw TypeError(qf);If(n,i++,s)}return n.length=i,n}});"use strict";var jj=A(),wj=re(),Tf=Or(),Ef=Vt(),_j=fe(),xj=Te(),Oj=Sr(),Sj=G(),Ij=Lt(),Rj=Ij("slice"),Pj=Sj("species"),qj=[].slice,Tj=Math.max;jj({target:"Array",proto:!0,forced:!Rj},{slice:function(t,r){var n=xj(this),i=_j(n.length),o=Ef(t,i),a=Ef(r===void 0?i:r,i),u,l,s;if(Tf(n)&&(u=n.constructor,typeof u=="function"&&(u===Array||Tf(u.prototype))?u=void 0:wj(u)&&(u=u[Pj],u===null&&(u=void 0)),u===Array||u===void 0))return qj.call(n,o,a);for(l=new(u===void 0?Array:u)(Tj(a-o,0)),s=0;oLj)throw TypeError(zj);for(s=Nj(n,l),f=0;fi-l+u;f--)delete n[f-1]}else if(u>l)for(f=i-l;f>o;f--)c=f+l-1,p=f+u-1,c in n?n[p]=n[c]:delete n[p];for(f=0;f1||"".split(/.?/).length?n=function(i,o){var a=String(Mf(this)),u=o===void 0?Ff:o>>>0;if(u===0)return[];if(i===void 0)return[a];if(!iw(i))return t.call(a,i,u);for(var l=[],s=(i.ignoreCase?"i":"")+(i.multiline?"m":"")+(i.unicode?"u":"")+(i.sticky?"y":""),f=0,c=new RegExp(i.source,s+"g"),p,m,d;(p=lw.call(c,a))&&(m=c.lastIndex,!(m>f&&(l.push(a.slice(f,p.index)),p.length>1&&p.index=u)));)c.lastIndex===p.index&&c.lastIndex++;return f===a.length?(d||!c.test(""))&&l.push(""):l.push(a.slice(f)),l.length>u?l.slice(0,u):l}:"0".split(void 0,0).length?n=function(i,o){return i===void 0&&o===0?[]:t.call(this,i,o)}:n=t,[function(o,a){var u=Mf(this),l=o==null?void 0:o[e];return l!==void 0?l.call(o,u,a):n.call(String(u),o,a)},function(i,o){var a=r(n,i,this,o,n!==t);if(a.done)return a.value;var u=ow(i),l=String(this),s=aw(u,RegExp),f=u.unicode,c=(u.ignoreCase?"i":"")+(u.multiline?"m":"")+(u.unicode?"u":"")+(Ut?"g":"y"),p=new s(Ut?"^(?:"+u.source+")":u,c),m=o===void 0?Ff:o>>>0;if(m===0)return[];if(l.length===0)return Vf(p,l)===null?[l]:[];for(var d=0,y=0,h=[];y":">",'"':""","'":"'","/":"/"};return e.replace(/[&<>'"/]/g,function(r){return t[r]})}function wn(){return Math.floor(4294967296+Math.random()*64424509440).toString(16)}function Rt(e){if(!(!e||!e.toLowerCase))switch(e.toLowerCase()){case"true":return!0;case"false":return!1;default:return}}function Fe(e,t){var r=void 0;if(e.currentStyle)r=e.currentStyle[t];else if(window.getComputedStyle){var n=document.defaultView.getComputedStyle(e,null);n&&(r=n.getPropertyValue(t))}return r}function Gf(e,t){for(var r=e.toString();r.length1&&arguments[1]!==void 0?arguments[1]:1;if(t<1)throw"Significant digits must be at least 1.";return parseFloat(e.toPrecision(t))}function Kf(e){var t=new Date(e);return t.toString()==="Invalid Date"&&(t=new Date(e.replace(/-/g,"/"))),t}function Ee(e){return e instanceof Date?e.getUTCFullYear()+"-"+Gf(e.getUTCMonth()+1,2)+"-"+Gf(e.getUTCDate(),2):null}function Wf(e,t){var r={};return function(){var n={w:e.offsetWidth,h:e.offsetHeight};n.w===0&&n.h===0||n.w===r.w&&n.h===r.h||(r=n,t(n.w,n.h))}}function Mo(){return Ao()?Math.round(Ao()*100)/100:1}function Yf(e){var t=e.replace(/[\\"']/g,"\\$&").replace(/\u0000/g,"\\0").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/[\b]/g,"\\b"),r;try{r=new Function("with (this) {\n try {\n return (".concat(e,");\n } catch (e) {\n console.error('Error evaluating expression: ").concat(t,"');\n throw e;\n }\n }"))}catch(n){throw console.error("Error parsing expression: "+e),n}return function(n){return r.call(n)}}function Ht(e){return e==null?[]:Array.isArray(e)?e:[e]}function Xf(e,t){function r(s,f,c){for(var p=0,m=0,d=[];p?@[\\\]^`{|}~])/g,"\\$1")};function ke(e,t){var r={};for(var n in e)O(e,n)&&(r[n]=t(e[n],n,e));return r}function Qf(e){return typeof e=="number"&&isNaN(e)}function Vo(e,t){if(Rr.default.type(e)==="object"&&Rr.default.type(t)==="object"){var r=e,n=t;if(Object.keys(r).length!==Object.keys(n).length)return!1;for(var i in r)if(!O(n,i)||!Vo(r[i],n[i]))return!1;return!0}else if(Rr.default.type(e)==="array"&&Rr.default.type(t)==="array"){var o=e,a=t;if(o.length!==a.length)return!1;for(var u=0;u=")return a>=0;if(r===">")return a>0;if(r==="<=")return a<=0;if(r==="<")return a<0;throw"Unknown operator: ".concat(r)};function ne(e,t){if(typeof e!="undefined"){if(t.length!==1)throw new Error("labelNode must be of length 1");var r=Array.isArray(e)&&e.length===0;r?t.addClass("shiny-label-null"):(t.text(e),t.removeClass("shiny-label-null"))}}function Pr(e){var t=document.createElement("a");t.href="/";var r=document.createElement("div");r.style.setProperty("position","absolute","important"),r.style.setProperty("top","-1000px","important"),r.style.setProperty("left","0","important"),r.style.setProperty("width","30px","important"),r.style.setProperty("height","10px","important"),r.appendChild(t),e.appendChild(r);var n=window.getComputedStyle(t).getPropertyValue("color");return e.removeChild(r),n}function Lo(){return!window.bootstrap}function Zf(e){return e.toLowerCase()}function dw(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function ec(e,t){for(var r=0;r2&&arguments[2]!==void 0?arguments[2]:0,o={binding:r,priority:i};this.bindings.unshift(o),n&&(this.bindingNames[n]=o,r.name=n)}},{key:"setPriority",value:function(r,n){var i=this.bindingNames[r];if(!i)throw"Tried to set priority on unknown binding "+r;i.priority=n||0}},{key:"getPriority",value:function(r){var n=this.bindingNames[r];return n?n.priority:!1}},{key:"getBindings",value:function(){return Xf(this.bindings,function(r,n){return n.priority-r.priority})}}]),e}();function vw(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function tc(e,t){for(var r=0;r1?arguments[1]:void 0)}});Lw(Jo);var Gw=A(),Kw=qr();Gw({target:"Object",stat:!0},{setPrototypeOf:Kw});var e_=A(),t_=M(),r_=be(),xc=Wt(),n_=Zo(),i_=t_(function(){xc(1)});e_({target:"Object",stat:!0,forced:i_,sham:!n_},{getPrototypeOf:function(t){return xc(r_(t))}});var s_=A(),l_=St(),Rc=zt(),f_=Y(),Pc=re(),c_=Kt(),p_=Ic(),qc=M(),ta=l_("Reflect","construct"),Tc=qc(function(){function e(){}return!(ta(function(){},[],e)instanceof e)}),Ec=!qc(function(){ta(function(){})}),kc=Tc||Ec;s_({target:"Reflect",stat:!0,forced:kc,sham:kc},{construct:function(t,r){Rc(t),f_(r);var n=arguments.length<3?t:Rc(arguments[2]);if(Ec&&!Tc)return ta(t,r,n);if(t==n){switch(r.length){case 0:return new t;case 1:return new t(r[0]);case 2:return new t(r[0],r[1]);case 3:return new t(r[0],r[1],r[2]);case 4:return new t(r[0],r[1],r[2],r[3])}var i=[null];return i.push.apply(i,r),new(p_.apply(t,i))}var o=n.prototype,a=c_(Pc(o)?o:Object.prototype),u=Function.apply.call(t,a,r);return Pc(u)?u:a}});"use strict";var Yt=A(),Lc=z(),x_=St(),O_=lr(),Xt=pe(),Pt=dn(),S_=qo(),ia=M(),K=le(),I_=Or(),R_=re(),oa=Y(),P_=be(),On=Te(),aa=$t(),ua=At(),Er=Kt(),zc=Ir(),q_=Ft(),Uc=Nc(),sa=vo(),Hc=xt(),Gc=de(),Kc=en(),T_=Se(),la=We(),kr=fr(),E_=cr(),Wc=pr(),Yc=on(),Xc=G(),k_=ra(),B_=na(),D_=Tr(),Qc=Mt(),Sn=Gt().forEach,me=E_("hidden"),In="Symbol",Ye="prototype",Jc=Xc("toPrimitive"),C_=Qc.set,Zc=Qc.getterFor(In),Re=Object[Ye],ve=Lc.Symbol,Br=x_("JSON","stringify"),ep=Hc.f,lt=Gc.f,tp=Uc.f,N_=Kc.f,Xe=kr("symbols"),Dr=kr("op-symbols"),fa=kr("string-to-symbol-registry"),ca=kr("symbol-to-string-registry"),A_=kr("wks"),pa=Lc.QObject,da=!pa||!pa[Ye]||!pa[Ye].findChild,ma=Xt&&ia(function(){return Er(lt({},"a",{get:function(){return lt(this,"a",{value:7}).a}})).a!=7})?function(e,t,r){var n=ep(Re,t);n&&delete Re[t],lt(e,t,r),n&&e!==Re&<(Re,t,n)}:lt,va=function(e,t){var r=Xe[e]=Er(ve[Ye]);return C_(r,{type:In,tag:e,description:t}),Xt||(r.description=t),r},ya=S_?function(e){return typeof e=="symbol"}:function(e){return Object(e)instanceof ve},Rn=function(t,r,n){t===Re&&Rn(Dr,r,n),oa(t);var i=aa(r,!0);return oa(n),K(Xe,i)?(n.enumerable?(K(t,me)&&t[me][i]&&(t[me][i]=!1),n=Er(n,{enumerable:ua(0,!1)})):(K(t,me)||lt(t,me,ua(1,{})),t[me][i]=!0),ma(t,i,n)):lt(t,i,n)},rp=function(t,r){oa(t);var n=On(r),i=zc(n).concat(ga(n));return Sn(i,function(o){(!Xt||ha.call(n,o))&&Rn(t,o,n[o])}),t},$_=function(t,r){return r===void 0?Er(t):rp(Er(t),r)},ha=function(t){var r=aa(t,!0),n=N_.call(this,r);return this===Re&&K(Xe,r)&&!K(Dr,r)?!1:n||!K(this,r)||!K(Xe,r)||K(this,me)&&this[me][r]?n:!0},np=function(t,r){var n=On(t),i=aa(r,!0);if(!(n===Re&&K(Xe,i)&&!K(Dr,i))){var o=ep(n,i);return o&&K(Xe,i)&&!(K(n,me)&&n[me][i])&&(o.enumerable=!0),o}},ip=function(t){var r=tp(On(t)),n=[];return Sn(r,function(i){!K(Xe,i)&&!K(Wc,i)&&n.push(i)}),n},ga=function(t){var r=t===Re,n=tp(r?Dr:On(t)),i=[];return Sn(n,function(o){K(Xe,o)&&(!r||K(Re,o))&&i.push(Xe[o])}),i};Pt||(ve=function(){if(this instanceof ve)throw TypeError("Symbol is not a constructor");var t=!arguments.length||arguments[0]===void 0?void 0:String(arguments[0]),r=Yc(t),n=function(i){this===Re&&n.call(Dr,i),K(this,me)&&K(this[me],r)&&(this[me][r]=!1),ma(this,r,ua(1,i))};return Xt&&da&&ma(Re,r,{configurable:!0,set:n}),va(r,t)},la(ve[Ye],"toString",function(){return Zc(this).tag}),la(ve,"withoutSetter",function(e){return va(Yc(e),e)}),Kc.f=ha,Gc.f=Rn,Hc.f=np,q_.f=Uc.f=ip,sa.f=ga,k_.f=function(e){return va(Xc(e),e)},Xt&&(lt(ve[Ye],"description",{configurable:!0,get:function(){return Zc(this).description}}),O_||la(Re,"propertyIsEnumerable",ha,{unsafe:!0})));Yt({global:!0,wrap:!0,forced:!Pt,sham:!Pt},{Symbol:ve});Sn(zc(A_),function(e){B_(e)});Yt({target:In,stat:!0,forced:!Pt},{for:function(e){var t=String(e);if(K(fa,t))return fa[t];var r=ve(t);return fa[t]=r,ca[r]=t,r},keyFor:function(t){if(!ya(t))throw TypeError(t+" is not a symbol");if(K(ca,t))return ca[t]},useSetter:function(){da=!0},useSimple:function(){da=!1}});Yt({target:"Object",stat:!0,forced:!Pt,sham:!Xt},{create:$_,defineProperty:Rn,defineProperties:rp,getOwnPropertyDescriptor:np});Yt({target:"Object",stat:!0,forced:!Pt},{getOwnPropertyNames:ip,getOwnPropertySymbols:ga});Yt({target:"Object",stat:!0,forced:ia(function(){sa.f(1)})},{getOwnPropertySymbols:function(t){return sa.f(P_(t))}});Br&&(op=!Pt||ia(function(){var e=ve();return Br([e])!="[null]"||Br({a:e})!="{}"||Br(Object(e))!="{}"}),Yt({target:"JSON",stat:!0,forced:op},{stringify:function(t,r,n){for(var i=[t],o=1,a;arguments.length>o;)i.push(arguments[o++]);if(a=r,!(!R_(r)&&t===void 0||ya(t)))return I_(r)||(r=function(u,l){if(typeof a=="function"&&(l=a.call(this,u,l)),!ya(l))return l}),i[1]=r,Br.apply(null,i)}}));var op;ve[Ye][Jc]||T_(ve[Ye],Jc,ve[Ye].valueOf);D_(ve,In);Wc[me]=!0;"use strict";var M_=A(),V_=pe(),F_=z(),L_=le(),z_=re(),U_=de().f,H_=yo(),Qe=F_.Symbol;V_&&typeof Qe=="function"&&(!("description"in Qe.prototype)||Qe().description!==void 0)&&(ba={},Qt=function(){var t=arguments.length<1||arguments[0]===void 0?void 0:String(arguments[0]),r=this instanceof Qt?new Qe(t):t===void 0?Qe():Qe(t);return t===""&&(ba[r]=!0),r},H_(Qt,Qe),Pn=Qt.prototype=Qe.prototype,Pn.constructor=Qt,ap=Pn.toString,up=String(Qe("test"))=="Symbol(test)",sp=/^Symbol\((.*)\)[^)]+$/,U_(Pn,"description",{configurable:!0,get:function(){var t=z_(this)?this.valueOf():this,r=ap.call(t);if(L_(ba,t))return"";var n=up?r.slice(7,-1):r.replace(sp,"$1");return n===""?void 0:n}}),M_({global:!0,forced:!0},{Symbol:Qt}));var ba,Qt,Pn,ap,up,sp;var G_=na();G_("iterator");var tk=j($());"use strict";var mx=ko().charAt,qp=Mt(),vx=Ia(),Tp="String Iterator",yx=qp.set,hx=qp.getterFor(Tp);vx(String,"String",function(e){yx(this,{type:Tp,string:String(e),index:0})},function(){var t=hx(this),r=t.string,n=t.index,i;return n>=r.length?{value:void 0,done:!0}:(i=mx(r,n),t.index+=i.length,{value:i,done:!1})});var gx=z(),kp=Pa(),Nr=$(),qa=Se(),Bp=G(),Ta=Bp("iterator"),Dp=Bp("toStringTag"),Ea=Nr.values;for(var ka in kp)if(Ba=gx[ka],Le=Ba&&Ba.prototype,Le){if(Le[Ta]!==Ea)try{qa(Le,Ta,Ea)}catch(e){Le[Ta]=Ea}if(Le[Dp]||qa(Le,Dp,ka),kp[ka]){for(Tt in Nr)if(Le[Tt]!==Nr[Tt])try{qa(Le,Tt,Nr[Tt])}catch(e){Le[Tt]=Nr[Tt]}}}var Ba,Le,Tt;var Et=j(E());function En(e){return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?En=function(r){return typeof r}:En=function(r){return r&&typeof Symbol=="function"&&r.constructor===Symbol&&r!==Symbol.prototype?"symbol":typeof r},En(e)}function bx(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function Cp(e,t){for(var r=0;r2){if(t=Yx(t),r=t.charCodeAt(0),r===43||r===45){if(n=t.charCodeAt(2),n===88||n===120)return NaN}else if(r===48){switch(t.charCodeAt(1)){case 66:case 98:i=2,o=49;break;case 79:case 111:i=8,o=55;break;default:return+t}for(a=t.slice(2),u=a.length,l=0;lo)return NaN;return parseInt(a,i)}}return+t};if(Vx(Ar,!ft(" 0o1")||!ft("0b1")||ft("+0x1"))){for(ct=function(t){var r=arguments.length<1?0:t,n=this;return n instanceof ct&&(Xx?Ux(function(){Cn.valueOf.call(n)}):Yp(n)!=Ar)?Lx(new ft(Xp(r)),n,ct):Xp(r)},Na=Mx?Gx(ft):"MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger,fromString,range".split(","),Nn=0;Na.length>Nn;Nn++)Wp(ft,$r=Na[Nn])&&!Wp(ct,$r)&&Wx(ct,$r,Kx(ft,$r));ct.prototype=Cn,Cn.constructor=ct,Fx(Kp,Ar,ct)}var ct,Na,Nn,$r;var eB=j($());var Vr=j(E());var Qx=A(),Jx=re(),Zx=Y(),eO=le(),tO=xt(),rO=Wt();function Qp(e,t){var r=arguments.length<3?e:arguments[2],n,i;if(Zx(e)===r)return e[t];if(n=tO.f(e,t))return eO(n,"value")?n.value:n.get===void 0?void 0:n.get.call(r);if(Jx(i=rO(e)))return Qp(i,t,r)}Qx({target:"Reflect",stat:!0},{get:Qp});var nO=A(),iO=M(),oO=Te(),Jp=xt().f,Zp=pe(),aO=iO(function(){Jp(1)}),uO=!Zp||aO;nO({target:"Object",stat:!0,forced:uO,sham:!Zp},{getOwnPropertyDescriptor:function(t,r){return Jp(oO(t),r)}});var Mk=j($());var kt=j(E());function An(e){return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?An=function(r){return typeof r}:An=function(r){return r&&typeof Symbol=="function"&&r.constructor===Symbol&&r!==Symbol.prototype?"symbol":typeof r},An(e)}function ed(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function td(e,t){for(var r=0;ru.getTime()?(0,F.default)(i).bsDatepicker("clearDates"):(0,F.default)(i).bsDatepicker("setUTCDate",u)}}}},{key:"_setMax",value:function(i,o){if(o!==void 0){if(o===null){(0,F.default)(i).bsDatepicker("setEndDate",null);return}var a=this._newDate(o);if(a!==null&&(o=a,!isNaN(o.valueOf()))){var u=(0,F.default)(i).bsDatepicker("getUTCDate");(0,F.default)(i).bsDatepicker("setEndDate",this._utcDateAsLocal(o)),o&&u&&o.getTime()1&&arguments[1]!==void 0?arguments[1]:",",r=arguments.length>2&&arguments[2]!==void 0?arguments[2]:".",n=e.toString().split(".");return n[0]=n[0].replace(/(\d{1,3}(?=(?:\d\d\d)+(?!\d)))/g,"$1"+t),n.length===1?n[0]:n.length===2?n[0]+r+n[1]:""}(0,X.default)(document).on("click",".slider-animate-button",function(e){e.preventDefault();var t=(0,X.default)(this),r=(0,X.default)("#"+q(t.attr("data-target-id"))),n="Play",i="Pause",o=t.attr("data-loop")!==void 0&&!/^\s*false\s*$/i.test(t.attr("data-loop")),a=t.attr("data-interval");if(isNaN(a)?a=1500:a=Number(a),r.data("animTimer"))clearTimeout(r.data("animTimer")),r.removeData("animTimer"),t.attr("title",n),t.removeClass("playing"),r.removeData("animating");else{var u;if(r.hasClass("jslider")){var l=r.slider();l.canStepNext()||l.resetToStart(),u=setInterval(function(){o&&!l.canStepNext()?l.resetToStart():(l.stepNext(),!o&&!l.canStepNext()&&t.click())},a)}else{var s=r.data("ionRangeSlider"),f=function(){return s.options.type==="double"?s.result.to0}var Bd=function(e){sS(r,e);var t=lS(r);function r(){return aS(this,r),t.apply(this,arguments)}return uS(r,[{key:"find",value:function(i){return(0,U.default)(i).find("select")}},{key:"getType",value:function(i){var o=(0,U.default)(i);return o.hasClass("symbol")?o.attr("multiple")==="multiple"?"shiny.symbolList":"shiny.symbol":null}},{key:"getId",value:function(i){return V.prototype.getId.call(this,i)||i.name}},{key:"getValue",value:function(i){return(0,U.default)(i).val()}},{key:"setValue",value:function(i,o){if(!kd(i))(0,U.default)(i).val(o);else{var a=this._selectize(i);a&&a.setValue(o)}}},{key:"getState",value:function(i){for(var o=new Array(i.length),a=0;a1&&arguments[1]!==void 0?arguments[1]:!1;if(!!U.default.fn.selectize){var a=(0,U.default)(i),u=a.parent().find('script[data-for="'+q(i.id)+'"]');if(u.length!==0){var l=U.default.extend({labelField:"label",valueField:"value",searchField:["label"]},JSON.parse(u.html()));typeof u.data("nonempty")!="undefined"?(i.nonempty=!0,l=U.default.extend(l,{onItemRemove:function(p){this.getValue()===""&&(0,U.default)("select#"+q(i.id)).empty().append((0,U.default)("