{"version":3,"file":"static/js/c4eec837ce9df97a56cf.bundle.js","mappings":"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","sources":["webpack://@msdyn365-commerce-partners/fabrikam/../src/StyleOptionsState.ts?6e9d","webpack://@msdyn365-commerce-partners/fabrikam/../src/Stylesheet.ts?2b78","webpack://@msdyn365-commerce-partners/fabrikam/../src/concatStyleSets.ts?985c","webpack://@msdyn365-commerce-partners/fabrikam/../src/fontFace.ts?ba43","webpack://@msdyn365-commerce-partners/fabrikam/../src/getVendorSettings.ts?57f5","webpack://@msdyn365-commerce-partners/fabrikam/../src/transforms/kebabRules.ts?e9b6","webpack://@msdyn365-commerce-partners/fabrikam/../src/transforms/prefixRules.ts?7003","webpack://@msdyn365-commerce-partners/fabrikam/../src/transforms/provideUnits.ts?6886","webpack://@msdyn365-commerce-partners/fabrikam/../src/transforms/rtlifyRules.ts?296f","webpack://@msdyn365-commerce-partners/fabrikam/../src/styleToClassName.ts?36c7","webpack://@msdyn365-commerce-partners/fabrikam/../src/styles/hiddenContentStyle.ts?446a","webpack://@msdyn365-commerce-partners/fabrikam/../src/styles/getGlobalClassNames.ts?37db","webpack://@msdyn365-commerce-partners/fabrikam/../src/styles/CommonStyles.ts?85af","webpack://@msdyn365-commerce-partners/fabrikam/../src/keyframes.ts?0aa9","webpack://@msdyn365-commerce-partners/fabrikam/../src/setVersion.ts?84dd","webpack://@msdyn365-commerce-partners/fabrikam/../src/index.ts?6f37","webpack://@msdyn365-commerce-partners/fabrikam/../src/version.ts?0003","webpack://@msdyn365-commerce-partners/fabrikam/../src/styles/theme.ts?23d7","webpack://@msdyn365-commerce-partners/fabrikam/../src/DelayedRender.tsx?982e","webpack://@msdyn365-commerce-partners/fabrikam/../src/extractStyleParts.ts?3aec","webpack://@msdyn365-commerce-partners/fabrikam/../src/mergeStyleSets.ts?fe5d","webpack://@msdyn365-commerce-partners/fabrikam/../src/rtl.ts?c642","webpack://@msdyn365-commerce-partners/fabrikam/../src/classNamesFunction.ts?d5ba","webpack://@msdyn365-commerce-partners/fabrikam/../src/GlobalSettings.ts?e817","webpack://@msdyn365-commerce-partners/fabrikam/../src/customizations/Customizations.ts?aff4","webpack://@msdyn365-commerce-partners/fabrikam/../src/dom/getDocument.ts?8890","webpack://@msdyn365-commerce-partners/fabrikam/../src/dom/getWindow.ts?82a7","webpack://@msdyn365-commerce-partners/fabrikam/../src/dom/setSSR.ts?5961","webpack://@msdyn365-commerce-partners/fabrikam/../src/language.ts?7f1b","webpack://@msdyn365-commerce-partners/fabrikam/../src/localStorage.ts?a4c3","webpack://@msdyn365-commerce-partners/fabrikam/../src/memoize.ts?10c6","webpack://@msdyn365-commerce-partners/fabrikam/../src/merge.ts?8d44","webpack://@msdyn365-commerce-partners/fabrikam/../src/properties.ts?6a7f","webpack://@msdyn365-commerce-partners/fabrikam/../src/sessionStorage.ts?f322","webpack://@msdyn365-commerce-partners/fabrikam/../src/customizations/CustomizerContext.ts?228b","webpack://@msdyn365-commerce-partners/fabrikam/../src/customizations/useCustomizationSettings.ts?00f5","webpack://@msdyn365-commerce-partners/fabrikam/../src/styled.tsx?7957","webpack://@msdyn365-commerce-partners/fabrikam/../src/concatStyleSetsWithProps.ts?ec44","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/uncontrollable/lib/esm/hook.js?0848","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/underscore/underscore.js?a6c9","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/punycode/punycode.js?9346","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/qs/lib/formats.js?3248","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/qs/lib/index.js?bd8b","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/qs/lib/parse.js?2425","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/qs/lib/stringify.js?2440","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/node_modules/qs/lib/utils.js?ad85","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/url/url.js?c2c4","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/uuid/lib/bytesToUuid.js?d625","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/uuid/lib/rng-browser.js?b3a8","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/uuid/v1.js?2d46","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/uuid/v4.js?088a","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/warning/warning.js?aa7d","webpack://@msdyn365-commerce-partners/fabrikam/./node_modules/web-vitals/dist/web-vitals.js?9b79"],"sourcesContent":["import { IStyleOptions } from './IStyleOptions';\n\n/**\n * Sets the current RTL value.\n */\nexport function setRTL(isRTL: boolean): void {\n  if (_rtl !== isRTL) {\n    _rtl = isRTL;\n  }\n}\n\n/**\n * Gets the current RTL value.\n */\nexport function getRTL(): boolean {\n  if (_rtl === undefined) {\n    _rtl =\n      typeof document !== 'undefined' &&\n      !!document.documentElement &&\n      document.documentElement.getAttribute('dir') === 'rtl';\n  }\n  return _rtl;\n}\n\n// This has been split into 2 lines because it was working in Fabric due to the code being transpiled to es5, so this\n// was converted to var while not working in Fluent that uses babel to transpile the code to be es6-like. Splitting the\n// logic into two lines, however, allows it to work in both scenarios.\nlet _rtl: boolean;\n_rtl = getRTL();\n\nexport function getStyleOptions(): IStyleOptions {\n  return {\n    rtl: getRTL(),\n  };\n}\n","import { IStyle } from './IStyle';\n\nexport const InjectionMode = {\n  /**\n   * Avoids style injection, use getRules() to read the styles.\n   */\n  none: 0 as 0,\n\n  /**\n   * Inserts rules using the insertRule api.\n   */\n  insertNode: 1 as 1,\n\n  /**\n   * Appends rules using appendChild.\n   */\n  appendChild: 2 as 2,\n};\n\nexport type InjectionMode = typeof InjectionMode[keyof typeof InjectionMode];\n\n/**\n * CSP settings for the stylesheet\n */\nexport interface ICSPSettings {\n  /**\n   * Nonce to inject into script tag\n   */\n  nonce?: string;\n}\n\n/**\n * Stylesheet config.\n *\n * @public\n */\nexport interface IStyleSheetConfig {\n  /**\n   * Injection mode for how rules are inserted.\n   */\n  injectionMode?: InjectionMode;\n\n  /**\n   * Default 'displayName' to use for a className.\n   * @defaultvalue 'css'\n   */\n  defaultPrefix?: string;\n\n  /**\n   * Defines the default direction of rules for auto-rtlifying things.\n   * While typically this is represented as a DIR attribute in the markup,\n   * the DIR is not enough to control whether padding goes on the left or\n   * right. Use this to set the default direction when rules are registered.\n   */\n  rtl?: boolean;\n\n  /**\n   * Default 'namespace' to attach before the className.\n   */\n  namespace?: string;\n\n  /**\n   * CSP settings\n   */\n  cspSettings?: ICSPSettings;\n\n  /**\n   * Callback executed when a rule is inserted.\n   */\n  onInsertRule?: (rule: string) => void;\n\n  /**\n   * Initial value for classnames cache. Key is serialized css rules associated with a classname.\n   */\n  classNameCache?: { [key: string]: string };\n}\n\nconst STYLESHEET_SETTING = '__stylesheet__';\n/**\n * MSIE 11 doesn't cascade styles based on DOM ordering, but rather on the order that each style node\n * is created. As such, to maintain consistent priority, IE11 should reuse a single style node.\n */\nconst REUSE_STYLE_NODE = typeof navigator !== 'undefined' && /rv:11.0/.test(navigator.userAgent);\n\nlet _global: { [key: string]: any } = {};\n\n// Grab window.\ntry {\n  _global = window;\n} catch {\n  /* leave as blank object */\n}\n\nlet _stylesheet: Stylesheet;\n\n/**\n * Represents the state of styles registered in the page. Abstracts\n * the surface for adding styles to the stylesheet, exposes helpers\n * for reading the styles registered in server rendered scenarios.\n *\n * @public\n */\nexport class Stylesheet {\n  private _lastStyleElement?: HTMLStyleElement;\n  private _styleElement?: HTMLStyleElement;\n  private _rules: string[] = [];\n  private _preservedRules: string[] = [];\n  private _config: IStyleSheetConfig;\n  private _rulesToInsert: string[] = [];\n  private _counter = 0;\n  private _keyToClassName: { [key: string]: string } = {};\n  private _onResetCallbacks: (() => void)[] = [];\n\n  private _classNameToArgs: { [key: string]: { args: any; rules: string[] } } = {};\n\n  /**\n   * Gets the singleton instance.\n   */\n  public static getInstance(): Stylesheet {\n    _stylesheet = _global[STYLESHEET_SETTING] as Stylesheet;\n\n    if (!_stylesheet || (_stylesheet._lastStyleElement && _stylesheet._lastStyleElement.ownerDocument !== document)) {\n      const fabricConfig = _global?.FabricConfig || {};\n\n      _stylesheet = _global[STYLESHEET_SETTING] = new Stylesheet(fabricConfig.mergeStyles);\n    }\n\n    return _stylesheet;\n  }\n\n  constructor(config?: IStyleSheetConfig) {\n    this._config = {\n      injectionMode: InjectionMode.insertNode,\n      defaultPrefix: 'css',\n      namespace: undefined,\n      cspSettings: undefined,\n      ...config,\n    };\n\n    this._keyToClassName = this._config.classNameCache || {};\n  }\n\n  /**\n   * Configures the stylesheet.\n   */\n  public setConfig(config?: IStyleSheetConfig): void {\n    this._config = {\n      ...this._config,\n      ...config,\n    };\n  }\n\n  /**\n   * Configures a reset callback.\n   *\n   * @param callback - A callback which will be called when the Stylesheet is reset.\n   */\n  public onReset(callback: () => void): void {\n    this._onResetCallbacks.push(callback);\n  }\n\n  /**\n   * Generates a unique classname.\n   *\n   * @param displayName - Optional value to use as a prefix.\n   */\n  public getClassName(displayName?: string): string {\n    const { namespace } = this._config;\n    const prefix = displayName || this._config.defaultPrefix;\n\n    return `${namespace ? namespace + '-' : ''}${prefix}-${this._counter++}`;\n  }\n\n  /**\n   * Used internally to cache information about a class which was\n   * registered with the stylesheet.\n   */\n  public cacheClassName(className: string, key: string, args: IStyle[], rules: string[]): void {\n    this._keyToClassName[key] = className;\n    this._classNameToArgs[className] = {\n      args,\n      rules,\n    };\n  }\n\n  /**\n   * Gets the appropriate classname given a key which was previously\n   * registered using cacheClassName.\n   */\n  public classNameFromKey(key: string): string | undefined {\n    return this._keyToClassName[key];\n  }\n\n  /**\n   * Gets all classnames cache with the stylesheet.\n   */\n  public getClassNameCache(): { [key: string]: string } {\n    return this._keyToClassName;\n  }\n\n  /**\n   * Gets the arguments associated with a given classname which was\n   * previously registered using cacheClassName.\n   */\n  public argsFromClassName(className: string): IStyle[] | undefined {\n    const entry = this._classNameToArgs[className];\n\n    return entry && entry.args;\n  }\n\n  /**\n   * Gets the arguments associated with a given classname which was\n   * previously registered using cacheClassName.\n   */\n  public insertedRulesFromClassName(className: string): string[] | undefined {\n    const entry = this._classNameToArgs[className];\n\n    return entry && entry.rules;\n  }\n\n  /**\n   * Inserts a css rule into the stylesheet.\n   * @param preserve - Preserves the rule beyond a reset boundary.\n   */\n  public insertRule(rule: string, preserve?: boolean): void {\n    const { injectionMode } = this._config;\n    const element = injectionMode !== InjectionMode.none ? this._getStyleElement() : undefined;\n\n    if (preserve) {\n      this._preservedRules.push(rule);\n    }\n\n    if (element) {\n      switch (this._config.injectionMode) {\n        case InjectionMode.insertNode:\n          const { sheet } = element!;\n\n          try {\n            (sheet as CSSStyleSheet).insertRule(rule, (sheet as CSSStyleSheet).cssRules.length);\n          } catch (e) {\n            // The browser will throw exceptions on unsupported rules (such as a moz prefix in webkit.)\n            // We need to swallow the exceptions for this scenario, otherwise we'd need to filter\n            // which could be slower and bulkier.\n          }\n          break;\n\n        case InjectionMode.appendChild:\n          element.appendChild(document.createTextNode(rule));\n          break;\n      }\n    } else {\n      this._rules.push(rule);\n    }\n\n    if (this._config.onInsertRule) {\n      this._config.onInsertRule(rule);\n    }\n  }\n\n  /**\n   * Gets all rules registered with the stylesheet; only valid when\n   * using InsertionMode.none.\n   */\n  public getRules(includePreservedRules?: boolean): string {\n    return (\n      (includePreservedRules ? this._preservedRules.join('') : '') + this._rules.join('') + this._rulesToInsert.join('')\n    );\n  }\n\n  /**\n   * Resets the internal state of the stylesheet. Only used in server\n   * rendered scenarios where we're using InsertionMode.none.\n   */\n  public reset(): void {\n    this._rules = [];\n    this._rulesToInsert = [];\n    this._counter = 0;\n    this._classNameToArgs = {};\n    this._keyToClassName = {};\n\n    this._onResetCallbacks.forEach((callback: () => void) => callback());\n  }\n\n  // Forces the regeneration of incoming styles without totally resetting the stylesheet.\n  public resetKeys(): void {\n    this._keyToClassName = {};\n  }\n\n  private _getStyleElement(): HTMLStyleElement | undefined {\n    if (!this._styleElement && typeof document !== 'undefined') {\n      this._styleElement = this._createStyleElement();\n\n      if (!REUSE_STYLE_NODE) {\n        // Reset the style element on the next frame.\n        window.requestAnimationFrame(() => {\n          this._styleElement = undefined;\n        });\n      }\n    }\n    return this._styleElement;\n  }\n\n  private _createStyleElement(): HTMLStyleElement {\n    const head: HTMLHeadElement = document.head;\n    const styleElement = document.createElement('style');\n    let nodeToInsertBefore: Node | null = null;\n\n    styleElement.setAttribute('data-merge-styles', 'true');\n\n    const { cspSettings } = this._config;\n    if (cspSettings) {\n      if (cspSettings.nonce) {\n        styleElement.setAttribute('nonce', cspSettings.nonce);\n      }\n    }\n    if (this._lastStyleElement) {\n      // If the `nextElementSibling` is null, then the insertBefore will act as a regular append.\n      // https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore#Syntax\n      nodeToInsertBefore = this._lastStyleElement.nextElementSibling;\n    } else {\n      const placeholderStyleTag: Element | null = this._findPlaceholderStyleTag();\n\n      if (placeholderStyleTag) {\n        nodeToInsertBefore = placeholderStyleTag.nextElementSibling;\n      } else {\n        nodeToInsertBefore = head.childNodes[0];\n      }\n    }\n\n    head!.insertBefore(styleElement, head!.contains(nodeToInsertBefore) ? nodeToInsertBefore : null);\n    this._lastStyleElement = styleElement;\n\n    return styleElement;\n  }\n\n  private _findPlaceholderStyleTag(): Element | null {\n    const head: HTMLHeadElement = document.head;\n    if (head) {\n      return head.querySelector('style[data-merge-styles]');\n    }\n    return null;\n  }\n}\n","import { IStyleSet, IConcatenatedStyleSet } from './IStyleSet';\nimport { IStyleBase, IStyle } from './IStyle';\nimport { IStyleFunctionOrObject } from './IStyleFunction';\nimport { ObjectOnly } from './ObjectOnly';\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet - The first style set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet>(\n  styleSet: TStyleSet | false | null | undefined,\n): IConcatenatedStyleSet<ObjectOnly<TStyleSet>>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet1 - The first style set to be concatenated.\n * @param styleSet2 - The second style set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet1, TStyleSet2>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n): IConcatenatedStyleSet<ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2>>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet1 - The first style set to be concatenated.\n * @param styleSet2 - The second style set to be concatenated.\n * @param styleSet3 - The third style set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet1, TStyleSet2, TStyleSet3>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n): IConcatenatedStyleSet<ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2> & ObjectOnly<TStyleSet3>>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet1 - The first style set to be concatenated.\n * @param styleSet2 - The second style set to be concatenated.\n * @param styleSet3 - The third style set to be concatenated.\n * @param styleSet4 - The fourth style set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet1, TStyleSet2, TStyleSet3, TStyleSet4>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n  styleSet4: TStyleSet4 | false | null | undefined,\n): IConcatenatedStyleSet<\n  ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2> & ObjectOnly<TStyleSet3> & ObjectOnly<TStyleSet4>\n>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet1 - The first style set to be concatenated.\n * @param styleSet2 - The second style set to be concatenated.\n * @param styleSet3 - The third style set to be concatenated.\n * @param styleSet4 - The fourth style set to be concatenated.\n * @param styleSet5 - The fifth set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet1, TStyleSet2, TStyleSet3, TStyleSet4, TStyleSet5>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n  styleSet4: TStyleSet4 | false | null | undefined,\n  styleSet5: TStyleSet5 | false | null | undefined,\n): IConcatenatedStyleSet<\n  ObjectOnly<TStyleSet1> &\n    ObjectOnly<TStyleSet2> &\n    ObjectOnly<TStyleSet3> &\n    ObjectOnly<TStyleSet4> &\n    ObjectOnly<TStyleSet5>\n>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSet1 - The first style set to be concatenated.\n * @param styleSet2 - The second style set to be concatenated.\n * @param styleSet3 - The third style set to be concatenated.\n * @param styleSet4 - The fourth style set to be concatenated.\n * @param styleSet5 - The fifth set to be concatenated.\n * @param styleSet6 - The sixth set to be concatenated.\n */\nexport function concatStyleSets<TStyleSet1, TStyleSet2, TStyleSet3, TStyleSet4, TStyleSet5, TStyleSet6>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n  styleSet4: TStyleSet4 | false | null | undefined,\n  styleSet5: TStyleSet5 | false | null | undefined,\n  styleSet6: TStyleSet6 | false | null | undefined,\n): IConcatenatedStyleSet<\n  ObjectOnly<TStyleSet1> &\n    ObjectOnly<TStyleSet2> &\n    ObjectOnly<TStyleSet3> &\n    ObjectOnly<TStyleSet4> &\n    ObjectOnly<TStyleSet5> &\n    ObjectOnly<TStyleSet6>\n>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSets - One or more stylesets to be merged (each param can also be falsy).\n */\nexport function concatStyleSets(...styleSets: (IStyleSet | false | null | undefined)[]): IConcatenatedStyleSet<any>;\n\n/**\n * Combine a set of styles together (but does not register css classes).\n * @param styleSets - One or more stylesets to be merged (each param can also be falsy).\n */\nexport function concatStyleSets(...styleSets: (IStyleSet | false | null | undefined)[]): IConcatenatedStyleSet<any> {\n  if (styleSets && styleSets.length === 1 && styleSets[0] && !(styleSets[0] as IStyleSet).subComponentStyles) {\n    return styleSets[0] as IConcatenatedStyleSet<any>;\n  }\n\n  const mergedSet: IConcatenatedStyleSet<any> = {};\n\n  // We process sub component styles in two phases. First we collect them, then we combine them into 1 style function.\n  const workingSubcomponentStyles: { [key: string]: Array<IStyleFunctionOrObject<any, any>> } = {};\n\n  for (const currentSet of styleSets) {\n    if (currentSet) {\n      for (const prop in currentSet) {\n        if (currentSet.hasOwnProperty(prop)) {\n          if (prop === 'subComponentStyles' && currentSet.subComponentStyles !== undefined) {\n            // subcomponent styles - style functions or objects\n\n            const currentComponentStyles = currentSet.subComponentStyles;\n            for (const subCompProp in currentComponentStyles) {\n              if (currentComponentStyles.hasOwnProperty(subCompProp)) {\n                if (workingSubcomponentStyles.hasOwnProperty(subCompProp)) {\n                  workingSubcomponentStyles[subCompProp].push(currentComponentStyles[subCompProp]);\n                } else {\n                  workingSubcomponentStyles[subCompProp] = [currentComponentStyles[subCompProp]];\n                }\n              }\n            }\n\n            continue;\n          }\n\n          // the as any casts below is a workaround for ts 2.8.\n          // todo: remove cast to any in ts 2.9.\n          const mergedValue: IStyle = (mergedSet as any)[prop];\n          const currentValue = (currentSet as any)[prop];\n\n          if (mergedValue === undefined) {\n            (mergedSet as any)[prop] = currentValue;\n          } else {\n            (mergedSet as any)[prop] = [\n              // https://github.com/Microsoft/TypeScript/issues/25474\n              ...(Array.isArray(mergedValue) ? mergedValue : [mergedValue as IStyleBase]),\n              ...(Array.isArray(currentValue) ? currentValue : [currentValue as IStyleBase]),\n            ];\n          }\n        }\n      }\n    }\n  }\n\n  if (Object.keys(workingSubcomponentStyles).length > 0) {\n    mergedSet.subComponentStyles = {};\n    const mergedSubStyles = mergedSet.subComponentStyles;\n\n    // now we process the subcomponent styles if there are any\n    for (const subCompProp in workingSubcomponentStyles) {\n      if (workingSubcomponentStyles.hasOwnProperty(subCompProp)) {\n        const workingSet = workingSubcomponentStyles[subCompProp];\n        mergedSubStyles[subCompProp] = (styleProps: any) => {\n          return concatStyleSets(\n            ...workingSet.map((styleFunctionOrObject: IStyleFunctionOrObject<any, any>) =>\n              typeof styleFunctionOrObject === 'function' ? styleFunctionOrObject(styleProps) : styleFunctionOrObject,\n            ),\n          );\n        };\n      }\n    }\n  }\n\n  return mergedSet;\n}\n","import { IFontFace } from './IRawStyleBase';\nimport { getStyleOptions } from './StyleOptionsState';\nimport { Stylesheet } from './Stylesheet';\nimport { serializeRuleEntries } from './styleToClassName';\n\n/**\n * Registers a font face.\n * @public\n */\nexport function fontFace(font: IFontFace): void {\n  Stylesheet.getInstance().insertRule(`@font-face{${serializeRuleEntries(getStyleOptions(), font as {})}}`, true);\n}\n","export interface IVendorSettings {\n  isWebkit?: boolean;\n  isMoz?: boolean;\n  isMs?: boolean;\n  isOpera?: boolean;\n}\n\nlet _vendorSettings: IVendorSettings | undefined;\n\nexport function getVendorSettings(): IVendorSettings {\n  if (!_vendorSettings) {\n    const doc = typeof document !== 'undefined' ? document : undefined;\n    const nav = typeof navigator !== 'undefined' ? navigator : undefined;\n    const userAgent = nav?.userAgent?.toLowerCase();\n\n    if (!doc) {\n      _vendorSettings = {\n        isWebkit: true,\n        isMoz: true,\n        isOpera: true,\n        isMs: true,\n      };\n    } else {\n      _vendorSettings = {\n        isWebkit: !!(doc && 'WebkitAppearance' in doc.documentElement.style),\n        isMoz: !!(userAgent && userAgent.indexOf('firefox') > -1),\n        isOpera: !!(userAgent && userAgent.indexOf('opera') > -1),\n        isMs: !!(nav && (/rv:11.0/i.test(nav.userAgent) || /Edge\\/\\d./i.test(navigator.userAgent))),\n      };\n    }\n  }\n\n  return _vendorSettings;\n}\n\n/**\n * Sets the vendor settings for prefixing and vendor specific operations.\n */\nexport function setVendorSettings(vendorSettings?: IVendorSettings): void {\n  _vendorSettings = vendorSettings;\n}\n","const rules: { [key: string]: string } = {};\n\nexport function kebabRules(rulePairs: (string | number)[], index: number): void {\n  const rule: string = rulePairs[index] as string;\n\n  if (rule.charAt(0) !== '-') {\n    rulePairs[index] = rules[rule] = rules[rule] || rule.replace(/([A-Z])/g, '-$1').toLowerCase();\n  }\n}\n","import { getVendorSettings } from '../getVendorSettings';\n\nconst autoPrefixNames: { [key: string]: number } = {\n  'user-select': 1,\n};\n\nexport function prefixRules(rulePairs: (string | number)[], index: number): void {\n  const vendorSettings = getVendorSettings();\n\n  const name = rulePairs[index];\n\n  if (autoPrefixNames[name]) {\n    const value = rulePairs[index + 1];\n\n    if (autoPrefixNames[name]) {\n      if (vendorSettings.isWebkit) {\n        rulePairs.push('-webkit-' + name, value);\n      }\n      if (vendorSettings.isMoz) {\n        rulePairs.push('-moz-' + name, value);\n      }\n      if (vendorSettings.isMs) {\n        rulePairs.push('-ms-' + name, value);\n      }\n      if (vendorSettings.isOpera) {\n        rulePairs.push('-o-' + name, value);\n      }\n    }\n  }\n}\n","const NON_PIXEL_NUMBER_PROPS = [\n  'column-count',\n  'font-weight',\n  'flex',\n  'flex-grow',\n  'flex-shrink',\n  'fill-opacity',\n  'opacity',\n  'order',\n  'z-index',\n  'zoom',\n];\n\nexport function provideUnits(rulePairs: (string | number)[], index: number): void {\n  const name = rulePairs[index] as string;\n  const value = rulePairs[index + 1];\n\n  if (typeof value === 'number') {\n    const isNonPixelProp = NON_PIXEL_NUMBER_PROPS.indexOf(name as string) > -1;\n    const isVariableOrPrefixed = name.indexOf('--') > -1;\n    const unit = isNonPixelProp || isVariableOrPrefixed ? '' : 'px';\n\n    rulePairs[index + 1] = `${value}${unit}`;\n  }\n}\n","import { IStyleOptions } from '../IStyleOptions';\n\nconst LEFT = 'left';\nconst RIGHT = 'right';\nconst NO_FLIP = '@noflip';\nconst NAME_REPLACEMENTS: { [key: string]: string } = {\n  [LEFT]: RIGHT,\n  [RIGHT]: LEFT,\n};\nconst VALUE_REPLACEMENTS: { [key: string]: string } = {\n  'w-resize': 'e-resize',\n  'sw-resize': 'se-resize',\n  'nw-resize': 'ne-resize',\n};\n\n/**\n * RTLifies the rulePair in the array at the current index. This mutates the array for performance\n * reasons.\n */\nexport function rtlifyRules(options: IStyleOptions, rulePairs: (string | number)[], index: number): void {\n  if (options.rtl) {\n    const name = rulePairs[index] as string;\n\n    if (!name) {\n      return;\n    }\n\n    const value = rulePairs[index + 1] as string;\n\n    if (typeof value === 'string' && value.indexOf(NO_FLIP) >= 0) {\n      rulePairs[index + 1] = value.replace(/\\s*(?:\\/\\*\\s*)?\\@noflip\\b(?:\\s*\\*\\/)?\\s*?/g, '');\n    } else if (name.indexOf(LEFT) >= 0) {\n      rulePairs[index] = name.replace(LEFT, RIGHT);\n    } else if (name.indexOf(RIGHT) >= 0) {\n      rulePairs[index] = name.replace(RIGHT, LEFT);\n    } else if (String(value).indexOf(LEFT) >= 0) {\n      rulePairs[index + 1] = value.replace(LEFT, RIGHT);\n    } else if (String(value).indexOf(RIGHT) >= 0) {\n      rulePairs[index + 1] = value.replace(RIGHT, LEFT);\n    } else if (NAME_REPLACEMENTS[name]) {\n      rulePairs[index] = NAME_REPLACEMENTS[name];\n    } else if (VALUE_REPLACEMENTS[value]) {\n      rulePairs[index + 1] = VALUE_REPLACEMENTS[value];\n    } else {\n      switch (name) {\n        case 'margin':\n        case 'padding':\n          rulePairs[index + 1] = flipQuad(value);\n          break;\n        case 'box-shadow':\n          rulePairs[index + 1] = negateNum(value, 0);\n          break;\n      }\n    }\n  }\n}\n\n/**\n * Given a string value in a space delimited format (e.g. \"1 2 3 4\"), negates a particular value.\n */\nfunction negateNum(value: string, partIndex: number): string {\n  const parts = value.split(' ');\n  const numberVal = parseInt(parts[partIndex], 10);\n\n  parts[0] = parts[0].replace(String(numberVal), String(numberVal * -1));\n\n  return parts.join(' ');\n}\n\n/**\n * Given a string quad, flips the left and right values.\n */\nfunction flipQuad(value: string): string {\n  if (typeof value === 'string') {\n    const parts = value.split(' ');\n\n    if (parts.length === 4) {\n      return `${parts[0]} ${parts[3]} ${parts[2]} ${parts[1]}`;\n    }\n  }\n\n  return value;\n}\n","import { IStyle } from './IStyle';\nimport { IRawStyle } from './IRawStyle';\n\nimport { Stylesheet } from './Stylesheet';\nimport { kebabRules } from './transforms/kebabRules';\nimport { prefixRules } from './transforms/prefixRules';\nimport { provideUnits } from './transforms/provideUnits';\nimport { rtlifyRules } from './transforms/rtlifyRules';\nimport { IStyleOptions } from './IStyleOptions';\n\nconst DISPLAY_NAME = 'displayName';\n\ntype IDictionary = { [key: string]: any };\n\ninterface IRuleSet {\n  __order: string[];\n  [key: string]: IDictionary;\n}\n\nfunction getDisplayName(rules?: { [key: string]: IRawStyle }): string | undefined {\n  const rootStyle: IStyle = rules && rules['&'];\n\n  return rootStyle ? (rootStyle as IRawStyle).displayName : undefined;\n}\n\nconst globalSelectorRegExp = /\\:global\\((.+?)\\)/g;\n\ntype ReplacementInfo = [number, number, string];\n\n/**\n * Finds comma separated selectors in a :global() e.g. \":global(.class1, .class2, .class3)\"\n * and wraps them each in their own global \":global(.class1), :global(.class2), :global(.class3)\"\n *\n * @param selectorWithGlobals The selector to process\n * @returns The updated selector\n */\nfunction expandCommaSeparatedGlobals(selectorWithGlobals: string): string {\n  // We the selector does not have a :global() we can shortcut\n  if (!globalSelectorRegExp.test(selectorWithGlobals)) {\n    return selectorWithGlobals;\n  }\n\n  const replacementInfo: ReplacementInfo[] = [];\n\n  const findGlobal = /\\:global\\((.+?)\\)/g;\n  let match = null;\n  // Create a result list for global selectors so we can replace them.\n  while ((match = findGlobal.exec(selectorWithGlobals))) {\n    // Only if the found selector is a comma separated list we'll process it.\n    if (match[1].indexOf(',') > -1) {\n      replacementInfo.push([\n        match.index,\n        match.index + match[0].length,\n        // Wrap each of the found selectors in :global()\n        match[1]\n          .split(',')\n          .map((v: string) => `:global(${v.trim()})`)\n          .join(', '),\n      ]);\n    }\n  }\n\n  // Replace the found selectors with their wrapped variants in reverse order\n  return replacementInfo\n    .reverse()\n    .reduce((selector: string, [matchIndex, matchEndIndex, replacement]: ReplacementInfo) => {\n      const prefix = selector.slice(0, matchIndex);\n      const suffix = selector.slice(matchEndIndex);\n\n      return prefix + replacement + suffix;\n    }, selectorWithGlobals);\n}\n\nfunction expandSelector(newSelector: string, currentSelector: string): string {\n  if (newSelector.indexOf(':global(') >= 0) {\n    return newSelector.replace(globalSelectorRegExp, '$1');\n  } else if (newSelector.indexOf(':') === 0) {\n    return currentSelector + newSelector;\n  } else if (newSelector.indexOf('&') < 0) {\n    return currentSelector + ' ' + newSelector;\n  }\n\n  return newSelector;\n}\n\nfunction extractSelector(currentSelector: string, rules: IRuleSet = { __order: [] }, selector: string, value: IStyle) {\n  if (selector.indexOf('@') === 0) {\n    selector = selector + '{' + currentSelector;\n    extractRules([value], rules, selector);\n  } else if (selector.indexOf(',') > -1) {\n    expandCommaSeparatedGlobals(selector)\n      .split(',')\n      .map((s: string) => s.trim())\n      .forEach((separatedSelector: string) =>\n        extractRules([value], rules, expandSelector(separatedSelector, currentSelector)),\n      );\n  } else {\n    extractRules([value], rules, expandSelector(selector, currentSelector));\n  }\n}\n\nfunction extractRules(args: IStyle[], rules: IRuleSet = { __order: [] }, currentSelector: string = '&'): IRuleSet {\n  const stylesheet = Stylesheet.getInstance();\n  let currentRules: IDictionary | undefined = rules[currentSelector] as IDictionary;\n\n  if (!currentRules) {\n    currentRules = {};\n    rules[currentSelector] = currentRules;\n    rules.__order.push(currentSelector);\n  }\n\n  for (const arg of args) {\n    // If the arg is a string, we need to look up the class map and merge.\n    if (typeof arg === 'string') {\n      const expandedRules = stylesheet.argsFromClassName(arg);\n\n      if (expandedRules) {\n        extractRules(expandedRules, rules, currentSelector);\n      }\n      // Else if the arg is an array, we need to recurse in.\n    } else if (Array.isArray(arg)) {\n      extractRules(arg, rules, currentSelector);\n    } else {\n      for (const prop in arg as any) {\n        if ((arg as any).hasOwnProperty(prop)) {\n          const propValue = (arg as any)[prop];\n\n          if (prop === 'selectors') {\n            // every child is a selector.\n            const selectors: { [key: string]: IStyle } = (arg as any).selectors;\n\n            for (const newSelector in selectors) {\n              if (selectors.hasOwnProperty(newSelector)) {\n                extractSelector(currentSelector, rules, newSelector, selectors[newSelector]);\n              }\n            }\n          } else if (typeof propValue === 'object') {\n            // prop is a selector.\n            if (propValue !== null) {\n              extractSelector(currentSelector, rules, prop, propValue);\n            }\n          } else {\n            if (propValue !== undefined) {\n              // Else, add the rule to the currentSelector.\n              if (prop === 'margin' || prop === 'padding') {\n                expandQuads(currentRules, prop, propValue);\n              } else {\n                (currentRules as any)[prop] = propValue;\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return rules;\n}\n\nfunction expandQuads(currentRules: IDictionary, name: string, value: string): void {\n  const parts = typeof value === 'string' ? value.split(' ') : [value];\n\n  currentRules[name + 'Top'] = parts[0];\n  currentRules[name + 'Right'] = parts[1] || parts[0];\n  currentRules[name + 'Bottom'] = parts[2] || parts[0];\n  currentRules[name + 'Left'] = parts[3] || parts[1] || parts[0];\n}\n\nfunction getKeyForRules(options: IStyleOptions, rules: IRuleSet): string | undefined {\n  const serialized: string[] = [options.rtl ? 'rtl' : 'ltr'];\n  let hasProps = false;\n\n  for (const selector of rules.__order) {\n    serialized.push(selector);\n    const rulesForSelector = rules[selector];\n\n    for (const propName in rulesForSelector) {\n      if (rulesForSelector.hasOwnProperty(propName) && rulesForSelector[propName] !== undefined) {\n        hasProps = true;\n        serialized.push(propName, rulesForSelector[propName]);\n      }\n    }\n  }\n\n  return hasProps ? serialized.join('') : undefined;\n}\n\nfunction repeatString(target: string, count: number): string {\n  if (count <= 0) {\n    return '';\n  }\n\n  if (count === 1) {\n    return target;\n  }\n\n  return target + repeatString(target, count - 1);\n}\n\nexport function serializeRuleEntries(options: IStyleOptions, ruleEntries: { [key: string]: string | number }): string {\n  if (!ruleEntries) {\n    return '';\n  }\n\n  const allEntries: (string | number)[] = [];\n\n  for (const entry in ruleEntries) {\n    if (ruleEntries.hasOwnProperty(entry) && entry !== DISPLAY_NAME && ruleEntries[entry] !== undefined) {\n      allEntries.push(entry, ruleEntries[entry]);\n    }\n  }\n\n  // Apply transforms.\n  for (let i = 0; i < allEntries.length; i += 2) {\n    kebabRules(allEntries, i);\n    provideUnits(allEntries, i);\n    rtlifyRules(options, allEntries, i);\n    prefixRules(allEntries, i);\n  }\n\n  // Apply punctuation.\n  for (let i = 1; i < allEntries.length; i += 4) {\n    allEntries.splice(i, 1, ':', allEntries[i], ';');\n  }\n\n  return allEntries.join('');\n}\n\nexport interface IRegistration {\n  className: string;\n  key: string;\n  args: IStyle[];\n  rulesToInsert: string[];\n}\n\nexport function styleToRegistration(options: IStyleOptions, ...args: IStyle[]): IRegistration | undefined {\n  const rules: IRuleSet = extractRules(args);\n  const key = getKeyForRules(options, rules);\n\n  if (key) {\n    const stylesheet = Stylesheet.getInstance();\n    const registration: Partial<IRegistration> = {\n      className: stylesheet.classNameFromKey(key),\n      key,\n      args,\n    };\n\n    if (!registration.className) {\n      registration.className = stylesheet.getClassName(getDisplayName(rules));\n      const rulesToInsert: string[] = [];\n\n      for (const selector of rules.__order) {\n        rulesToInsert.push(selector, serializeRuleEntries(options, rules[selector]));\n      }\n      registration.rulesToInsert = rulesToInsert;\n    }\n\n    return registration as IRegistration;\n  }\n\n  return undefined;\n}\n\n/**\n * Insert style to stylesheet.\n * @param registration Style registration.\n * @param specificityMultiplier Number of times classname selector is repeated in the css rule.\n * This is to increase css specificity in case it's needed. Default to 1.\n */\nexport function applyRegistration(registration: IRegistration, specificityMultiplier: number = 1): void {\n  const stylesheet = Stylesheet.getInstance();\n  const { className, key, args, rulesToInsert } = registration;\n\n  if (rulesToInsert) {\n    // rulesToInsert is an ordered array of selector/rule pairs.\n    for (let i = 0; i < rulesToInsert.length; i += 2) {\n      const rules = rulesToInsert[i + 1];\n      if (rules) {\n        let selector = rulesToInsert[i];\n        selector = selector.replace(/&/g, repeatString(`.${registration.className}`, specificityMultiplier));\n\n        // Insert. Note if a media query, we must close the query with a final bracket.\n        const processedRule = `${selector}{${rules}}${selector.indexOf('@') === 0 ? '}' : ''}`;\n        stylesheet.insertRule(processedRule);\n      }\n    }\n    stylesheet.cacheClassName(className!, key!, args!, rulesToInsert);\n  }\n}\n\nexport function styleToClassName(options: IStyleOptions, ...args: IStyle[]): string {\n  const registration = styleToRegistration(options, ...args);\n  if (registration) {\n    applyRegistration(registration, options.specificityMultiplier);\n\n    return registration.className;\n  }\n\n  return '';\n}\n","import { IRawStyle } from '@uifabric/merge-styles';\n\nexport const hiddenContentStyle: IRawStyle = {\n  position: 'absolute',\n  width: 1,\n  height: 1,\n  margin: -1,\n  padding: 0,\n  border: 0,\n  overflow: 'hidden',\n};\n","import { ITheme } from '../interfaces/index';\nimport { Stylesheet } from '@uifabric/merge-styles';\nimport { memoizeFunction } from '@uifabric/utilities';\n\nexport type GlobalClassNames<IStyles> = Record<keyof IStyles, string>;\n\n/**\n * Internal memoized function which simply takes in the class map and the\n * disable boolean. These immutable values can be memoized.\n */\nconst _getGlobalClassNames = memoizeFunction(\n  <T>(classNames: GlobalClassNames<T>, disableGlobalClassNames?: boolean): GlobalClassNames<T> => {\n    const styleSheet = Stylesheet.getInstance();\n\n    if (disableGlobalClassNames) {\n      // disable global classnames\n      return (Object.keys(classNames) as (keyof T)[]).reduce((acc, className) => {\n        acc[className] = styleSheet.getClassName(classNames[className]);\n        return acc;\n      }, {} as GlobalClassNames<T>);\n    }\n\n    // use global classnames\n    return classNames;\n  },\n);\n\n/**\n * Checks for the `disableGlobalClassNames` property on the `theme` to determine if it should return `classNames`\n * Note that calls to this function are memoized.\n *\n * @param classNames - The collection of global class names that apply when the flag is false. Make sure to pass in\n * the same instance on each call to benefit from memoization.\n * @param theme - The theme to check the flag on\n * @param disableGlobalClassNames - Optional. Explicitly opt in/out of disabling global classnames. Defaults to false.\n */\nexport function getGlobalClassNames<T>(\n  classNames: GlobalClassNames<T>,\n  theme: ITheme,\n  disableGlobalClassNames?: boolean,\n): GlobalClassNames<T> {\n  return _getGlobalClassNames(\n    classNames,\n    disableGlobalClassNames !== undefined ? disableGlobalClassNames : theme.disableGlobalClassNames,\n  );\n}\n","import { IRawStyle } from '../MergeStyles';\n\nexport const HighContrastSelector = '@media screen and (-ms-high-contrast: active), screen and (forced-colors: active)';\nexport const HighContrastSelectorWhite =\n  // eslint-disable-next-line @fluentui/max-len\n  '@media screen and (-ms-high-contrast: black-on-white), screen and (forced-colors: active) and (prefers-color-scheme: light)';\nexport const HighContrastSelectorBlack =\n  // eslint-disable-next-line @fluentui/max-len\n  '@media screen and (-ms-high-contrast: white-on-black), screen and (forced-colors: active) and (prefers-color-scheme: dark)';\n/**\n * @deprecated Use `HighContrastSelector`\n */\nexport const EdgeChromiumHighContrastSelector =\n  '@media screen and (-ms-high-contrast: active), screen and (forced-colors: active)';\n\nexport const ScreenWidthMinSmall = 320;\nexport const ScreenWidthMinMedium = 480;\nexport const ScreenWidthMinLarge = 640;\nexport const ScreenWidthMinXLarge = 1024;\nexport const ScreenWidthMinXXLarge = 1366;\nexport const ScreenWidthMinXXXLarge = 1920;\nexport const ScreenWidthMaxSmall = ScreenWidthMinMedium - 1;\nexport const ScreenWidthMaxMedium = ScreenWidthMinLarge - 1;\nexport const ScreenWidthMaxLarge = ScreenWidthMinXLarge - 1;\nexport const ScreenWidthMaxXLarge = ScreenWidthMinXXLarge - 1;\nexport const ScreenWidthMaxXXLarge = ScreenWidthMinXXXLarge - 1;\n\nexport const ScreenWidthMinUhfMobile = 768;\n\nexport function getScreenSelector(min: number | undefined, max: number | undefined): string {\n  const minSelector = typeof min === 'number' ? ` and (min-width: ${min}px)` : '';\n  const maxSelector = typeof max === 'number' ? ` and (max-width: ${max}px)` : '';\n  return `@media only screen${minSelector}${maxSelector}`;\n}\n\n/**\n * The style which turns off high contrast adjustment in browsers.\n */\nexport function getHighContrastNoAdjustStyle(): IRawStyle {\n  return {\n    forcedColorAdjust: 'none',\n    MsHighContrastAdjust: 'none',\n  };\n}\n\n/**\n * The style which turns off high contrast adjustment in (only) Edge Chromium browser.\n * @deprecated Use `getHighContrastNoAdjustStyle`\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getEdgeChromiumNoHighContrastAdjustSelector(): { [EdgeChromiumHighContrastSelector]: IRawStyle } {\n  return {\n    // eslint-disable-next-line deprecation/deprecation\n    [EdgeChromiumHighContrastSelector]: {\n      forcedColorAdjust: 'none',\n      MsHighContrastAdjust: 'none',\n    },\n  };\n}\n","import { IKeyframes } from './IKeyframes';\nimport { getStyleOptions } from './StyleOptionsState';\nimport { Stylesheet } from './Stylesheet';\nimport { serializeRuleEntries } from './styleToClassName';\n\n/**\n * Registers keyframe definitions.\n *\n * @public\n */\nexport function keyframes(timeline: IKeyframes): string {\n  const stylesheet = Stylesheet.getInstance();\n  const name = stylesheet.getClassName();\n\n  const rulesArray: string[] = [];\n\n  for (const prop in timeline) {\n    if (timeline.hasOwnProperty(prop)) {\n      rulesArray.push(prop, '{', serializeRuleEntries(getStyleOptions(), timeline[prop]), '}');\n    }\n  }\n  const rules = rulesArray.join('');\n\n  stylesheet.insertRule(`@keyframes ${name}{${rules}}`, true);\n\n  stylesheet.cacheClassName(name, rules, [], ['keyframes', rules]);\n\n  return name;\n}\n","// A packages cache that makes sure that we don't inject the same packageName twice in the same bundle -\n// this cache is local to the module closure inside this bundle\nconst packagesCache: { [name: string]: string } = {};\n\n// Cache access to window to avoid IE11 memory leak.\nlet _win: Window | undefined = undefined;\n\ntry {\n  _win = window;\n} catch (e) {\n  /* no-op */\n}\n\nexport function setVersion(packageName: string, packageVersion: string): void {\n  if (typeof _win !== 'undefined') {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const packages = ((_win as any).__packages__ = (_win as any).__packages__ || {});\n\n    // We allow either the global packages or local packages caches to invalidate so testing can\n    // just clear the global to set this state\n    if (!packages[packageName] || !packagesCache[packageName]) {\n      packagesCache[packageName] = packageVersion;\n      const versions = (packages[packageName] = packages[packageName] || []);\n      versions.push(packageVersion);\n    }\n  }\n}\n","import { setVersion } from './setVersion';\nexport { setVersion };\n\nsetVersion('@uifabric/set-version', '6.0.0');\n","// Do not modify this file; it is generated as part of publish.\n// The checked in version is a placeholder only and will not be updated.\nimport { setVersion } from '@uifabric/set-version';\nsetVersion('@uifabric/styling', '7.25.0');","import { Customizations, getWindow } from '@uifabric/utilities';\nimport { ITheme, IPartialTheme, IFontStyles } from '../interfaces/index';\nimport { loadTheme as legacyLoadTheme } from '@microsoft/load-themed-styles';\nimport { IRawStyle } from '@uifabric/merge-styles';\nimport { createTheme } from '@fluentui/theme/lib/createTheme';\n\nexport { createTheme } from '@fluentui/theme/lib/createTheme';\n\nlet _theme: ITheme = createTheme({});\nlet _onThemeChangeCallbacks: Array<(theme: ITheme) => void> = [];\n\nexport const ThemeSettingName = 'theme';\n\nexport function initializeThemeInCustomizations(): void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const win: any = getWindow();\n\n  if (win?.FabricConfig?.legacyTheme) {\n    // does everything the `else` clause does and more, such as invoke legacy theming\n    loadTheme(win.FabricConfig.legacyTheme);\n  } else if (!Customizations.getSettings([ThemeSettingName]).theme) {\n    if (win?.FabricConfig?.theme) {\n      _theme = createTheme(win.FabricConfig.theme);\n    }\n\n    // Set the default theme.\n    Customizations.applySettings({ [ThemeSettingName]: _theme });\n  }\n}\n\n// Ensure theme is initialized when this package is referenced.\ninitializeThemeInCustomizations();\n\n/**\n * Gets the theme object\n * @param depComments - Whether to include deprecated tags as comments for deprecated slots.\n */\nexport function getTheme(depComments: boolean = false): ITheme {\n  if (depComments === true) {\n    _theme = createTheme({}, depComments);\n  }\n  return _theme;\n}\n\n/**\n * Registers a callback that gets called whenever the theme changes.\n * This should only be used when the component cannot automatically get theme changes through its state.\n * This will not register duplicate callbacks.\n */\nexport function registerOnThemeChangeCallback(callback: (theme: ITheme) => void): void {\n  if (_onThemeChangeCallbacks.indexOf(callback) === -1) {\n    _onThemeChangeCallbacks.push(callback);\n  }\n}\n\n/**\n * See registerOnThemeChangeCallback().\n * Removes previously registered callbacks.\n */\nexport function removeOnThemeChangeCallback(callback: (theme: ITheme) => void): void {\n  const i = _onThemeChangeCallbacks.indexOf(callback);\n  if (i === -1) {\n    return;\n  }\n\n  _onThemeChangeCallbacks.splice(i, 1);\n}\n\n/**\n * Applies the theme, while filling in missing slots.\n * @param theme - Partial theme object.\n * @param depComments - Whether to include deprecated tags as comments for deprecated slots.\n */\nexport function loadTheme(theme: IPartialTheme, depComments: boolean = false): ITheme {\n  _theme = createTheme(theme, depComments);\n\n  // Invoke the legacy method of theming the page as well.\n  legacyLoadTheme({ ..._theme.palette, ..._theme.semanticColors, ..._theme.effects, ..._loadFonts(_theme) });\n\n  Customizations.applySettings({ [ThemeSettingName]: _theme });\n\n  _onThemeChangeCallbacks.forEach((callback: (theme: ITheme) => void) => {\n    try {\n      callback(_theme);\n    } catch (e) {\n      // don't let a bad callback break everything else\n    }\n  });\n\n  return _theme;\n}\n\n/**\n * Loads font variables into a JSON object.\n * @param theme - The theme object\n */\nfunction _loadFonts(theme: ITheme): { [name: string]: string } {\n  const lines: { [key: string]: string } = {};\n\n  for (const fontName of Object.keys(theme.fonts)) {\n    const font: IRawStyle = theme.fonts[fontName as keyof IFontStyles];\n\n    for (const propName of Object.keys(font)) {\n      const name: string = fontName + propName.charAt(0).toUpperCase() + propName.slice(1);\n      let value = font[propName as keyof IRawStyle] as string;\n\n      if (propName === 'fontSize' && typeof value === 'number') {\n        // if it's a number, convert it to px by default like our theming system does\n        value = value + 'px';\n      }\n      lines[name] = value;\n    }\n  }\n  return lines;\n}\n","import * as React from 'react';\n\n/**\n * DelayedRender component props.\n *\n * @public\n */\n// eslint-disable-next-line deprecation/deprecation\nexport interface IDelayedRenderProps extends React.Props<{}> {\n  /**\n   * Number of milliseconds to delay rendering children.\n   */\n  delay?: number;\n}\n\n/**\n * DelayedRender component state.\n *\n * @internal\n */\nexport interface IDelayedRenderState {\n  /**\n   * Whether the component is rendered or not.\n   */\n  isRendered: boolean;\n}\n\n/**\n * Utility component for delaying the render of a child component after a given delay. This component\n * requires a single child component; don't pass in many components. Wrap multiple components in a DIV\n * if necessary.\n *\n * @public\n * {@docCategory DelayedRender}\n */\nexport class DelayedRender extends React.Component<IDelayedRenderProps, IDelayedRenderState> {\n  public static defaultProps = {\n    delay: 0,\n  };\n\n  private _timeoutId: number | undefined;\n\n  constructor(props: IDelayedRenderProps) {\n    super(props);\n    this.state = {\n      isRendered: false,\n    };\n  }\n\n  public componentDidMount(): void {\n    let { delay } = this.props;\n    this._timeoutId = window.setTimeout(() => {\n      this.setState({\n        isRendered: true,\n      });\n    }, delay);\n  }\n\n  public componentWillUnmount(): void {\n    if (this._timeoutId) {\n      clearTimeout(this._timeoutId);\n    }\n  }\n\n  public render(): React.ReactElement<{}> | null {\n    return this.state.isRendered ? (React.Children.only(this.props.children) as React.ReactElement<{}>) : null;\n  }\n}\n","import { IStyle, IStyleBaseArray } from './IStyle';\nimport { Stylesheet } from './Stylesheet';\n\n/**\n * Separates the classes and style objects. Any classes that are pre-registered\n * args are auto expanded into objects.\n */\nexport function extractStyleParts(\n  ...args: (IStyle | IStyle[] | false | null | undefined)[]\n): { classes: string[]; objects: IStyleBaseArray } {\n  const classes: string[] = [];\n  const objects: {}[] = [];\n  const stylesheet = Stylesheet.getInstance();\n\n  function _processArgs(argsList: (IStyle | IStyle[])[]): void {\n    for (const arg of argsList) {\n      if (arg) {\n        if (typeof arg === 'string') {\n          if (arg.indexOf(' ') >= 0) {\n            _processArgs(arg.split(' '));\n          } else {\n            const translatedArgs = stylesheet.argsFromClassName(arg);\n\n            if (translatedArgs) {\n              _processArgs(translatedArgs);\n            } else {\n              // Avoid adding the same class twice.\n              if (classes.indexOf(arg) === -1) {\n                classes.push(arg);\n              }\n            }\n          }\n        } else if (Array.isArray(arg)) {\n          _processArgs(arg);\n        } else if (typeof arg === 'object') {\n          objects.push(arg);\n        }\n      }\n    }\n  }\n\n  _processArgs(args);\n\n  return {\n    classes,\n    objects,\n  };\n}\n","import { concatStyleSets } from './concatStyleSets';\nimport { extractStyleParts } from './extractStyleParts';\nimport { IStyle } from './IStyle';\nimport { IStyleOptions } from './IStyleOptions';\nimport { IConcatenatedStyleSet, IProcessedStyleSet, IStyleSet } from './IStyleSet';\nimport { getStyleOptions } from './StyleOptionsState';\nimport { applyRegistration, styleToRegistration } from './styleToClassName';\nimport { ObjectOnly } from './ObjectOnly';\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSet - The first style set to be merged and reigstered.\n */\nexport function mergeStyleSets<TStyleSet>(\n  styleSet: TStyleSet | false | null | undefined,\n): IProcessedStyleSet<ObjectOnly<TStyleSet>>;\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSet1 - The first style set to be merged.\n * @param styleSet2 - The second style set to be merged.\n */\nexport function mergeStyleSets<TStyleSet1, TStyleSet2>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n): IProcessedStyleSet<ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2>>;\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSet1 - The first style set to be merged.\n * @param styleSet2 - The second style set to be merged.\n * @param styleSet3 - The third style set to be merged.\n */\nexport function mergeStyleSets<TStyleSet1, TStyleSet2, TStyleSet3>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n): IProcessedStyleSet<ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2> & ObjectOnly<TStyleSet3>>;\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSet1 - The first style set to be merged.\n * @param styleSet2 - The second style set to be merged.\n * @param styleSet3 - The third style set to be merged.\n * @param styleSet4 - The fourth style set to be merged.\n */\nexport function mergeStyleSets<TStyleSet1, TStyleSet2, TStyleSet3, TStyleSet4>(\n  styleSet1: TStyleSet1 | false | null | undefined,\n  styleSet2: TStyleSet2 | false | null | undefined,\n  styleSet3: TStyleSet3 | false | null | undefined,\n  styleSet4: TStyleSet4 | false | null | undefined,\n): IProcessedStyleSet<\n  ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2> & ObjectOnly<TStyleSet3> & ObjectOnly<TStyleSet4>\n>;\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n */\nexport function mergeStyleSets(...styleSets: Array<IStyleSet | undefined | false | null>): IProcessedStyleSet<any>;\n\n/**\n * Takes in one or more style set objects, each consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeStyles` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n */\nexport function mergeStyleSets(...styleSets: Array<IStyleSet | undefined | false | null>): IProcessedStyleSet<any> {\n  return mergeCssSets(styleSets as any, getStyleOptions());\n}\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets<TStyleSet>(\n  styleSets: [TStyleSet | false | null | undefined],\n  options?: IStyleOptions,\n): IProcessedStyleSet<TStyleSet>;\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets<TStyleSet1, TStyleSet2>(\n  styleSets: [TStyleSet1 | false | null | undefined, TStyleSet2 | false | null | undefined],\n  options?: IStyleOptions,\n): IProcessedStyleSet<TStyleSet1 & TStyleSet2>;\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets<TStyleSet1, TStyleSet2, TStyleSet3>(\n  styleSets: [\n    TStyleSet1 | false | null | undefined,\n    TStyleSet2 | false | null | undefined,\n    TStyleSet3 | false | null | undefined,\n  ],\n  options?: IStyleOptions,\n): IProcessedStyleSet<TStyleSet1 & TStyleSet2 & TStyleSet3>;\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets<TStyleSet1, TStyleSet2, TStyleSet3, TStyleSet4>(\n  styleSets: [\n    TStyleSet1 | false | null | undefined,\n    TStyleSet2 | false | null | undefined,\n    TStyleSet3 | false | null | undefined,\n    TStyleSet4 | false | null | undefined,\n  ],\n  options?: IStyleOptions,\n): IProcessedStyleSet<\n  ObjectOnly<TStyleSet1> & ObjectOnly<TStyleSet2> & ObjectOnly<TStyleSet3> & ObjectOnly<TStyleSet4>\n>;\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures we maintain the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets<TStyleSet>(\n  styleSet: [TStyleSet | false | null | undefined],\n  options?: IStyleOptions,\n): IProcessedStyleSet<TStyleSet>;\n\n/**\n * Takes in one or more style set objects, each1consisting of a set of areas,\n * each which will produce a class name. Using this is analogous to calling\n * `mergeCss` for each property in the object, but ensures the\n * set ordering when multiple style sets are merged.\n *\n * @param styleSets - One or more style sets to be merged.\n * @param options - (optional) Options to use when creating rules.\n */\nexport function mergeCssSets(\n  styleSets: Array<IStyleSet | undefined | false | null>,\n  options?: IStyleOptions,\n): IProcessedStyleSet<any> {\n  const classNameSet: IProcessedStyleSet<any> = { subComponentStyles: {} };\n\n  const styleSet = styleSets[0];\n\n  if (!styleSet && styleSets.length <= 1) {\n    return { subComponentStyles: {} } as any;\n  }\n\n  const concatenatedStyleSet = concatStyleSets(...styleSets);\n\n  const registrations = [];\n\n  for (const styleSetArea in concatenatedStyleSet) {\n    if (concatenatedStyleSet.hasOwnProperty(styleSetArea)) {\n      if (styleSetArea === 'subComponentStyles') {\n        classNameSet.subComponentStyles = (concatenatedStyleSet as IConcatenatedStyleSet<any>).subComponentStyles || {};\n        continue;\n      }\n\n      const styles: IStyle = (concatenatedStyleSet as any)[styleSetArea];\n\n      const { classes, objects } = extractStyleParts(styles);\n\n      if (objects?.length) {\n        const registration = styleToRegistration(options || {}, { displayName: styleSetArea }, objects);\n\n        if (registration) {\n          registrations.push(registration);\n          classNameSet[styleSetArea] = classes.concat([registration.className]).join(' ');\n        }\n      } else {\n        classNameSet[styleSetArea] = classes.join(' ');\n      }\n    }\n  }\n\n  for (const registration of registrations) {\n    if (registration) {\n      applyRegistration(registration, options?.specificityMultiplier);\n    }\n  }\n\n  return classNameSet as any;\n}\n","import { KeyCodes } from './KeyCodes';\nimport { getDocument } from './dom/getDocument';\nimport { getItem, setItem } from './sessionStorage';\nimport { setRTL as mergeStylesSetRTL } from '@uifabric/merge-styles';\n\nconst RTL_LOCAL_STORAGE_KEY = 'isRTL';\n\n// Default to undefined so that we initialize on first read.\nlet _isRTL: boolean | undefined;\n\n/**\n * Gets the rtl state of the page (returns true if in rtl.)\n */\nexport function getRTL(theme: { rtl?: boolean } = {}): boolean {\n  if (theme.rtl !== undefined) {\n    return theme.rtl;\n  }\n  if (_isRTL === undefined) {\n    // Fabric supports persisting the RTL setting between page refreshes via session storage\n    let savedRTL = getItem(RTL_LOCAL_STORAGE_KEY);\n    if (savedRTL !== null) {\n      _isRTL = savedRTL === '1';\n      setRTL(_isRTL);\n    }\n\n    let doc = getDocument();\n    if (_isRTL === undefined && doc) {\n      _isRTL = ((doc.body && doc.body.getAttribute('dir')) || doc.documentElement.getAttribute('dir')) === 'rtl';\n      mergeStylesSetRTL(_isRTL);\n    }\n  }\n\n  return !!_isRTL;\n}\n\n/**\n * Sets the rtl state of the page (by adjusting the dir attribute of the html element.)\n */\nexport function setRTL(isRTL: boolean, persistSetting: boolean = false): void {\n  let doc = getDocument();\n  if (doc) {\n    doc.documentElement.setAttribute('dir', isRTL ? 'rtl' : 'ltr');\n  }\n\n  if (persistSetting) {\n    setItem(RTL_LOCAL_STORAGE_KEY, isRTL ? '1' : '0');\n  }\n\n  _isRTL = isRTL;\n  mergeStylesSetRTL(_isRTL);\n}\n\n/**\n * Returns the given key, but flips right/left arrows if necessary.\n */\nexport function getRTLSafeKeyCode(key: number, theme: { rtl?: boolean } = {}): number {\n  if (getRTL(theme)) {\n    if (key === KeyCodes.left) {\n      key = KeyCodes.right;\n    } else if (key === KeyCodes.right) {\n      key = KeyCodes.left;\n    }\n  }\n\n  return key;\n}\n","import {\n  mergeCssSets,\n  IStyleSet,\n  IProcessedStyleSet,\n  Stylesheet,\n  IStyleFunctionOrObject,\n} from '@uifabric/merge-styles';\nimport { getRTL } from './rtl';\nimport { getWindow } from './dom';\nimport { StyleFunction } from './styled';\n\nconst MAX_CACHE_COUNT = 50;\nconst DEFAULT_SPECIFICITY_MULTIPLIER = 5;\n\nlet _memoizedClassNames = 0;\n\nconst stylesheet = Stylesheet.getInstance();\n\nif (stylesheet && stylesheet.onReset) {\n  stylesheet.onReset(() => _memoizedClassNames++);\n}\n\n// Note that because of the caching nature within the classNames memoization,\n// I've disabled this rule to simply be able to work with any types.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n// This represents a prop we attach to each Map to indicate the cached return value\n// associated with the graph node.\nconst retVal = '__retval__';\n\ninterface IRecursiveMemoNode extends Map<any, IRecursiveMemoNode> {\n  [retVal]?: string;\n}\n\ntype AppWindow = (Window & { FabricConfig?: { enableClassNameCacheFullWarning?: boolean } }) | undefined;\n\nexport interface IClassNamesFunctionOptions {\n  /**\n   * Disables class caching for scenarios where styleProp parts mutate frequently.\n   */\n  disableCaching?: boolean;\n\n  /**\n   * Size of the cache. It overwrites default cache size when defined.\n   */\n  cacheSize?: number;\n\n  /**\n   * Set to true if component base styles are implemented in scss instead of css-in-js.\n   */\n  useStaticStyles?: boolean;\n}\n\n/**\n * Creates a getClassNames function which calls getStyles given the props, and injects them\n * into mergeStyleSets.\n *\n * Note that the props you pass in on every render should be in the same order and\n * immutable (numbers, strings, and booleans). This will allow the results to be memoized. Violating\n * these will cause extra recalcs to occur.\n */\nexport function classNamesFunction<TStyleProps extends {}, TStyleSet extends IStyleSet<TStyleSet>>(\n  options: IClassNamesFunctionOptions = {},\n): (\n  getStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined,\n  styleProps?: TStyleProps,\n) => IProcessedStyleSet<TStyleSet> {\n  // We build a trie where each node is a Map. The map entry key represents an argument\n  // value, and the entry value is another node (Map). Each node has a `__retval__`\n  // property which is used to hold the cached response.\n\n  // To derive the response, we can simply ensure the arguments are added or already\n  // exist in the trie. At the last node, if there is a `__retval__` we return that. Otherwise\n  // we call the `getStyles` api to evaluate, cache on the property, and return that.\n  let map: IRecursiveMemoNode = new Map();\n  let styleCalcCount = 0;\n  let getClassNamesCount = 0;\n  let currentMemoizedClassNames = _memoizedClassNames;\n\n  const getClassNames = (\n    styleFunctionOrObject: IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined,\n    styleProps: TStyleProps = {} as TStyleProps,\n  ): IProcessedStyleSet<TStyleSet> => {\n    // If useStaticStyles is true, styleFunctionOrObject returns slot to classname mappings.\n    // If there is also no style overrides, we can skip merge styles completely and\n    // simply return the result from the style funcion.\n    if (\n      options.useStaticStyles &&\n      typeof styleFunctionOrObject === 'function' &&\n      (styleFunctionOrObject as StyleFunction<TStyleProps, TStyleSet>).__noStyleOverride__\n    ) {\n      return styleFunctionOrObject(styleProps) as IProcessedStyleSet<TStyleSet>;\n    }\n\n    getClassNamesCount++;\n    let current: Map<any, any> = map;\n    const { theme } = styleProps as any;\n    const rtl = theme && theme.rtl !== undefined ? theme.rtl : getRTL();\n\n    const disableCaching = options.disableCaching;\n\n    // On reset of our stylesheet, reset memoized cache.\n    if (currentMemoizedClassNames !== _memoizedClassNames) {\n      currentMemoizedClassNames = _memoizedClassNames;\n      map = new Map();\n      styleCalcCount = 0;\n    }\n\n    if (!options.disableCaching) {\n      current = _traverseMap(map, styleFunctionOrObject as any);\n      current = _traverseMap(current, styleProps);\n    }\n\n    if (disableCaching || !(current as any)[retVal]) {\n      if (styleFunctionOrObject === undefined) {\n        (current as any)[retVal] = {} as IProcessedStyleSet<TStyleSet>;\n      } else {\n        (current as any)[retVal] = mergeCssSets(\n          [\n            (typeof styleFunctionOrObject === 'function'\n              ? styleFunctionOrObject(styleProps)\n              : styleFunctionOrObject) as IStyleSet<TStyleSet>,\n          ],\n          { rtl: !!rtl, specificityMultiplier: options.useStaticStyles ? DEFAULT_SPECIFICITY_MULTIPLIER : undefined },\n        );\n      }\n\n      if (!disableCaching) {\n        styleCalcCount++;\n      }\n    }\n\n    if (styleCalcCount > (options.cacheSize || MAX_CACHE_COUNT)) {\n      const win = getWindow() as AppWindow;\n      if (win?.FabricConfig?.enableClassNameCacheFullWarning) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `Styles are being recalculated too frequently. Cache miss rate is ${styleCalcCount}/${getClassNamesCount}.`,\n        );\n        // eslint-disable-next-line no-console\n        console.trace();\n      }\n\n      map.clear();\n      styleCalcCount = 0;\n\n      // Mutate the options passed in, that's all we can do.\n      options.disableCaching = true;\n    }\n\n    // Note: the retVal is an attached property on the Map; not a key in the Map. We use this attached property to\n    // cache the return value for this branch of the graph.\n    return (current as any)[retVal];\n  };\n\n  return getClassNames;\n}\n\nfunction _traverseEdge(current: Map<any, any>, value: any): Map<any, any> {\n  value = _normalizeValue(value);\n\n  if (!current.has(value)) {\n    current.set(value, new Map<any, any>());\n  }\n\n  return current.get(value);\n}\n\nfunction _traverseMap(current: Map<any, any>, inputs: any[] | Object): Map<any, any> {\n  if (typeof inputs === 'function') {\n    const cachedInputsFromStyled = (inputs as StyleFunction<any, any>).__cachedInputs__;\n    if (cachedInputsFromStyled) {\n      // The styled helper will generate the styles function and will attach the cached\n      // inputs (consisting of the default styles, customzied styles, and user provided styles.)\n      // These should be used as cache keys for deriving the memoized value.\n      for (const input of (inputs as any).__cachedInputs__) {\n        current = _traverseEdge(current, input);\n      }\n    } else {\n      current = _traverseEdge(current, inputs);\n    }\n  } else if (typeof inputs === 'object') {\n    for (const propName in inputs) {\n      if (inputs.hasOwnProperty(propName)) {\n        current = _traverseEdge(current, (inputs as any)[propName]);\n      }\n    }\n  }\n\n  return current;\n}\n\nfunction _normalizeValue(value: any): string {\n  switch (value) {\n    case undefined:\n      return '__undefined__';\n    case null:\n      return '__null__';\n    default:\n      return value;\n  }\n}\n","import { getWindow } from './dom/getWindow';\n\n/**\n * Storing global state in local module variables has issues when more than one copy\n * if the module gets loaded on the page (due to a bundling error or simply by consuming\n * a prebundled script.)\n *\n * This file contains helpers to deal with the getting and setting local state, and allows\n * callers to get called back when it mutates.\n */\n\nconst GLOBAL_SETTINGS_PROP_NAME = '__globalSettings__';\nconst CALLBACK_STATE_PROP_NAME = '__callbacks__';\n\nlet _counter = 0;\n\n/**\n * Change description used for change callbacks in GlobalSettings.\n *\n * @public\n * {@docCategory IChangeDescription}\n */\nexport interface IChangeDescription {\n  key: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  oldValue: any;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  value: any;\n}\n\n/**\n * Change event callback.\n *\n * @public\n * {@docCategory IChangeEventCallback}\n */\nexport interface IChangeEventCallback {\n  __id__?: string;\n  (changeDescription?: IChangeDescription): void;\n}\n\n/**\n * Global settings helper, which stores settings in the global (window) namespace.\n * If window is not provided, it will store settings in module scope. Provides a\n * way to observe changes as well when their values change.\n *\n * @public\n * {@docCategory GlobalSettings}\n */\nexport class GlobalSettings {\n  public static getValue<T>(key: string, defaultValue?: T | (() => T)): T {\n    const globalSettings = _getGlobalSettings();\n\n    if (globalSettings[key] === undefined) {\n      globalSettings[key] = typeof defaultValue === 'function' ? (defaultValue as Function)() : defaultValue;\n    }\n\n    return globalSettings[key];\n  }\n\n  public static setValue<T>(key: string, value: T): T {\n    const globalSettings = _getGlobalSettings();\n    const callbacks = globalSettings[CALLBACK_STATE_PROP_NAME];\n    let oldValue = globalSettings[key];\n\n    if (value !== oldValue) {\n      globalSettings[key] = value;\n\n      let changeDescription = {\n        oldValue,\n        value,\n        key,\n      };\n\n      for (let id in callbacks) {\n        if (callbacks.hasOwnProperty(id)) {\n          callbacks[id](changeDescription);\n        }\n      }\n    }\n\n    return value;\n  }\n\n  public static addChangeListener(cb: IChangeEventCallback): void {\n    // Note: we use generated ids on the callbacks to create a map of the callbacks, which optimizes removal.\n    // (It's faster to delete a key than it is to look up the index of an object and splice an array.)\n    let id = cb.__id__;\n    const callbacks = _getCallbacks();\n\n    if (!id) {\n      id = cb.__id__ = String(_counter++);\n    }\n\n    callbacks[id] = cb;\n  }\n\n  public static removeChangeListener(cb: IChangeEventCallback): void {\n    const callbacks = _getCallbacks();\n    delete callbacks[cb.__id__ as string];\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _getGlobalSettings(): { [key: string]: any } {\n  const win = getWindow();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObj: { [key: string]: any } = win || {};\n\n  if (!globalObj[GLOBAL_SETTINGS_PROP_NAME]) {\n    globalObj[GLOBAL_SETTINGS_PROP_NAME] = {\n      [CALLBACK_STATE_PROP_NAME]: {},\n    };\n  }\n\n  return globalObj[GLOBAL_SETTINGS_PROP_NAME];\n}\n\nfunction _getCallbacks(): { [key: string]: () => void } {\n  const globalSettings = _getGlobalSettings();\n  return globalSettings[CALLBACK_STATE_PROP_NAME];\n}\n","import { GlobalSettings } from '../GlobalSettings';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ISettings = { [key: string]: any };\nexport type ISettingsFunction = (settings: ISettings) => ISettings;\n\n/**\n * @deprecated Use ISettings.\n */\nexport type Settings = ISettings;\n\n/**\n * @deprecated Use ISettingsFunction.\n */\nexport type SettingsFunction = ISettingsFunction;\n\nexport interface ICustomizations {\n  settings: ISettings;\n  scopedSettings: { [key: string]: ISettings };\n  inCustomizerContext?: boolean;\n}\n\nconst CustomizationsGlobalKey = 'customizations';\nconst NO_CUSTOMIZATIONS = { settings: {}, scopedSettings: {}, inCustomizerContext: false };\n\nlet _allSettings = GlobalSettings.getValue<ICustomizations>(CustomizationsGlobalKey, {\n  settings: {},\n  scopedSettings: {},\n  inCustomizerContext: false,\n});\n\nlet _events: (() => void)[] = [];\n\nexport class Customizations {\n  private static _suppressUpdates: boolean;\n\n  public static reset(): void {\n    _allSettings.settings = {};\n    _allSettings.scopedSettings = {};\n  }\n\n  /** Apply global Customization settings.\n   * @example Customizations.applySettings(\\{ theme: \\{...\\} \\});\n   */\n  public static applySettings(settings: ISettings): void {\n    _allSettings.settings = { ..._allSettings.settings, ...settings };\n    Customizations._raiseChange();\n  }\n\n  /** Apply Customizations to a particular named scope, like a component.\n   * @example Customizations.applyScopedSettings('Nav', \\{ styles: () =\\> \\{\\} \\});\n   */\n  public static applyScopedSettings(scopeName: string, settings: ISettings): void {\n    _allSettings.scopedSettings[scopeName] = { ..._allSettings.scopedSettings[scopeName], ...settings };\n    Customizations._raiseChange();\n  }\n\n  public static getSettings(\n    properties: string[],\n    scopeName?: string,\n    localSettings: ICustomizations = NO_CUSTOMIZATIONS,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): any {\n    const settings: ISettings = {};\n    const localScopedSettings = (scopeName && localSettings.scopedSettings[scopeName]) || {};\n    const globalScopedSettings = (scopeName && _allSettings.scopedSettings[scopeName]) || {};\n\n    for (let property of properties) {\n      settings[property] =\n        localScopedSettings[property] ||\n        localSettings.settings[property] ||\n        globalScopedSettings[property] ||\n        _allSettings.settings[property];\n    }\n\n    return settings;\n  }\n\n  /** Used to run some code that sets Customizations without triggering an update until the end.\n   * Useful for applying Customizations that don't affect anything currently rendered, or for\n   * applying many customizations at once.\n   * @param suppressUpdate - Do not raise the change event at the end, preventing all updates\n   */\n  public static applyBatchedUpdates(code: () => void, suppressUpdate?: boolean): void {\n    Customizations._suppressUpdates = true;\n    try {\n      code();\n    } catch {\n      /* do nothing */\n    }\n    Customizations._suppressUpdates = false;\n    if (!suppressUpdate) {\n      Customizations._raiseChange();\n    }\n  }\n\n  public static observe(onChange: () => void): void {\n    _events.push(onChange);\n  }\n\n  public static unobserve(onChange: () => void): void {\n    _events = _events.filter((cb: () => void) => cb !== onChange);\n  }\n\n  private static _raiseChange(): void {\n    if (!Customizations._suppressUpdates) {\n      _events.forEach((cb: () => void) => cb());\n    }\n  }\n}\n","import { _isSSR } from './setSSR';\n\n/**\n * Helper to get the document object. Note that in popup window cases, document\n * might be the wrong document, which is why we look at ownerDocument for the\n * truth. Also note that the SSR flag is used to test ssr scenarios even if\n * document is defined (from JSDOM for example.)\n *\n * @public\n */\nexport function getDocument(rootElement?: HTMLElement | null): Document | undefined {\n  if (_isSSR || typeof document === 'undefined') {\n    return undefined;\n  } else {\n    const el = rootElement as Element;\n\n    return el && el.ownerDocument ? el.ownerDocument : document;\n  }\n}\n","import { _isSSR } from './setSSR';\n\nlet _window: Window | undefined = undefined;\n\n// Note: Accessing \"window\" in IE11 is somewhat expensive, and calling \"typeof window\"\n// hits a memory leak, whereas aliasing it and calling \"typeof _window\" does not.\n// Caching the window value at the file scope lets us minimize the impact.\ntry {\n  _window = window;\n} catch (e) {\n  /* no-op */\n}\n\n/**\n * Helper to get the window object. The helper will make sure to use a cached variable\n * of \"window\", to avoid overhead and memory leaks in IE11. Note that in popup scenarios the\n * window object won't match the \"global\" window object, and for these scenarios, you should\n * pass in an element hosted within the popup.\n *\n * @public\n */\nexport function getWindow(rootElement?: Element | null): Window | undefined {\n  if (_isSSR || typeof _window === 'undefined') {\n    return undefined;\n  } else {\n    const el = rootElement as Element;\n\n    return el && el.ownerDocument && el.ownerDocument.defaultView ? el.ownerDocument.defaultView : _window;\n  }\n}\n","export let _isSSR = false;\n\n/**\n * Helper to set ssr mode to simulate no window object returned from getWindow helper.\n *\n * @public\n */\nexport function setSSR(isEnabled: boolean): void {\n  _isSSR = isEnabled;\n}\n","import { getDocument } from './dom/getDocument';\nimport * as localStorage from './localStorage';\nimport * as sessionStorage from './sessionStorage';\n\n// Default to undefined so that we initialize on first read.\nlet _language: string | null;\n\nconst STORAGE_KEY = 'language';\n\n/**\n * Gets the language set for the page.\n * @param persistenceType - Where to persist the value. Default is `localStorage` if available.\n * (In version 8, the default will be `sessionStorage`.)\n */\nexport function getLanguage(\n  persistenceType: 'localStorage' | 'sessionStorage' | 'none' = 'localStorage',\n): string | null {\n  if (_language === undefined) {\n    let doc = getDocument();\n    const savedLanguage =\n      persistenceType === 'localStorage'\n        ? localStorage.getItem(STORAGE_KEY)\n        : persistenceType === 'sessionStorage'\n        ? sessionStorage.getItem(STORAGE_KEY)\n        : undefined;\n\n    if (savedLanguage) {\n      _language = savedLanguage;\n    }\n\n    if (_language === undefined && doc) {\n      _language = doc.documentElement.getAttribute('lang');\n    }\n\n    if (_language === undefined) {\n      _language = 'en';\n    }\n  }\n\n  return _language;\n}\n\n/**\n * Sets the language for the page (by adjusting the lang attribute of the html element).\n * @param language - Language to set.\n * @param persistenceType - Where to persist the value. Default is `localStorage` if available.\n * (In version 8, the default will be `sessionStorage`.)\n */\nexport function setLanguage(language: string, persistenceType?: 'localStorage' | 'sessionStorage' | 'none'): void;\n/**\n * Sets the language for the page (by adjusting the lang attribute of the html element).\n * @deprecated Use string parameter version.\n * @param language - Language to set.\n * @param avoidPersisting - If true, don't store the value.\n */\nexport function setLanguage(language: string, avoidPersisting?: boolean): void;\nexport function setLanguage(\n  language: string,\n  persistenceParam?: 'localStorage' | 'sessionStorage' | 'none' | boolean,\n): void {\n  let doc = getDocument();\n\n  if (doc) {\n    doc.documentElement.setAttribute('lang', language);\n  }\n\n  const persistenceType = persistenceParam === true ? 'none' : !persistenceParam ? 'localStorage' : persistenceParam;\n  if (persistenceType === 'localStorage') {\n    localStorage.setItem(STORAGE_KEY, language);\n  } else if (persistenceType === 'sessionStorage') {\n    sessionStorage.setItem(STORAGE_KEY, language);\n  }\n\n  _language = language;\n}\n","import { getWindow } from './dom/getWindow';\n\n/**\n * Fetches an item from local storage without throwing an exception\n * @param key The key of the item to fetch from local storage\n */\nexport function getItem(key: string): string | null {\n  let result = null;\n  try {\n    const win = getWindow();\n    result = win ? win.localStorage.getItem(key) : null;\n  } catch (e) {\n    /* Eat the exception */\n  }\n  return result;\n}\n\n/**\n * Inserts an item into local storage without throwing an exception\n * @param key The key of the item to add to local storage\n * @param data The data to put into local storage\n */\nexport function setItem(key: string, data: string): void {\n  try {\n    const win = getWindow();\n\n    win && win.localStorage.setItem(key, data);\n  } catch (e) {\n    /* Eat the exception */\n  }\n}\n","import { Stylesheet } from '@uifabric/merge-styles';\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\ndeclare class WeakMap {\n  public get(key: any): any;\n  public set(key: any, value: any): void;\n  public has(key: any): boolean;\n}\n\nlet _initializedStylesheetResets = false;\nlet _resetCounter = 0;\nconst _emptyObject = { empty: true };\nconst _dictionary: any = {};\nlet _weakMap = typeof WeakMap === 'undefined' ? null : WeakMap;\n\ninterface IMemoizeNode {\n  map: WeakMap | null;\n  value?: any;\n}\n\n/**\n *  Test utility for providing a custom weakmap.\n *\n * @internal\n * */\nexport function setMemoizeWeakMap(weakMap: any): void {\n  _weakMap = weakMap;\n}\n\n/**\n * Reset memoizations.\n */\nexport function resetMemoizations(): void {\n  _resetCounter++;\n}\n\n/**\n * Memoize decorator to be used on class methods. WARNING: the `this` reference\n * will be inaccessible within a memoized method, given that a cached method's `this`\n * would not be instance-specific.\n *\n * @public\n */\nexport function memoize<T extends Function>(\n  target: any,\n  key: string,\n  descriptor: TypedPropertyDescriptor<T>,\n): {\n  configurable: boolean;\n  get(): T;\n} {\n  // We bind to \"null\" to prevent people from inadvertently pulling values from \"this\",\n  // rather than passing them in as input values which can be memoized.\n  let fn = memoizeFunction(descriptor.value && descriptor.value.bind(null));\n\n  return {\n    configurable: true,\n    get(): T {\n      return fn;\n    },\n  };\n}\n\n/**\n * Memoizes a function; when you pass in the same parameters multiple times, it returns a cached result.\n * Be careful when passing in objects, you need to pass in the same INSTANCE for caching to work. Otherwise\n * it will grow the cache unnecessarily. Also avoid using default values that evaluate functions; passing in\n * undefined for a value and relying on a default function will execute it the first time, but will not\n * re-evaluate subsequent times which may have been unexpected.\n *\n * By default, the cache will reset after 100 permutations, to avoid abuse cases where the function is\n * unintendedly called with unique objects. Without a reset, the cache could grow infinitely, so we safeguard\n * by resetting. To override this behavior, pass a value of 0 to the maxCacheSize parameter.\n *\n * @public\n * @param cb - The function to memoize.\n * @param maxCacheSize - Max results to cache. If the cache exceeds this value, it will reset on the next call.\n * @param ignoreNullOrUndefinedResult - Flag to decide whether to cache callback result if it is undefined/null.\n * If the flag is set to true, the callback result is recomputed every time till the callback result is\n * not undefined/null for the first time, and then the non-undefined/null version gets cached.\n * @returns A memoized version of the function.\n */\nexport function memoizeFunction<T extends (...args: any[]) => RetType, RetType>(\n  cb: T,\n  maxCacheSize: number = 100,\n  ignoreNullOrUndefinedResult: boolean = false,\n): T {\n  // Avoid breaking scenarios which don't have weak map.\n  if (!_weakMap) {\n    return cb;\n  }\n\n  if (!_initializedStylesheetResets) {\n    const stylesheet = Stylesheet.getInstance();\n\n    if (stylesheet && stylesheet.onReset) {\n      Stylesheet.getInstance().onReset(resetMemoizations);\n    }\n    _initializedStylesheetResets = true;\n  }\n\n  let rootNode: any;\n  let cacheSize = 0;\n  let localResetCounter = _resetCounter;\n\n  return function memoizedFunction(...args: any[]): RetType {\n    let currentNode: any = rootNode;\n\n    if (\n      rootNode === undefined ||\n      localResetCounter !== _resetCounter ||\n      (maxCacheSize > 0 && cacheSize > maxCacheSize)\n    ) {\n      rootNode = _createNode();\n      cacheSize = 0;\n      localResetCounter = _resetCounter;\n    }\n\n    currentNode = rootNode;\n\n    // Traverse the tree until we find the match.\n    for (let i = 0; i < args.length; i++) {\n      let arg = _normalizeArg(args[i]);\n\n      if (!currentNode.map.has(arg)) {\n        currentNode.map.set(arg, _createNode());\n      }\n\n      currentNode = currentNode.map.get(arg);\n    }\n\n    if (!currentNode.hasOwnProperty('value')) {\n      currentNode.value = cb(...args);\n      cacheSize++;\n    }\n\n    if (ignoreNullOrUndefinedResult && (currentNode.value === null || currentNode.value === undefined)) {\n      currentNode.value = cb(...args);\n    }\n\n    return currentNode.value;\n  } as any;\n}\n\n/**\n * Creates a memoizer for a single-value function, backed by a WeakMap.\n * With a WeakMap, the memoized values are only kept as long as the source objects,\n * ensuring that there is no memory leak.\n *\n * This function assumes that the input values passed to the wrapped function will be\n * `function` or `object` types. To memoize functions which accept other inputs, use\n * `memoizeFunction`, which memoizes against arbitrary inputs using a lookup cache.\n *\n * @public\n */\nexport function createMemoizer<F extends (input: any) => any>(getValue: F): F {\n  if (!_weakMap) {\n    // Without a `WeakMap` implementation, memoization is not possible.\n    return getValue;\n  }\n\n  const cache = new _weakMap();\n\n  function memoizedGetValue(input: any): any {\n    if (!input || (typeof input !== 'function' && typeof input !== 'object')) {\n      // A WeakMap can only be used to test against reference values, i.e. 'function' and 'object'.\n      // All other inputs cannot be memoized against in this manner.\n      return getValue(input);\n    }\n\n    if (cache.has(input)) {\n      return cache.get(input)!;\n    }\n\n    const value = getValue(input);\n\n    cache.set(input, value);\n\n    return value;\n  }\n\n  return memoizedGetValue as F;\n}\n\nfunction _normalizeArg(val: null | undefined): { empty: boolean } | any;\nfunction _normalizeArg(val: object): any;\nfunction _normalizeArg(val: any): any {\n  if (!val) {\n    return _emptyObject;\n  } else if (typeof val === 'object' || typeof val === 'function') {\n    return val;\n  } else if (!_dictionary[val]) {\n    _dictionary[val] = { val };\n  }\n\n  return _dictionary[val];\n}\n\nfunction _createNode(): IMemoizeNode {\n  return {\n    map: _weakMap ? new _weakMap() : null,\n  };\n}\n","/**\n * Simple deep merge function. Takes all arguments and returns a deep copy of the objects merged\n * together in the order provided. If an object creates a circular reference, it will assign the\n * original reference.\n */\nexport function merge<T = {}>(target: Partial<T>, ...args: (Partial<T> | null | undefined | false)[]): T {\n  for (const arg of args) {\n    _merge(target || {}, arg as Partial<T>);\n  }\n\n  return target as T;\n}\n\n/**\n * The _merge helper iterates through all props on source and assigns them to target.\n * When the value is an object, we will create a deep clone of the object. However if\n * there is a circular reference, the value will not be deep cloned and will persist\n * the reference.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _merge<T extends Object>(target: T, source: T, circularReferences: any[] = []): T {\n  circularReferences.push(source);\n\n  for (let name in source) {\n    if (source.hasOwnProperty(name)) {\n      if (name !== '__proto__' && name !== 'constructor' && name !== 'prototype') {\n        const value: T[Extract<keyof T, string>] = source[name];\n        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n          const isCircularReference = circularReferences.indexOf(value) > -1;\n          target[name] = (isCircularReference\n            ? value\n            : _merge(target[name] || {}, value, circularReferences)) as T[Extract<keyof T, string>];\n        } else {\n          target[name] = value;\n        }\n      }\n    }\n  }\n\n  circularReferences.pop();\n\n  return target;\n}\n","const toObjectMap = (...items: (string[] | Record<string, number>)[]) => {\n  const result: Record<string, number> = {};\n\n  for (const item of items) {\n    const keys = Array.isArray(item) ? item : Object.keys(item);\n\n    for (const key of keys) {\n      result[key] = 1;\n    }\n  }\n\n  return result;\n};\n\n/**\n * An array of events that are allowed on every html element type.\n *\n * @public\n */\nexport const baseElementEvents = toObjectMap([\n  'onCopy',\n  'onCut',\n  'onPaste',\n  'onCompositionEnd',\n  'onCompositionStart',\n  'onCompositionUpdate',\n  'onFocus',\n  'onFocusCapture',\n  'onBlur',\n  'onBlurCapture',\n  'onChange',\n  'onInput',\n  'onSubmit',\n  'onLoad',\n  'onError',\n  'onKeyDown',\n  'onKeyDownCapture',\n  'onKeyPress',\n  'onKeyUp',\n  'onAbort',\n  'onCanPlay',\n  'onCanPlayThrough',\n  'onDurationChange',\n  'onEmptied',\n  'onEncrypted',\n  'onEnded',\n  'onLoadedData',\n  'onLoadedMetadata',\n  'onLoadStart',\n  'onPause',\n  'onPlay',\n  'onPlaying',\n  'onProgress',\n  'onRateChange',\n  'onSeeked',\n  'onSeeking',\n  'onStalled',\n  'onSuspend',\n  'onTimeUpdate',\n  'onVolumeChange',\n  'onWaiting',\n  'onClick',\n  'onClickCapture',\n  'onContextMenu',\n  'onDoubleClick',\n  'onDrag',\n  'onDragEnd',\n  'onDragEnter',\n  'onDragExit',\n  'onDragLeave',\n  'onDragOver',\n  'onDragStart',\n  'onDrop',\n  'onMouseDown',\n  'onMouseDownCapture',\n  'onMouseEnter',\n  'onMouseLeave',\n  'onMouseMove',\n  'onMouseOut',\n  'onMouseOver',\n  'onMouseUp',\n  'onMouseUpCapture',\n  'onSelect',\n  'onTouchCancel',\n  'onTouchEnd',\n  'onTouchMove',\n  'onTouchStart',\n  'onScroll',\n  'onWheel',\n  'onPointerCancel',\n  'onPointerDown',\n  'onPointerEnter',\n  'onPointerLeave',\n  'onPointerMove',\n  'onPointerOut',\n  'onPointerOver',\n  'onPointerUp',\n  'onGotPointerCapture',\n  'onLostPointerCapture',\n]);\n\n/**\n * An array of element attributes which are allowed on every html element type.\n *\n * @public\n */\nexport const baseElementProperties = toObjectMap([\n  'accessKey', // global\n  'children', // global\n  'className', // global\n  'contentEditable', // global\n  'dir', // global\n  'draggable', // global\n  'hidden', // global\n  'htmlFor', // global\n  'id', // global\n  'lang', // global\n  'ref', // global\n  'role', // global\n  'style', // global\n  'tabIndex', // global\n  'title', // global\n  'translate', // global\n  'spellCheck', // global\n  'name', // global\n]);\n\n/**\n * An array of HTML element properties and events.\n *\n * @public\n */\nexport const htmlElementProperties = toObjectMap(baseElementProperties, baseElementEvents);\n\n/**\n * An array of LABEL tag properties and events.\n *\n * @public\n */\nexport const labelProperties = toObjectMap(htmlElementProperties, [\n  'form', // button, fieldset, input, label, meter, object, output, select, textarea\n]);\n\n/**\n * An array of AUDIO tag properties and events.\n\n * @public\n */\nexport const audioProperties = toObjectMap(htmlElementProperties, [\n  'height', // canvas, embed, iframe, img, input, object, video\n  'loop', // audio, video\n  'muted', // audio, video\n  'preload', // audio, video\n  'src', // audio, embed, iframe, img, input, script, source, track, video\n  'width', // canvas, embed, iframe, img, input, object, video\n]);\n\n/**\n * An array of VIDEO tag properties and events.\n *\n * @public\n */\nexport const videoProperties = toObjectMap(audioProperties, [\n  'poster', // video\n]);\n\n/**\n * An array of OL tag properties and events.\n *\n * @public\n */\nexport const olProperties = toObjectMap(htmlElementProperties, [\n  'start', // ol\n]);\n\n/**\n * An array of LI tag properties and events.\n *\n * @public\n */\nexport const liProperties = toObjectMap(htmlElementProperties, [\n  'value', // button, input, li, option, meter, progress, param\n]);\n\n/**\n * An array of A tag properties and events.\n *\n * @public\n */\nexport const anchorProperties = toObjectMap(htmlElementProperties, [\n  'download', // a, area\n  'href', // a, area, base, link\n  'hrefLang', // a, area, link\n  'media', // a, area, link, source, style\n  'rel', // a, area, link\n  'target', // a, area, base, form\n  'type', // a, button, input, link, menu, object, script, source, style\n]);\n\n/**\n * An array of BUTTON tag properties and events.\n *\n * @public\n */\nexport const buttonProperties = toObjectMap(htmlElementProperties, [\n  'autoFocus', // button, input, select, textarea\n  'disabled', // button, fieldset, input, optgroup, option, select, textarea\n  'form', // button, fieldset, input, label, meter, object, output, select, textarea\n  'formAction', // input, button\n  'formEncType', // input, button\n  'formMethod', // input, button\n  'formNoValidate', // input, button\n  'formTarget', // input, button\n  'type', // a, button, input, link, menu, object, script, source, style\n  'value', // button, input, li, option, meter, progress, param,\n]);\n\n/**\n * An array of INPUT tag properties and events.\n *\n * @public\n */\nexport const inputProperties = toObjectMap(buttonProperties, [\n  'accept', // input\n  'alt', // area, img, input\n  'autoCapitalize', // input, textarea\n  'autoComplete', // form, input\n  'checked', // input\n  'dirname', // input, textarea\n  'form', // button, fieldset, input, label, meter, object, output, select, textarea\n  'height', // canvas, embed, iframe, img, input, object, video\n  'inputMode', // input\n  'list', // input\n  'max', // input, meter\n  'maxLength', // input, textarea\n  'min', // input, meter\n  'multiple', // input, select\n  'pattern', // input\n  'placeholder', // input, textarea\n  'readOnly', // input, textarea\n  'required', // input, select, textarea\n  'src', // audio, embed, iframe, img, input, script, source, track, video\n  'step', // input\n  'size', // input\n  'type', // a, button, input, link, menu, object, script, source, style\n  'value', // button, input, li, option, meter, progress, param\n  'width', // canvas, embed, iframe, img, input, object, video\n]);\n\n/**\n * An array of TEXTAREA tag properties and events.\n *\n * @public\n */\nexport const textAreaProperties = toObjectMap(buttonProperties, [\n  'autoCapitalize', // input, textarea\n  'cols', // textarea\n  'dirname', // input, textarea\n  'form', // button, fieldset, input, label, meter, object, output, select, textarea\n  'maxLength', // input, textarea\n  'placeholder', // input, textarea\n  'readOnly', // input, textarea\n  'required', // input, select, textarea\n  'rows', // textarea\n  'wrap', // textarea\n]);\n\n/**\n * An array of SELECT tag properties and events.\n *\n * @public\n */\nexport const selectProperties = toObjectMap(buttonProperties, [\n  'form', // button, fieldset, input, label, meter, object, output, select, textarea\n  'multiple', // input, select\n  'required', // input, select, textarea\n]);\n\nexport const optionProperties = toObjectMap(htmlElementProperties, [\n  'selected', // option\n  'value', // button, input, li, option, meter, progress, param\n]);\n\n/**\n * An array of TABLE tag properties and events.\n *\n * @public\n */\nexport const tableProperties = toObjectMap(htmlElementProperties, [\n  'cellPadding', // table\n  'cellSpacing', // table\n]);\n\n/**\n * An array of TR tag properties and events.\n *\n * @public\n */\nexport const trProperties = htmlElementProperties;\n\n/**\n * An array of TH tag properties and events.\n *\n * @public\n */\nexport const thProperties = toObjectMap(htmlElementProperties, [\n  'rowSpan', // td, th\n  'scope', // th\n]);\n\n/**\n * An array of TD tag properties and events.\n *\n * @public\n */\nexport const tdProperties = toObjectMap(htmlElementProperties, [\n  'colSpan', // td\n  'headers', // td\n  'rowSpan', // td, th\n  'scope', // th\n]);\n\nexport const colGroupProperties = toObjectMap(htmlElementProperties, [\n  'span', // col, colgroup\n]);\n\nexport const colProperties = toObjectMap(htmlElementProperties, [\n  'span', // col, colgroup\n]);\n\n/**\n * An array of FORM tag properties and events.\n *\n * @public\n */\nexport const formProperties = toObjectMap(htmlElementProperties, [\n  'acceptCharset', // form\n  'action', // form\n  'encType', // form\n  'encType', // form\n  'method', // form\n  'noValidate', // form\n  'target', // form\n]);\n\n/**\n * An array of IFRAME tag properties and events.\n *\n * @public\n */\nexport const iframeProperties = toObjectMap(htmlElementProperties, [\n  'allow', // iframe\n  'allowFullScreen', // iframe\n  'allowPaymentRequest', // iframe\n  'allowTransparency', // iframe\n  'csp', // iframe\n  'height', // canvas, embed, iframe, img, input, object, video\n  'importance', // iframe\n  'referrerPolicy', // iframe\n  'sandbox', // iframe\n  'src', // audio, embed, iframe, img, input, script, source, track, video\n  'srcDoc', // iframe\n  'width', // canvas, embed, iframe, img, input, object, video,\n]);\n\n/**\n * An array of IMAGE tag properties and events.\n *\n * @public\n */\nexport const imgProperties = toObjectMap(htmlElementProperties, [\n  'alt', // area, img, input\n  'crossOrigin', // img\n  'height', // canvas, embed, iframe, img, input, object, video\n  'src', // audio, embed, iframe, img, input, script, source, track, video\n  'srcSet', // img, source\n  'useMap', // img, object,\n  'width', // canvas, embed, iframe, img, input, object, video\n]);\n\n/**\n * @deprecated Use imgProperties for img elements.\n */\nexport const imageProperties = imgProperties;\n\n/**\n * An array of DIV tag properties and events.\n *\n * @public\n */\nexport const divProperties = htmlElementProperties;\n\n/**\n * Gets native supported props for an html element provided the allowance set. Use one of the property\n * sets defined (divProperties, buttonPropertes, etc) to filter out supported properties from a given\n * props set. Note that all data- and aria- prefixed attributes will be allowed.\n * NOTE: getNativeProps should always be applied first when adding props to a react component. The\n * non-native props should be applied second. This will prevent getNativeProps from overriding your custom props.\n * For example, if props passed to getNativeProps has an onClick function and getNativeProps is added to\n * the component after an onClick function is added, then the getNativeProps onClick will override it.\n *\n * @public\n * @param props - The unfiltered input props\n * @param allowedPropsNames - The array or record of allowed prop names.\n * @returns The filtered props\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getNativeProps<T extends Record<string, any>>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  props: Record<string, any>,\n  allowedPropNames: string[] | Record<string, number>,\n  excludedPropNames?: string[],\n): T {\n  // It'd be great to properly type this while allowing 'aria-` and 'data-' attributes like TypeScript does for\n  // JSX attributes, but that ability is hardcoded into the TS compiler with no analog in TypeScript typings.\n  // Then we'd be able to enforce props extends native props (including aria- and data- attributes), and then\n  // return native props.\n  // We should be able to do this once this PR is merged: https://github.com/microsoft/TypeScript/pull/26797\n\n  const isArray = Array.isArray(allowedPropNames);\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const result: Record<string, any> = {};\n  const keys = Object.keys(props);\n\n  for (const key of keys) {\n    const isNativeProp =\n      (!isArray && (allowedPropNames as Record<string, number>)[key]) ||\n      (isArray && (allowedPropNames as string[]).indexOf(key) >= 0) ||\n      key.indexOf('data-') === 0 ||\n      key.indexOf('aria-') === 0;\n\n    if (isNativeProp && (!excludedPropNames || excludedPropNames?.indexOf(key) === -1)) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      result[key] = props![key] as any;\n    }\n  }\n\n  return result as T;\n}\n","import { getWindow } from './dom/getWindow';\n\n/**\n * Fetches an item from session storage without throwing an exception\n * @param key The key of the item to fetch from session storage\n */\nexport function getItem(key: string): string | null {\n  let result = null;\n  try {\n    const win = getWindow();\n    result = win ? win.sessionStorage.getItem(key) : null;\n  } catch (e) {\n    /* Eat the exception */\n  }\n  return result;\n}\n\n/**\n * Inserts an item into session storage without throwing an exception\n * @param key The key of the item to add to session storage\n * @param data The data to put into session storage\n */\nexport function setItem(key: string, data: string): void {\n  try {\n    getWindow()?.sessionStorage.setItem(key, data);\n  } catch (e) {\n    /* Eat the exception */\n  }\n}\n","import * as React from 'react';\nimport { ICustomizations } from './Customizations';\n\nexport interface ICustomizerContext {\n  customizations: ICustomizations;\n}\n\nexport const CustomizerContext = React.createContext<ICustomizerContext>({\n  customizations: {\n    inCustomizerContext: false,\n    settings: {},\n    scopedSettings: {},\n  },\n});\n","import * as React from 'react';\nimport { ISettings, Customizations } from './Customizations';\nimport { CustomizerContext } from './CustomizerContext';\n\n/**\n * Hook to get Customizations settings from Customizations singleton or CustomizerContext.\n * It will trigger component state update on settings change observed.\n */\nexport function useCustomizationSettings(properties: string[], scopeName?: string): ISettings {\n  const forceUpdate = useForceUpdate();\n  const { customizations } = React.useContext(CustomizerContext);\n  const { inCustomizerContext } = customizations;\n  React.useEffect(() => {\n    if (!inCustomizerContext) {\n      Customizations.observe(forceUpdate);\n    }\n    return () => {\n      if (!inCustomizerContext) {\n        Customizations.unobserve(forceUpdate);\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- exclude forceUpdate\n  }, [inCustomizerContext]);\n\n  return Customizations.getSettings(properties, scopeName, customizations);\n}\n\nfunction useForceUpdate() {\n  const [, setValue] = React.useState(0);\n  return () => setValue(value => ++value);\n}\n","import * as React from 'react';\nimport { IStyleSet, IStyleFunctionOrObject, concatStyleSetsWithProps } from '@uifabric/merge-styles';\nimport { useCustomizationSettings } from './customizations/useCustomizationSettings';\n\nexport interface IPropsWithStyles<TStyleProps, TStyleSet extends IStyleSet<TStyleSet>> {\n  styles?: IStyleFunctionOrObject<TStyleProps, TStyleSet>;\n}\n\nexport interface ICustomizableProps {\n  /**\n   * Name of scope, which can be targeted using the Customizer.\n   */\n  scope: string;\n\n  /**\n   * List of fields which can be customized.\n   * @defaultvalue [ 'theme', 'styles' ]\n   */\n  fields?: string[];\n}\n\nconst DefaultFields = ['theme', 'styles'];\n\nexport type StyleFunction<TStyleProps, TStyleSet> = IStyleFunctionOrObject<TStyleProps, TStyleSet> & {\n  /** Cache for all style functions. */\n  __cachedInputs__: (IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined)[];\n\n  /** True if no styles prop or styles from Customizer is passed to wrapped component. */\n  __noStyleOverride__: boolean;\n};\n\n/**\n * The styled HOC wrapper allows you to create a functional wrapper around a given component which will resolve\n * getStyles functional props, and mix customized props passed in using concatStyleSets.\n *\n * @example\n * ```tsx\n * export const Toggle = styled(\n *   ToggleBase,\n *   props => ({ root: { background: 'red' }})\n * );\n * ```\n * @param Component - The unstyled base component to render, which receives styles.\n * @param baseStyles - The styles which should be curried with the component.\n * @param getProps - A helper which provides default props.\n * @param customizable - An object which defines which props can be customized using the Customizer.\n * @param pure - A boolean indicating if the component should avoid re-rendering when props haven't changed.\n * Note that pure should not be used on components which allow children, or take in complex objects or\n * arrays as props which could mutate on every render.\n */\nexport function styled<\n  TComponentProps extends IPropsWithStyles<TStyleProps, TStyleSet>,\n  TStyleProps,\n  TStyleSet extends IStyleSet<TStyleSet>\n>(\n  Component: React.ComponentClass<TComponentProps> | React.FunctionComponent<TComponentProps>,\n  baseStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet>,\n  getProps?: (props: TComponentProps) => Partial<TComponentProps>,\n  customizable?: ICustomizableProps,\n  pure?: boolean,\n): React.FunctionComponent<TComponentProps>;\nexport function styled<\n  TComponentProps extends IPropsWithStyles<TStyleProps, TStyleSet> & React.RefAttributes<TRef>,\n  TStyleProps,\n  TStyleSet extends IStyleSet<TStyleSet>,\n  TRef = unknown\n>(\n  Component: React.ComponentClass<TComponentProps> | React.FunctionComponent<TComponentProps>,\n  baseStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet>,\n  getProps?: (props: TComponentProps) => Partial<TComponentProps>,\n  customizable?: ICustomizableProps,\n  pure?: boolean,\n): React.ForwardRefExoticComponent<React.PropsWithoutRef<TComponentProps> & React.RefAttributes<TRef>>;\nexport function styled<\n  TComponentProps extends IPropsWithStyles<TStyleProps, TStyleSet> & React.RefAttributes<TRef>,\n  TStyleProps,\n  TStyleSet extends IStyleSet<TStyleSet>,\n  TRef = unknown\n>(\n  Component: React.ComponentClass<TComponentProps> | React.FunctionComponent<TComponentProps>,\n  baseStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet>,\n  getProps?: (props: TComponentProps) => Partial<TComponentProps>,\n  customizable?: ICustomizableProps,\n  pure?: boolean,\n) {\n  customizable = customizable || { scope: '', fields: undefined };\n\n  const { scope, fields = DefaultFields } = customizable;\n\n  const Wrapped = React.forwardRef((props: TComponentProps, forwardedRef: React.Ref<TRef>) => {\n    const styles = React.useRef<StyleFunction<TStyleProps, TStyleSet>>();\n\n    const settings = useCustomizationSettings(fields, scope);\n    const { styles: customizedStyles, dir, ...rest } = settings;\n    const additionalProps = getProps ? getProps(props) : undefined;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const cache = (styles.current && (styles.current as any).__cachedInputs__) || [];\n    if (!styles.current || customizedStyles !== cache[1] || props.styles !== cache[2]) {\n      // Using styled components as the Component arg will result in nested styling arrays.\n      const concatenatedStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet> = (styleProps: TStyleProps) =>\n        concatStyleSetsWithProps(styleProps, baseStyles, customizedStyles, props.styles);\n\n      // The __cachedInputs__ array is attached to the function and consumed by the\n      // classNamesFunction as a list of keys to include for memoizing classnames.\n      (concatenatedStyles as StyleFunction<TStyleProps, TStyleSet>).__cachedInputs__ = [\n        baseStyles,\n        customizedStyles,\n        props.styles,\n      ];\n\n      (concatenatedStyles as StyleFunction<TStyleProps, TStyleSet>).__noStyleOverride__ =\n        !customizedStyles && !props.styles;\n\n      styles.current = concatenatedStyles as StyleFunction<TStyleProps, TStyleSet>;\n    }\n\n    return <Component ref={forwardedRef} {...rest} {...additionalProps} {...props} styles={styles.current} />;\n  });\n  // Function.prototype.name is an ES6 feature, so the cast to any is required until we're\n  // able to drop IE 11 support and compile with ES6 libs\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Wrapped.displayName = `Styled${Component.displayName || (Component as any).name}`;\n\n  // This preserves backwards compatibility.\n  const pureComponent = pure ? React.memo(Wrapped) : Wrapped;\n  // Check if the wrapper has a displayName after it has been memoized. Then assign it to the pure component.\n  if (Wrapped.displayName) {\n    pureComponent.displayName = Wrapped.displayName;\n  }\n\n  return pureComponent;\n}\n","import { concatStyleSets } from './concatStyleSets';\nimport { IStyleSet } from './IStyleSet';\nimport { IStyleFunctionOrObject } from './IStyleFunction';\nimport { DeepPartial } from './DeepPartial';\n\n/**\n * Concatenates style sets into one, but resolves functional sets using the given props.\n * @param styleProps - Props used to resolve functional sets.\n * @param allStyles - Style sets, which can be functions or objects.\n */\nexport function concatStyleSetsWithProps<TStyleProps, TStyleSet extends IStyleSet<TStyleSet>>(\n  styleProps: TStyleProps,\n  ...allStyles: (IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined)[]\n): DeepPartial<TStyleSet> {\n  const result: DeepPartial<TStyleSet>[] = [];\n  for (const styles of allStyles) {\n    if (styles) {\n      result.push(typeof styles === 'function' ? styles(styleProps) : styles);\n    }\n  }\n  if (result.length === 1) {\n    return result[0] as DeepPartial<TStyleSet>;\n  } else if (result.length) {\n    // cliffkoh: I cannot figure out how to avoid the cast to any here.\n    // It is something to do with the use of Omit in IStyleSet.\n    // It might not be necessary once  Omit becomes part of lib.d.ts (when we remove our own Omit and rely on\n    // the official version).\n    return concatStyleSets(...(result as any)) as any;\n  }\n\n  return {};\n}\n","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\n\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\n\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n\nimport { useCallback, useRef, useState } from 'react';\nimport * as Utils from './utils';\n\nfunction useUncontrolledProp(propValue, defaultValue, handler) {\n  var wasPropRef = useRef(propValue !== undefined);\n\n  var _useState = useState(defaultValue),\n      stateValue = _useState[0],\n      setState = _useState[1];\n\n  var isProp = propValue !== undefined;\n  var wasProp = wasPropRef.current;\n  wasPropRef.current = isProp;\n  /**\n   * If a prop switches from controlled to Uncontrolled\n   * reset its value to the defaultValue\n   */\n\n  if (!isProp && wasProp && stateValue !== defaultValue) {\n    setState(defaultValue);\n  }\n\n  return [isProp ? propValue : stateValue, useCallback(function (value) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    if (handler) handler.apply(void 0, [value].concat(args));\n    setState(value);\n  }, [handler])];\n}\n\nexport { useUncontrolledProp };\nexport default function useUncontrolled(props, config) {\n  return Object.keys(config).reduce(function (result, fieldName) {\n    var _extends2;\n\n    var _ref = result,\n        defaultValue = _ref[Utils.defaultKey(fieldName)],\n        propsValue = _ref[fieldName],\n        rest = _objectWithoutPropertiesLoose(_ref, [Utils.defaultKey(fieldName), fieldName].map(_toPropertyKey));\n\n    var handlerName = config[fieldName];\n\n    var _useUncontrolledProp = useUncontrolledProp(propsValue, defaultValue, props[handlerName]),\n        value = _useUncontrolledProp[0],\n        handler = _useUncontrolledProp[1];\n\n    return _extends({}, rest, (_extends2 = {}, _extends2[fieldName] = value, _extends2[handlerName] = handler, _extends2));\n  }, props);\n}","//     Underscore.js 1.9.1\n//     http://underscorejs.org\n//     (c) 2009-2018 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n            typeof global == 'object' && global.global === global && global ||\n            this ||\n            {};\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push = ArrayProto.push,\n      slice = ArrayProto.slice,\n      toString = ObjProto.toString,\n      hasOwnProperty = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var nativeIsArray = Array.isArray,\n      nativeKeys = Object.keys,\n      nativeCreate = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for their old module API. If we're in\n  // the browser, add `_` as a global object.\n  // (`nodeType` is checked to ensure that `module`\n  // and `exports` are not HTML elements.)\n  if (typeof exports != 'undefined' && !exports.nodeType) {\n    if (typeof module != 'undefined' && !module.nodeType && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.9.1';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      // The 2-argument case is omitted because we’re not using it.\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  var builtinIteratee;\n\n  // An internal function to generate callbacks that can be applied to each\n  // element in a collection, returning the desired result — either `identity`,\n  // an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (_.iteratee !== builtinIteratee) return _.iteratee(value, context);\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value) && !_.isArray(value)) return _.matcher(value);\n    return _.property(value);\n  };\n\n  // External wrapper for our callback generator. Users may customize\n  // `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n  // This abstraction hides the internal-only argCount argument.\n  _.iteratee = builtinIteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // Some functions take a variable number of arguments, or a few expected\n  // arguments at the beginning and then a variable number of values to operate\n  // on. This helper accumulates all remaining arguments past the function’s\n  // argument length (or an explicit `startIndex`), into an array that becomes\n  // the last argument. Similar to ES6’s \"rest parameter\".\n  var restArguments = function(func, startIndex) {\n    startIndex = startIndex == null ? func.length - 1 : +startIndex;\n    return function() {\n      var length = Math.max(arguments.length - startIndex, 0),\n          rest = Array(length),\n          index = 0;\n      for (; index < length; index++) {\n        rest[index] = arguments[index + startIndex];\n      }\n      switch (startIndex) {\n        case 0: return func.call(this, rest);\n        case 1: return func.call(this, arguments[0], rest);\n        case 2: return func.call(this, arguments[0], arguments[1], rest);\n      }\n      var args = Array(startIndex + 1);\n      for (index = 0; index < startIndex; index++) {\n        args[index] = arguments[index];\n      }\n      args[startIndex] = rest;\n      return func.apply(this, args);\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var shallowProperty = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  var has = function(obj, path) {\n    return obj != null && hasOwnProperty.call(obj, path);\n  }\n\n  var deepGet = function(obj, path) {\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      if (obj == null) return void 0;\n      obj = obj[path[i]];\n    }\n    return length ? obj : void 0;\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object.\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = shallowProperty('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  var createReduce = function(dir) {\n    // Wrap code that reassigns argument variables in a separate function than\n    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n    var reducer = function(obj, iteratee, memo, initial) {\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      if (!initial) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    };\n\n    return function(obj, iteratee, memo, context) {\n      var initial = arguments.length >= 3;\n      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n    };\n  };\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var keyFinder = isArrayLike(obj) ? _.findIndex : _.findKey;\n    var key = keyFinder(obj, predicate, context);\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = restArguments(function(obj, path, args) {\n    var contextPath, func;\n    if (_.isFunction(path)) {\n      func = path;\n    } else if (_.isArray(path)) {\n      contextPath = path.slice(0, -1);\n      path = path[path.length - 1];\n    }\n    return _.map(obj, function(context) {\n      var method = func;\n      if (!method) {\n        if (contextPath && contextPath.length) {\n          context = deepGet(context, contextPath);\n        }\n        if (context == null) return void 0;\n        method = context[path];\n      }\n      return method == null ? method : method.apply(context, args);\n    });\n  });\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection.\n  _.shuffle = function(obj) {\n    return _.sample(obj, Infinity);\n  };\n\n  // Sample **n** random values from a collection using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    var sample = isArrayLike(obj) ? _.clone(obj) : _.values(obj);\n    var length = getLength(sample);\n    n = Math.max(Math.min(n, length), 0);\n    var last = length - 1;\n    for (var index = 0; index < n; index++) {\n      var rand = _.random(index, last);\n      var temp = sample[index];\n      sample[index] = sample[rand];\n      sample[rand] = temp;\n    }\n    return sample.slice(0, n);\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    var index = 0;\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, key, list) {\n      return {\n        value: value,\n        index: index++,\n        criteria: iteratee(value, key, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior, partition) {\n    return function(obj, iteratee, context) {\n      var result = partition ? [[], []] : {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  var reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (_.isString(obj)) {\n      // Keep surrogate pair characters together\n      return obj.match(reStrSymbol);\n    }\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = group(function(result, value, pass) {\n    result[pass ? 0 : 1].push(value);\n  }, true);\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null || array.length < 1) return n == null ? void 0 : [];\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null || array.length < 1) return n == null ? void 0 : [];\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, Boolean);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, output) {\n    output = output || [];\n    var idx = output.length;\n    for (var i = 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        // Flatten current level of array or arguments object.\n        if (shallow) {\n          var j = 0, len = value.length;\n          while (j < len) output[idx++] = value[j++];\n        } else {\n          flatten(value, shallow, strict, output);\n          idx = output.length;\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = restArguments(function(array, otherArrays) {\n    return _.difference(array, otherArrays);\n  });\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // The faster algorithm will not work with an iteratee if the iteratee\n  // is not a one-to-one function, so providing an iteratee will disable\n  // the faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted && !iteratee) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = restArguments(function(arrays) {\n    return _.uniq(flatten(arrays, true, true));\n  });\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      var j;\n      for (j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = restArguments(function(array, rest) {\n    rest = flatten(rest, true, true);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  });\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices.\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = restArguments(_.unzip);\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values. Passing by pairs is the reverse of _.pairs.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions.\n  var createPredicateIndexFinder = function(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  };\n\n  // Returns the first index on an array-like that passes a predicate test.\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions.\n  var createIndexFinder = function(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n          i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  };\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    if (!step) {\n      step = stop < start ? -1 : 1;\n    }\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Chunk a single array into multiple arrays, each containing `count` or fewer\n  // items.\n  _.chunk = function(array, count) {\n    if (count == null || count < 1) return [];\n    var result = [];\n    var i = 0, length = array.length;\n    while (i < length) {\n      result.push(slice.call(array, i, i += count));\n    }\n    return result;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments.\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = restArguments(function(func, context, args) {\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var bound = restArguments(function(callArgs) {\n      return executeBound(func, bound, context, this, args.concat(callArgs));\n    });\n    return bound;\n  });\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder by default, allowing any combination of arguments to be\n  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\n  _.partial = restArguments(function(func, boundArgs) {\n    var placeholder = _.partial.placeholder;\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  });\n\n  _.partial.placeholder = _;\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = restArguments(function(obj, keys) {\n    keys = flatten(keys, false, false);\n    var index = keys.length;\n    if (index < 1) throw new Error('bindAll must be passed function names');\n    while (index--) {\n      var key = keys[index];\n      obj[key] = _.bind(obj[key], obj);\n    }\n  });\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = restArguments(function(func, wait, args) {\n    return setTimeout(function() {\n      return func.apply(null, args);\n    }, wait);\n  });\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var timeout, context, args, result;\n    var previous = 0;\n    if (!options) options = {};\n\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n\n    var throttled = function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n\n    throttled.cancel = function() {\n      clearTimeout(timeout);\n      previous = 0;\n      timeout = context = args = null;\n    };\n\n    return throttled;\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, result;\n\n    var later = function(context, args) {\n      timeout = null;\n      if (args) result = func.apply(context, args);\n    };\n\n    var debounced = restArguments(function(args) {\n      if (timeout) clearTimeout(timeout);\n      if (immediate) {\n        var callNow = !timeout;\n        timeout = setTimeout(later, wait);\n        if (callNow) result = func.apply(this, args);\n      } else {\n        timeout = _.delay(later, wait, this, args);\n      }\n\n      return result;\n    });\n\n    debounced.cancel = function() {\n      clearTimeout(timeout);\n      timeout = null;\n    };\n\n    return debounced;\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  _.restArguments = restArguments;\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var collectNonEnumProps = function(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  };\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`.\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object.\n  // In contrast to _.map it returns an object.\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = _.keys(obj),\n        length = keys.length,\n        results = {};\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys[index];\n      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  // The opposite of _.object.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`.\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, defaults) {\n    return function(obj) {\n      var length = arguments.length;\n      if (defaults) obj = Object(obj);\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!defaults || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s).\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test.\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Internal pick helper function to determine if `obj` has key `key`.\n  var keyInObj = function(value, key, obj) {\n    return key in obj;\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = restArguments(function(obj, keys) {\n    var result = {}, iteratee = keys[0];\n    if (obj == null) return result;\n    if (_.isFunction(iteratee)) {\n      if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n      keys = _.allKeys(obj);\n    } else {\n      iteratee = keyInObj;\n      keys = flatten(keys, false, false);\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  });\n\n  // Return a copy of the object without the blacklisted properties.\n  _.omit = restArguments(function(obj, keys) {\n    var iteratee = keys[0], context;\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n      if (keys.length > 1) context = keys[1];\n    } else {\n      keys = _.map(flatten(keys, false, false), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  });\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq, deepEq;\n  eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // `null` or `undefined` only equal to itself (strict comparison).\n    if (a == null || b == null) return false;\n    // `NaN`s are equivalent, but non-reflexive.\n    if (a !== a) return b !== b;\n    // Exhaust primitive checks\n    var type = typeof a;\n    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n    return deepEq(a, b, aStack, bStack);\n  };\n\n  // Internal recursive comparison function for `isEqual`.\n  deepEq = function(a, b, aStack, bStack) {\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN.\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n      case '[object Symbol]':\n        return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError, isMap, isWeakMap, isSet, isWeakSet.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\n  var nodelist = root.document && root.document.childNodes;\n  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return !_.isSymbol(obj) && isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`?\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && isNaN(obj);\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, path) {\n    if (!_.isArray(path)) {\n      return has(obj, path);\n    }\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      var key = path[i];\n      if (obj == null || !hasOwnProperty.call(obj, key)) {\n        return false;\n      }\n      obj = obj[key];\n    }\n    return !!length;\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  // Creates a function that, when passed an object, will traverse that object’s\n  // properties down the given `path`, specified as an array of keys or indexes.\n  _.property = function(path) {\n    if (!_.isArray(path)) {\n      return shallowProperty(path);\n    }\n    return function(obj) {\n      return deepGet(obj, path);\n    };\n  };\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    if (obj == null) {\n      return function(){};\n    }\n    return function(path) {\n      return !_.isArray(path) ? obj[path] : deepGet(obj, path);\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n  // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped.\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // Traverses the children of `obj` along `path`. If a child is a function, it\n  // is invoked with its parent as context. Returns the value of the final\n  // child, or `fallback` if any child is undefined.\n  _.result = function(obj, path, fallback) {\n    if (!_.isArray(path)) path = [path];\n    var length = path.length;\n    if (!length) {\n      return _.isFunction(fallback) ? fallback.call(obj) : fallback;\n    }\n    for (var i = 0; i < length; i++) {\n      var prop = obj == null ? void 0 : obj[path[i]];\n      if (prop === void 0) {\n        prop = fallback;\n        i = length; // Ensure we don't continue iterating.\n      }\n      obj = _.isFunction(prop) ? prop.call(obj) : prop;\n    }\n    return obj;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate: /<%([\\s\\S]+?)%>/g,\n    interpolate: /<%=([\\s\\S]+?)%>/g,\n    escape: /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\": \"'\",\n    '\\\\': '\\\\',\n    '\\r': 'r',\n    '\\n': 'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offset.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    var render;\n    try {\n      render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var chainResult = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return chainResult(this, func.apply(_, args));\n      };\n    });\n    return _;\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return chainResult(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return chainResult(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return String(this._wrapped);\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define == 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}());\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","'use strict';\n\nvar replace = String.prototype.replace;\nvar percentTwenties = /%20/g;\n\nvar Format = {\n    RFC1738: 'RFC1738',\n    RFC3986: 'RFC3986'\n};\n\nmodule.exports = {\n    'default': Format.RFC3986,\n    formatters: {\n        RFC1738: function (value) {\n            return replace.call(value, percentTwenties, '+');\n        },\n        RFC3986: function (value) {\n            return String(value);\n        }\n    },\n    RFC1738: Format.RFC1738,\n    RFC3986: Format.RFC3986\n};\n","'use strict';\n\nvar stringify = require('./stringify');\nvar parse = require('./parse');\nvar formats = require('./formats');\n\nmodule.exports = {\n    formats: formats,\n    parse: parse,\n    stringify: stringify\n};\n","'use strict';\n\nvar utils = require('./utils');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar defaults = {\n    allowDots: false,\n    allowEmptyArrays: false,\n    allowPrototypes: false,\n    allowSparse: false,\n    arrayLimit: 20,\n    charset: 'utf-8',\n    charsetSentinel: false,\n    comma: false,\n    decodeDotInKeys: false,\n    decoder: utils.decode,\n    delimiter: '&',\n    depth: 5,\n    duplicates: 'combine',\n    ignoreQueryPrefix: false,\n    interpretNumericEntities: false,\n    parameterLimit: 1000,\n    parseArrays: true,\n    plainObjects: false,\n    strictNullHandling: false\n};\n\nvar interpretNumericEntities = function (str) {\n    return str.replace(/&#(\\d+);/g, function ($0, numberStr) {\n        return String.fromCharCode(parseInt(numberStr, 10));\n    });\n};\n\nvar parseArrayValue = function (val, options) {\n    if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {\n        return val.split(',');\n    }\n\n    return val;\n};\n\n// This is what browsers will submit when the ✓ character occurs in an\n// application/x-www-form-urlencoded body and the encoding of the page containing\n// the form is iso-8859-1, or when the submitted form has an accept-charset\n// attribute of iso-8859-1. Presumably also with other charsets that do not contain\n// the ✓ character, such as us-ascii.\nvar isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('&#10003;')\n\n// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.\nvar charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')\n\nvar parseValues = function parseQueryStringValues(str, options) {\n    var obj = { __proto__: null };\n\n    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, '') : str;\n    cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');\n    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;\n    var parts = cleanStr.split(options.delimiter, limit);\n    var skipIndex = -1; // Keep track of where the utf8 sentinel was found\n    var i;\n\n    var charset = options.charset;\n    if (options.charsetSentinel) {\n        for (i = 0; i < parts.length; ++i) {\n            if (parts[i].indexOf('utf8=') === 0) {\n                if (parts[i] === charsetSentinel) {\n                    charset = 'utf-8';\n                } else if (parts[i] === isoSentinel) {\n                    charset = 'iso-8859-1';\n                }\n                skipIndex = i;\n                i = parts.length; // The eslint settings do not allow break;\n            }\n        }\n    }\n\n    for (i = 0; i < parts.length; ++i) {\n        if (i === skipIndex) {\n            continue;\n        }\n        var part = parts[i];\n\n        var bracketEqualsPos = part.indexOf(']=');\n        var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;\n\n        var key, val;\n        if (pos === -1) {\n            key = options.decoder(part, defaults.decoder, charset, 'key');\n            val = options.strictNullHandling ? null : '';\n        } else {\n            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');\n            val = utils.maybeMap(\n                parseArrayValue(part.slice(pos + 1), options),\n                function (encodedVal) {\n                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');\n                }\n            );\n        }\n\n        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {\n            val = interpretNumericEntities(val);\n        }\n\n        if (part.indexOf('[]=') > -1) {\n            val = isArray(val) ? [val] : val;\n        }\n\n        var existing = has.call(obj, key);\n        if (existing && options.duplicates === 'combine') {\n            obj[key] = utils.combine(obj[key], val);\n        } else if (!existing || options.duplicates === 'last') {\n            obj[key] = val;\n        }\n    }\n\n    return obj;\n};\n\nvar parseObject = function (chain, val, options, valuesParsed) {\n    var leaf = valuesParsed ? val : parseArrayValue(val, options);\n\n    for (var i = chain.length - 1; i >= 0; --i) {\n        var obj;\n        var root = chain[i];\n\n        if (root === '[]' && options.parseArrays) {\n            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))\n                ? []\n                : [].concat(leaf);\n        } else {\n            obj = options.plainObjects ? Object.create(null) : {};\n            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;\n            var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;\n            var index = parseInt(decodedRoot, 10);\n            if (!options.parseArrays && decodedRoot === '') {\n                obj = { 0: leaf };\n            } else if (\n                !isNaN(index)\n                && root !== decodedRoot\n                && String(index) === decodedRoot\n                && index >= 0\n                && (options.parseArrays && index <= options.arrayLimit)\n            ) {\n                obj = [];\n                obj[index] = leaf;\n            } else if (decodedRoot !== '__proto__') {\n                obj[decodedRoot] = leaf;\n            }\n        }\n\n        leaf = obj;\n    }\n\n    return leaf;\n};\n\nvar parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {\n    if (!givenKey) {\n        return;\n    }\n\n    // Transform dot notation to bracket notation\n    var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, '[$1]') : givenKey;\n\n    // The regex chunks\n\n    var brackets = /(\\[[^[\\]]*])/;\n    var child = /(\\[[^[\\]]*])/g;\n\n    // Get the parent\n\n    var segment = options.depth > 0 && brackets.exec(key);\n    var parent = segment ? key.slice(0, segment.index) : key;\n\n    // Stash the parent if it exists\n\n    var keys = [];\n    if (parent) {\n        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties\n        if (!options.plainObjects && has.call(Object.prototype, parent)) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n\n        keys.push(parent);\n    }\n\n    // Loop through children appending to the array until we hit depth\n\n    var i = 0;\n    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {\n        i += 1;\n        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n        keys.push(segment[1]);\n    }\n\n    // If there's a remainder, just add whatever is left\n\n    if (segment) {\n        keys.push('[' + key.slice(segment.index) + ']');\n    }\n\n    return parseObject(keys, val, options, valuesParsed);\n};\n\nvar normalizeParseOptions = function normalizeParseOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {\n        throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');\n    }\n\n    if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {\n        throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');\n    }\n\n    if (opts.decoder !== null && typeof opts.decoder !== 'undefined' && typeof opts.decoder !== 'function') {\n        throw new TypeError('Decoder has to be a function.');\n    }\n\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n    var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;\n\n    var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;\n\n    if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {\n        throw new TypeError('The duplicates option must be either combine, first, or last');\n    }\n\n    var allowDots = typeof opts.allowDots === 'undefined' ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n\n    return {\n        allowDots: allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,\n        allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,\n        arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,\n        decodeDotInKeys: typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,\n        decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,\n        delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n        // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n        depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,\n        duplicates: duplicates,\n        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n        interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n        parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,\n        parseArrays: opts.parseArrays !== false,\n        plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (str, opts) {\n    var options = normalizeParseOptions(opts);\n\n    if (str === '' || str === null || typeof str === 'undefined') {\n        return options.plainObjects ? Object.create(null) : {};\n    }\n\n    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;\n    var obj = options.plainObjects ? Object.create(null) : {};\n\n    // Iterate over the keys and setup the new object\n\n    var keys = Object.keys(tempObj);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');\n        obj = utils.merge(obj, newObj, options);\n    }\n\n    if (options.allowSparse === true) {\n        return obj;\n    }\n\n    return utils.compact(obj);\n};\n","'use strict';\n\nvar getSideChannel = require('side-channel');\nvar utils = require('./utils');\nvar formats = require('./formats');\nvar has = Object.prototype.hasOwnProperty;\n\nvar arrayPrefixGenerators = {\n    brackets: function brackets(prefix) {\n        return prefix + '[]';\n    },\n    comma: 'comma',\n    indices: function indices(prefix, key) {\n        return prefix + '[' + key + ']';\n    },\n    repeat: function repeat(prefix) {\n        return prefix;\n    }\n};\n\nvar isArray = Array.isArray;\nvar push = Array.prototype.push;\nvar pushToArray = function (arr, valueOrArray) {\n    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n};\n\nvar toISO = Date.prototype.toISOString;\n\nvar defaultFormat = formats['default'];\nvar defaults = {\n    addQueryPrefix: false,\n    allowDots: false,\n    allowEmptyArrays: false,\n    arrayFormat: 'indices',\n    charset: 'utf-8',\n    charsetSentinel: false,\n    delimiter: '&',\n    encode: true,\n    encodeDotInKeys: false,\n    encoder: utils.encode,\n    encodeValuesOnly: false,\n    format: defaultFormat,\n    formatter: formats.formatters[defaultFormat],\n    // deprecated\n    indices: false,\n    serializeDate: function serializeDate(date) {\n        return toISO.call(date);\n    },\n    skipNulls: false,\n    strictNullHandling: false\n};\n\nvar isNonNullishPrimitive = function isNonNullishPrimitive(v) {\n    return typeof v === 'string'\n        || typeof v === 'number'\n        || typeof v === 'boolean'\n        || typeof v === 'symbol'\n        || typeof v === 'bigint';\n};\n\nvar sentinel = {};\n\nvar stringify = function stringify(\n    object,\n    prefix,\n    generateArrayPrefix,\n    commaRoundTrip,\n    allowEmptyArrays,\n    strictNullHandling,\n    skipNulls,\n    encodeDotInKeys,\n    encoder,\n    filter,\n    sort,\n    allowDots,\n    serializeDate,\n    format,\n    formatter,\n    encodeValuesOnly,\n    charset,\n    sideChannel\n) {\n    var obj = object;\n\n    var tmpSc = sideChannel;\n    var step = 0;\n    var findFlag = false;\n    while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {\n        // Where object last appeared in the ref tree\n        var pos = tmpSc.get(object);\n        step += 1;\n        if (typeof pos !== 'undefined') {\n            if (pos === step) {\n                throw new RangeError('Cyclic object value');\n            } else {\n                findFlag = true; // Break while\n            }\n        }\n        if (typeof tmpSc.get(sentinel) === 'undefined') {\n            step = 0;\n        }\n    }\n\n    if (typeof filter === 'function') {\n        obj = filter(prefix, obj);\n    } else if (obj instanceof Date) {\n        obj = serializeDate(obj);\n    } else if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        obj = utils.maybeMap(obj, function (value) {\n            if (value instanceof Date) {\n                return serializeDate(value);\n            }\n            return value;\n        });\n    }\n\n    if (obj === null) {\n        if (strictNullHandling) {\n            return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;\n        }\n\n        obj = '';\n    }\n\n    if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n        if (encoder) {\n            var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);\n            return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];\n        }\n        return [formatter(prefix) + '=' + formatter(String(obj))];\n    }\n\n    var values = [];\n\n    if (typeof obj === 'undefined') {\n        return values;\n    }\n\n    var objKeys;\n    if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        // we need to join elements in\n        if (encodeValuesOnly && encoder) {\n            obj = utils.maybeMap(obj, encoder);\n        }\n        objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];\n    } else if (isArray(filter)) {\n        objKeys = filter;\n    } else {\n        var keys = Object.keys(obj);\n        objKeys = sort ? keys.sort(sort) : keys;\n    }\n\n    var encodedPrefix = encodeDotInKeys ? prefix.replace(/\\./g, '%2E') : prefix;\n\n    var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;\n\n    if (allowEmptyArrays && isArray(obj) && obj.length === 0) {\n        return adjustedPrefix + '[]';\n    }\n\n    for (var j = 0; j < objKeys.length; ++j) {\n        var key = objKeys[j];\n        var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];\n\n        if (skipNulls && value === null) {\n            continue;\n        }\n\n        var encodedKey = allowDots && encodeDotInKeys ? key.replace(/\\./g, '%2E') : key;\n        var keyPrefix = isArray(obj)\n            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix\n            : adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');\n\n        sideChannel.set(object, step);\n        var valueSideChannel = getSideChannel();\n        valueSideChannel.set(sentinel, sideChannel);\n        pushToArray(values, stringify(\n            value,\n            keyPrefix,\n            generateArrayPrefix,\n            commaRoundTrip,\n            allowEmptyArrays,\n            strictNullHandling,\n            skipNulls,\n            encodeDotInKeys,\n            generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,\n            filter,\n            sort,\n            allowDots,\n            serializeDate,\n            format,\n            formatter,\n            encodeValuesOnly,\n            charset,\n            valueSideChannel\n        ));\n    }\n\n    return values;\n};\n\nvar normalizeStringifyOptions = function normalizeStringifyOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {\n        throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');\n    }\n\n    if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {\n        throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');\n    }\n\n    if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {\n        throw new TypeError('Encoder has to be a function.');\n    }\n\n    var charset = opts.charset || defaults.charset;\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n\n    var format = formats['default'];\n    if (typeof opts.format !== 'undefined') {\n        if (!has.call(formats.formatters, opts.format)) {\n            throw new TypeError('Unknown format option provided.');\n        }\n        format = opts.format;\n    }\n    var formatter = formats.formatters[format];\n\n    var filter = defaults.filter;\n    if (typeof opts.filter === 'function' || isArray(opts.filter)) {\n        filter = opts.filter;\n    }\n\n    var arrayFormat;\n    if (opts.arrayFormat in arrayPrefixGenerators) {\n        arrayFormat = opts.arrayFormat;\n    } else if ('indices' in opts) {\n        arrayFormat = opts.indices ? 'indices' : 'repeat';\n    } else {\n        arrayFormat = defaults.arrayFormat;\n    }\n\n    if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {\n        throw new TypeError('`commaRoundTrip` must be a boolean, or absent');\n    }\n\n    var allowDots = typeof opts.allowDots === 'undefined' ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n\n    return {\n        addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,\n        allowDots: allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        arrayFormat: arrayFormat,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        commaRoundTrip: opts.commaRoundTrip,\n        delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,\n        encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,\n        encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,\n        encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,\n        encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n        filter: filter,\n        format: format,\n        formatter: formatter,\n        serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,\n        skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,\n        sort: typeof opts.sort === 'function' ? opts.sort : null,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (object, opts) {\n    var obj = object;\n    var options = normalizeStringifyOptions(opts);\n\n    var objKeys;\n    var filter;\n\n    if (typeof options.filter === 'function') {\n        filter = options.filter;\n        obj = filter('', obj);\n    } else if (isArray(options.filter)) {\n        filter = options.filter;\n        objKeys = filter;\n    }\n\n    var keys = [];\n\n    if (typeof obj !== 'object' || obj === null) {\n        return '';\n    }\n\n    var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];\n    var commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;\n\n    if (!objKeys) {\n        objKeys = Object.keys(obj);\n    }\n\n    if (options.sort) {\n        objKeys.sort(options.sort);\n    }\n\n    var sideChannel = getSideChannel();\n    for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n\n        if (options.skipNulls && obj[key] === null) {\n            continue;\n        }\n        pushToArray(keys, stringify(\n            obj[key],\n            key,\n            generateArrayPrefix,\n            commaRoundTrip,\n            options.allowEmptyArrays,\n            options.strictNullHandling,\n            options.skipNulls,\n            options.encodeDotInKeys,\n            options.encode ? options.encoder : null,\n            options.filter,\n            options.sort,\n            options.allowDots,\n            options.serializeDate,\n            options.format,\n            options.formatter,\n            options.encodeValuesOnly,\n            options.charset,\n            sideChannel\n        ));\n    }\n\n    var joined = keys.join(options.delimiter);\n    var prefix = options.addQueryPrefix === true ? '?' : '';\n\n    if (options.charsetSentinel) {\n        if (options.charset === 'iso-8859-1') {\n            // encodeURIComponent('&#10003;'), the \"numeric entity\" representation of a checkmark\n            prefix += 'utf8=%26%2310003%3B&';\n        } else {\n            // encodeURIComponent('✓')\n            prefix += 'utf8=%E2%9C%93&';\n        }\n    }\n\n    return joined.length > 0 ? prefix + joined : '';\n};\n","'use strict';\n\nvar formats = require('./formats');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar hexTable = (function () {\n    var array = [];\n    for (var i = 0; i < 256; ++i) {\n        array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());\n    }\n\n    return array;\n}());\n\nvar compactQueue = function compactQueue(queue) {\n    while (queue.length > 1) {\n        var item = queue.pop();\n        var obj = item.obj[item.prop];\n\n        if (isArray(obj)) {\n            var compacted = [];\n\n            for (var j = 0; j < obj.length; ++j) {\n                if (typeof obj[j] !== 'undefined') {\n                    compacted.push(obj[j]);\n                }\n            }\n\n            item.obj[item.prop] = compacted;\n        }\n    }\n};\n\nvar arrayToObject = function arrayToObject(source, options) {\n    var obj = options && options.plainObjects ? Object.create(null) : {};\n    for (var i = 0; i < source.length; ++i) {\n        if (typeof source[i] !== 'undefined') {\n            obj[i] = source[i];\n        }\n    }\n\n    return obj;\n};\n\nvar merge = function merge(target, source, options) {\n    /* eslint no-param-reassign: 0 */\n    if (!source) {\n        return target;\n    }\n\n    if (typeof source !== 'object') {\n        if (isArray(target)) {\n            target.push(source);\n        } else if (target && typeof target === 'object') {\n            if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {\n                target[source] = true;\n            }\n        } else {\n            return [target, source];\n        }\n\n        return target;\n    }\n\n    if (!target || typeof target !== 'object') {\n        return [target].concat(source);\n    }\n\n    var mergeTarget = target;\n    if (isArray(target) && !isArray(source)) {\n        mergeTarget = arrayToObject(target, options);\n    }\n\n    if (isArray(target) && isArray(source)) {\n        source.forEach(function (item, i) {\n            if (has.call(target, i)) {\n                var targetItem = target[i];\n                if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {\n                    target[i] = merge(targetItem, item, options);\n                } else {\n                    target.push(item);\n                }\n            } else {\n                target[i] = item;\n            }\n        });\n        return target;\n    }\n\n    return Object.keys(source).reduce(function (acc, key) {\n        var value = source[key];\n\n        if (has.call(acc, key)) {\n            acc[key] = merge(acc[key], value, options);\n        } else {\n            acc[key] = value;\n        }\n        return acc;\n    }, mergeTarget);\n};\n\nvar assign = function assignSingleSource(target, source) {\n    return Object.keys(source).reduce(function (acc, key) {\n        acc[key] = source[key];\n        return acc;\n    }, target);\n};\n\nvar decode = function (str, decoder, charset) {\n    var strWithoutPlus = str.replace(/\\+/g, ' ');\n    if (charset === 'iso-8859-1') {\n        // unescape never throws, no try...catch needed:\n        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n    }\n    // utf-8\n    try {\n        return decodeURIComponent(strWithoutPlus);\n    } catch (e) {\n        return strWithoutPlus;\n    }\n};\n\nvar limit = 1024;\n\n/* eslint operator-linebreak: [2, \"before\"] */\n\nvar encode = function encode(str, defaultEncoder, charset, kind, format) {\n    // This code was originally written by Brian White (mscdex) for the io.js core querystring library.\n    // It has been adapted here for stricter adherence to RFC 3986\n    if (str.length === 0) {\n        return str;\n    }\n\n    var string = str;\n    if (typeof str === 'symbol') {\n        string = Symbol.prototype.toString.call(str);\n    } else if (typeof str !== 'string') {\n        string = String(str);\n    }\n\n    if (charset === 'iso-8859-1') {\n        return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {\n            return '%26%23' + parseInt($0.slice(2), 16) + '%3B';\n        });\n    }\n\n    var out = '';\n    for (var j = 0; j < string.length; j += limit) {\n        var segment = string.length >= limit ? string.slice(j, j + limit) : string;\n        var arr = [];\n\n        for (var i = 0; i < segment.length; ++i) {\n            var c = segment.charCodeAt(i);\n            if (\n                c === 0x2D // -\n                || c === 0x2E // .\n                || c === 0x5F // _\n                || c === 0x7E // ~\n                || (c >= 0x30 && c <= 0x39) // 0-9\n                || (c >= 0x41 && c <= 0x5A) // a-z\n                || (c >= 0x61 && c <= 0x7A) // A-Z\n                || (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )\n            ) {\n                arr[arr.length] = segment.charAt(i);\n                continue;\n            }\n\n            if (c < 0x80) {\n                arr[arr.length] = hexTable[c];\n                continue;\n            }\n\n            if (c < 0x800) {\n                arr[arr.length] = hexTable[0xC0 | (c >> 6)]\n                    + hexTable[0x80 | (c & 0x3F)];\n                continue;\n            }\n\n            if (c < 0xD800 || c >= 0xE000) {\n                arr[arr.length] = hexTable[0xE0 | (c >> 12)]\n                    + hexTable[0x80 | ((c >> 6) & 0x3F)]\n                    + hexTable[0x80 | (c & 0x3F)];\n                continue;\n            }\n\n            i += 1;\n            c = 0x10000 + (((c & 0x3FF) << 10) | (segment.charCodeAt(i) & 0x3FF));\n\n            arr[arr.length] = hexTable[0xF0 | (c >> 18)]\n                + hexTable[0x80 | ((c >> 12) & 0x3F)]\n                + hexTable[0x80 | ((c >> 6) & 0x3F)]\n                + hexTable[0x80 | (c & 0x3F)];\n        }\n\n        out += arr.join('');\n    }\n\n    return out;\n};\n\nvar compact = function compact(value) {\n    var queue = [{ obj: { o: value }, prop: 'o' }];\n    var refs = [];\n\n    for (var i = 0; i < queue.length; ++i) {\n        var item = queue[i];\n        var obj = item.obj[item.prop];\n\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; ++j) {\n            var key = keys[j];\n            var val = obj[key];\n            if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {\n                queue.push({ obj: obj, prop: key });\n                refs.push(val);\n            }\n        }\n    }\n\n    compactQueue(queue);\n\n    return value;\n};\n\nvar isRegExp = function isRegExp(obj) {\n    return Object.prototype.toString.call(obj) === '[object RegExp]';\n};\n\nvar isBuffer = function isBuffer(obj) {\n    if (!obj || typeof obj !== 'object') {\n        return false;\n    }\n\n    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n};\n\nvar combine = function combine(a, b) {\n    return [].concat(a, b);\n};\n\nvar maybeMap = function maybeMap(val, fn) {\n    if (isArray(val)) {\n        var mapped = [];\n        for (var i = 0; i < val.length; i += 1) {\n            mapped.push(fn(val[i]));\n        }\n        return mapped;\n    }\n    return fn(val);\n};\n\nmodule.exports = {\n    arrayToObject: arrayToObject,\n    assign: assign,\n    combine: combine,\n    compact: compact,\n    decode: decode,\n    encode: encode,\n    isBuffer: isBuffer,\n    isRegExp: isRegExp,\n    maybeMap: maybeMap,\n    merge: merge\n};\n","/*\n * Copyright Joyent, Inc. and other Node contributors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to permit\n * persons to whom the Software is furnished to do so, subject to the\n * following conditions:\n *\n * The above copyright notice and this permission notice shall be included\n * in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n * USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\n'use strict';\n\nvar punycode = require('punycode');\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n/*\n * define these here so at least they only have to be\n * compiled once on the first module load.\n */\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n  portPattern = /:[0-9]*$/,\n\n  // Special case for a simple path URL\n  simplePathPattern = /^(\\/\\/?(?!\\/)[^?\\s]*)(\\?[^\\s]*)?$/,\n\n  /*\n   * RFC 2396: characters reserved for delimiting URLs.\n   * We actually just auto-escape these.\n   */\n  delims = [\n    '<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'\n  ],\n\n  // RFC 2396: characters not allowed for various reasons.\n  unwise = [\n    '{', '}', '|', '\\\\', '^', '`'\n  ].concat(delims),\n\n  // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n  autoEscape = ['\\''].concat(unwise),\n  /*\n   * Characters that are never ever allowed in a hostname.\n   * Note that any invalid chars are also handled, but these\n   * are the ones that are *expected* to be seen, so we fast-path\n   * them.\n   */\n  nonHostChars = [\n    '%', '/', '?', ';', '#'\n  ].concat(autoEscape),\n  hostEndingChars = [\n    '/', '?', '#'\n  ],\n  hostnameMaxLen = 255,\n  hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n  hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n  // protocols that can allow \"unsafe\" and \"unwise\" chars.\n  unsafeProtocol = {\n    javascript: true,\n    'javascript:': true\n  },\n  // protocols that never have a hostname.\n  hostlessProtocol = {\n    javascript: true,\n    'javascript:': true\n  },\n  // protocols that always contain a // bit.\n  slashedProtocol = {\n    http: true,\n    https: true,\n    ftp: true,\n    gopher: true,\n    file: true,\n    'http:': true,\n    'https:': true,\n    'ftp:': true,\n    'gopher:': true,\n    'file:': true\n  },\n  querystring = require('qs');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && typeof url === 'object' && url instanceof Url) { return url; }\n\n  var u = new Url();\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {\n  if (typeof url !== 'string') {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  /*\n   * Copy chrome, IE, opera backslash-handling behavior.\n   * Back slashes before the query string get converted to forward slashes\n   * See: https://code.google.com/p/chromium/issues/detail?id=25916\n   */\n  var queryIndex = url.indexOf('?'),\n    splitter = queryIndex !== -1 && queryIndex < url.indexOf('#') ? '?' : '#',\n    uSplit = url.split(splitter),\n    slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  /*\n   * trim before proceeding.\n   * This is to support parse stuff like \"  http://foo.com  \\n\"\n   */\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  /*\n   * figure out if it's got a host\n   * user@server is *always* interpreted as a hostname, and url\n   * resolution will treat //foo/bar as host=foo,path=bar because that's\n   * how the browser resolves relative URLs.\n   */\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@/]+@[^@/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] && (slashes || (proto && !slashedProtocol[proto]))) {\n\n    /*\n     * there's a hostname.\n     * the first instance of /, ?, ;, or # ends the host.\n     *\n     * If there is an @ in the hostname, then non-host chars *are* allowed\n     * to the left of the last @ sign, unless some host-ending character\n     * comes *before* the @-sign.\n     * URLs are obnoxious.\n     *\n     * ex:\n     * http://a@b@c/ => user:a@b host:c\n     * http://a@b?@c => user:a host:c path:/?@c\n     */\n\n    /*\n     * v0.12 TODO(isaacs): This is not quite how Chrome does things.\n     * Review our test case against browsers more comprehensively.\n     */\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) { hostEnd = hec; }\n    }\n\n    /*\n     * at this point, either we have an explicit point where the\n     * auth portion cannot go past, or the last @ char is the decider.\n     */\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      /*\n       * atSign must be in auth portion.\n       * http://a@b/c@d => host:b auth:a path:/c@d\n       */\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    /*\n     * Now we have a portion which is definitely the auth.\n     * Pull that off.\n     */\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) { hostEnd = hec; }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) { hostEnd = rest.length; }\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    /*\n     * we've indicated that there is a hostname,\n     * so even if it's empty, it has to be present.\n     */\n    this.hostname = this.hostname || '';\n\n    /*\n     * if hostname begins with [ and ends with ]\n     * assume that it's an IPv6 address.\n     */\n    var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) { continue; }\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              /*\n               * we replace non-ASCII char with a temporary placeholder\n               * we need this to make sure size of hostname is not\n               * broken by replacing non-ASCII by nothing\n               */\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      /*\n       * IDNA Support: Returns a punycoded representation of \"domain\".\n       * It only converts parts of the domain name that\n       * have non-ASCII characters, i.e. it doesn't matter if\n       * you call it with a domain that already is ASCII-only.\n       */\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    /*\n     * strip [ and ] from the hostname\n     * the host field still retains them, though\n     */\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  /*\n   * now rest is set to the post-host stuff.\n   * chop off any delim chars.\n   */\n  if (!unsafeProtocol[lowerProto]) {\n\n    /*\n     * First, make 100% sure that any \"autoEscape\" chars get\n     * escaped, even if encodeURIComponent doesn't think they\n     * need to be.\n     */\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1) { continue; }\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) { this.pathname = rest; }\n  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  // to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  /*\n   * ensure it's an object, and not a string url.\n   * If it's an obj, this is a no-op.\n   * this way, you can call url_format() on strings\n   * to clean up potentially wonky urls.\n   */\n  if (typeof obj === 'string') { obj = urlParse(obj); }\n  if (!(obj instanceof Url)) { return Url.prototype.format.call(obj); }\n  return obj.format();\n}\n\nUrl.prototype.format = function () {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n    pathname = this.pathname || '',\n    hash = this.hash || '',\n    host = false,\n    query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ? this.hostname : '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query && typeof this.query === 'object' && Object.keys(this.query).length) {\n    query = querystring.stringify(this.query, {\n      arrayFormat: 'repeat',\n      addQueryPrefix: false\n    });\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') { protocol += ':'; }\n\n  /*\n   * only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n   * unless they had them to begin with.\n   */\n  if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') { pathname = '/' + pathname; }\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') { hash = '#' + hash; }\n  if (search && search.charAt(0) !== '?') { search = '?' + search; }\n\n  pathname = pathname.replace(/[?#]/g, function (match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function (relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) { return relative; }\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function (relative) {\n  if (typeof relative === 'string') {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  /*\n   * hash is always overridden, no matter what.\n   * even href=\"\" will remove it.\n   */\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol') { result[rkey] = relative[rkey]; }\n    }\n\n    // urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {\n      result.pathname = '/';\n      result.path = result.pathname;\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    /*\n     * if it's a known url protocol, then changing\n     * the protocol does weird things\n     * first, if it's not file:, then we MUST have a host,\n     * and if there was a path\n     * to begin with, then we MUST have a path.\n     * if it is file:, then the host is dropped,\n     * because that's known to be hostless.\n     * anything else is assumed to be absolute.\n     */\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift())) { }\n      if (!relative.host) { relative.host = ''; }\n      if (!relative.hostname) { relative.hostname = ''; }\n      if (relPath[0] !== '') { relPath.unshift(''); }\n      if (relPath.length < 2) { relPath.unshift(''); }\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = result.pathname && result.pathname.charAt(0) === '/',\n    isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === '/',\n    mustEndAbs = isRelAbs || isSourceAbs || (result.host && relative.pathname),\n    removeAllDots = mustEndAbs,\n    srcPath = result.pathname && result.pathname.split('/') || [],\n    relPath = relative.pathname && relative.pathname.split('/') || [],\n    psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  /*\n   * if the url is a non-slashed url, then relative\n   * links like ../.. should be able\n   * to crawl up to the hostname, as well.  This is strange.\n   * result.protocol has already been set by now.\n   * Later on, put the first path part into the host field.\n   */\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') { srcPath[0] = result.host; } else { srcPath.unshift(result.host); }\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') { relPath[0] = relative.host; } else { relPath.unshift(relative.host); }\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = relative.host || relative.host === '' ? relative.host : result.host;\n    result.hostname = relative.hostname || relative.hostname === '' ? relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    /*\n     * it's relative\n     * throw away the existing file, and take the new path instead.\n     */\n    if (!srcPath) { srcPath = []; }\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (relative.search != null) {\n    /*\n     * just pull out the search.\n     * like href='?foo'.\n     * Put this after the other two cases because it simplifies the booleans\n     */\n    if (psychotic) {\n      result.host = srcPath.shift();\n      result.hostname = result.host;\n      /*\n       * occationaly the auth can get stuck only in host\n       * this especially happens in cases like\n       * url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n       */\n      var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.hostname = authInHost.shift();\n        result.host = result.hostname;\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    // to support http.request\n    if (result.pathname !== null || result.search !== null) {\n      result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    /*\n     * no path at all.  easy.\n     * we've already handled the other stuff above.\n     */\n    result.pathname = null;\n    // to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  /*\n   * if a url ENDs in . or .., then it must get a trailing slash.\n   * however, if it ends in anything else non-slashy,\n   * then it must NOT get a trailing slash.\n   */\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === '.' || last === '..') || last === '';\n\n  /*\n   * strip single dots, resolve double dots to parent dir\n   * if the path tries to go above the root, `up` ends up > 0\n   */\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' && (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' || (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = isAbsolute ? '' : srcPath.length ? srcPath.shift() : '';\n    result.host = result.hostname;\n    /*\n     * occationaly the auth can get stuck only in host\n     * this especially happens in cases like\n     * url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n     */\n    var authInHost = result.host && result.host.indexOf('@') > 0 ? result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.hostname = authInHost.shift();\n      result.host = result.hostname;\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (srcPath.length > 0) {\n    result.pathname = srcPath.join('/');\n  } else {\n    result.pathname = null;\n    result.path = null;\n  }\n\n  // to support request.http\n  if (result.pathname !== null || result.search !== null) {\n    result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function () {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) { this.hostname = host; }\n};\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]]\n  ]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\n// **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\nvar _clockseq;\n\n// Previous uuid creation time\nvar _lastMSecs = 0;\nvar _lastNSecs = 0;\n\n// See https://github.com/uuidjs/uuid for API details\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || [];\n\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;\n\n  // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n  if (node == null || clockseq == null) {\n    var seedBytes = rng();\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [\n        seedBytes[0] | 0x01,\n        seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]\n      ];\n    }\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  }\n\n  // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();\n\n  // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;\n\n  // Time since last uuid creation (in msecs)\n  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;\n\n  // Per 4.2.1.2, Bump clockseq on clock regression\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  }\n\n  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  }\n\n  // Per 4.2.1.2 Throw error if too many uuids are requested\n  if (nsecs >= 10000) {\n    throw new Error('uuid.v1(): Can\\'t create more than 10M uuids/sec');\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq;\n\n  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n  msecs += 12219292800000;\n\n  // `time_low`\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff;\n\n  // `time_mid`\n  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff;\n\n  // `time_high_and_version`\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n  b[i++] = tmh >>> 16 & 0xff;\n\n  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n  b[i++] = clockseq >>> 8 | 0x80;\n\n  // `clock_seq_low`\n  b[i++] = clockseq & 0xff;\n\n  // `node`\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf ? buf : bytesToUuid(b);\n}\n\nmodule.exports = v1;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar __DEV__ = process.env.NODE_ENV !== 'production';\n\nvar warning = function() {};\n\nif (__DEV__) {\n  var printWarning = function printWarning(format, args) {\n    var len = arguments.length;\n    args = new Array(len > 1 ? len - 1 : 0);\n    for (var key = 1; key < len; key++) {\n      args[key - 1] = arguments[key];\n    }\n    var argIndex = 0;\n    var message = 'Warning: ' +\n      format.replace(/%s/g, function() {\n        return args[argIndex++];\n      });\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  }\n\n  warning = function(condition, format, args) {\n    var len = arguments.length;\n    args = new Array(len > 2 ? len - 2 : 0);\n    for (var key = 2; key < len; key++) {\n      args[key - 2] = arguments[key];\n    }\n    if (format === undefined) {\n      throw new Error(\n          '`warning(condition, format, ...args)` requires a warning ' +\n          'message argument'\n      );\n    }\n    if (!condition) {\n      printWarning.apply(null, [format].concat(args));\n    }\n  };\n}\n\nmodule.exports = warning;\n","var e,t,n,i,r=function(e,t){return{name:e,value:void 0===t?-1:t,delta:0,entries:[],id:\"v2-\".concat(Date.now(),\"-\").concat(Math.floor(8999999999999*Math.random())+1e12)}},a=function(e,t){try{if(PerformanceObserver.supportedEntryTypes.includes(e)){if(\"first-input\"===e&&!(\"PerformanceEventTiming\"in self))return;var n=new PerformanceObserver((function(e){return e.getEntries().map(t)}));return n.observe({type:e,buffered:!0}),n}}catch(e){}},o=function(e,t){var n=function n(i){\"pagehide\"!==i.type&&\"hidden\"!==document.visibilityState||(e(i),t&&(removeEventListener(\"visibilitychange\",n,!0),removeEventListener(\"pagehide\",n,!0)))};addEventListener(\"visibilitychange\",n,!0),addEventListener(\"pagehide\",n,!0)},u=function(e){addEventListener(\"pageshow\",(function(t){t.persisted&&e(t)}),!0)},c=function(e,t,n){var i;return function(r){t.value>=0&&(r||n)&&(t.delta=t.value-(i||0),(t.delta||void 0===i)&&(i=t.value,e(t)))}},f=-1,s=function(){return\"hidden\"===document.visibilityState?0:1/0},m=function(){o((function(e){var t=e.timeStamp;f=t}),!0)},v=function(){return f<0&&(f=s(),m(),u((function(){setTimeout((function(){f=s(),m()}),0)}))),{get firstHiddenTime(){return f}}},d=function(e,t){var n,i=v(),o=r(\"FCP\"),f=function(e){\"first-contentful-paint\"===e.name&&(m&&m.disconnect(),e.startTime<i.firstHiddenTime&&(o.value=e.startTime,o.entries.push(e),n(!0)))},s=window.performance&&performance.getEntriesByName&&performance.getEntriesByName(\"first-contentful-paint\")[0],m=s?null:a(\"paint\",f);(s||m)&&(n=c(e,o,t),s&&f(s),u((function(i){o=r(\"FCP\"),n=c(e,o,t),requestAnimationFrame((function(){requestAnimationFrame((function(){o.value=performance.now()-i.timeStamp,n(!0)}))}))})))},p=!1,l=-1,h=function(e,t){p||(d((function(e){l=e.value})),p=!0);var n,i=function(t){l>-1&&e(t)},f=r(\"CLS\",0),s=0,m=[],v=function(e){if(!e.hadRecentInput){var t=m[0],i=m[m.length-1];s&&e.startTime-i.startTime<1e3&&e.startTime-t.startTime<5e3?(s+=e.value,m.push(e)):(s=e.value,m=[e]),s>f.value&&(f.value=s,f.entries=m,n())}},h=a(\"layout-shift\",v);h&&(n=c(i,f,t),o((function(){h.takeRecords().map(v),n(!0)})),u((function(){s=0,l=-1,f=r(\"CLS\",0),n=c(i,f,t)})))},T={passive:!0,capture:!0},y=new Date,g=function(i,r){e||(e=r,t=i,n=new Date,w(removeEventListener),E())},E=function(){if(t>=0&&t<n-y){var r={entryType:\"first-input\",name:e.type,target:e.target,cancelable:e.cancelable,startTime:e.timeStamp,processingStart:e.timeStamp+t};i.forEach((function(e){e(r)})),i=[]}},S=function(e){if(e.cancelable){var t=(e.timeStamp>1e12?new Date:performance.now())-e.timeStamp;\"pointerdown\"==e.type?function(e,t){var n=function(){g(e,t),r()},i=function(){r()},r=function(){removeEventListener(\"pointerup\",n,T),removeEventListener(\"pointercancel\",i,T)};addEventListener(\"pointerup\",n,T),addEventListener(\"pointercancel\",i,T)}(t,e):g(t,e)}},w=function(e){[\"mousedown\",\"keydown\",\"touchstart\",\"pointerdown\"].forEach((function(t){return e(t,S,T)}))},L=function(n,f){var s,m=v(),d=r(\"FID\"),p=function(e){e.startTime<m.firstHiddenTime&&(d.value=e.processingStart-e.startTime,d.entries.push(e),s(!0))},l=a(\"first-input\",p);s=c(n,d,f),l&&o((function(){l.takeRecords().map(p),l.disconnect()}),!0),l&&u((function(){var a;d=r(\"FID\"),s=c(n,d,f),i=[],t=-1,e=null,w(addEventListener),a=p,i.push(a),E()}))},b={},F=function(e,t){var n,i=v(),f=r(\"LCP\"),s=function(e){var t=e.startTime;t<i.firstHiddenTime&&(f.value=t,f.entries.push(e),n())},m=a(\"largest-contentful-paint\",s);if(m){n=c(e,f,t);var d=function(){b[f.id]||(m.takeRecords().map(s),m.disconnect(),b[f.id]=!0,n(!0))};[\"keydown\",\"click\"].forEach((function(e){addEventListener(e,d,{once:!0,capture:!0})})),o(d,!0),u((function(i){f=r(\"LCP\"),n=c(e,f,t),requestAnimationFrame((function(){requestAnimationFrame((function(){f.value=performance.now()-i.timeStamp,b[f.id]=!0,n(!0)}))}))}))}},P=function(e){var t,n=r(\"TTFB\");t=function(){try{var t=performance.getEntriesByType(\"navigation\")[0]||function(){var e=performance.timing,t={entryType:\"navigation\",startTime:0};for(var n in e)\"navigationStart\"!==n&&\"toJSON\"!==n&&(t[n]=Math.max(e[n]-e.navigationStart,0));return t}();if(n.value=n.delta=t.responseStart,n.value<0||n.value>performance.now())return;n.entries=[t],e(n)}catch(e){}},\"complete\"===document.readyState?setTimeout(t,0):addEventListener(\"load\",(function(){return setTimeout(t,0)}))};export{h as getCLS,d as getFCP,L as getFID,F as getLCP,P as getTTFB};\n"],"names":["setRTL","isRTL","_rtl","getRTL","undefined","document","documentElement","getAttribute","getStyleOptions","rtl","_stylesheet","InjectionMode","REUSE_STYLE_NODE","navigator","test","userAgent","_global","window","config","_rules","_preservedRules","_rulesToInsert","_counter","_keyToClassName","_onResetCallbacks","_classNameToArgs","this","_config","injectionMode","defaultPrefix","namespace","cspSettings","classNameCache","getInstance","_lastStyleElement","ownerDocument","fabricConfig","FabricConfig","Stylesheet","mergeStyles","setConfig","onReset","callback","push","getClassName","displayName","cacheClassName","className","key","args","rules","classNameFromKey","getClassNameCache","argsFromClassName","entry","insertedRulesFromClassName","insertRule","rule","preserve","element","_getStyleElement","sheet","cssRules","length","e","appendChild","createTextNode","onInsertRule","getRules","includePreservedRules","join","reset","forEach","resetKeys","_styleElement","_createStyleElement","requestAnimationFrame","head","styleElement","createElement","nodeToInsertBefore","setAttribute","nonce","nextElementSibling","placeholderStyleTag","_findPlaceholderStyleTag","childNodes","insertBefore","contains","querySelector","concatStyleSets","styleSets","subComponentStyles","mergedSet","workingSubcomponentStyles","currentSet","prop","hasOwnProperty","currentComponentStyles","subCompProp","mergedValue","currentValue","Array","isArray","Object","keys","mergedSubStyles","styleProps","map","styleFunctionOrObject","fontFace","font","_vendorSettings","autoPrefixNames","prefixRules","rulePairs","index","vendorSettings","doc","nav","toLowerCase","isWebkit","style","isMoz","indexOf","isOpera","isMs","getVendorSettings","name","value","NON_PIXEL_NUMBER_PROPS","provideUnits","isNonPixelProp","isVariableOrPrefixed","unit","LEFT","RIGHT","NAME_REPLACEMENTS","VALUE_REPLACEMENTS","rtlifyRules","options","replace","String","parts","split","flipQuad","partIndex","numberVal","parseInt","negateNum","getDisplayName","rootStyle","globalSelectorRegExp","expandSelector","newSelector","currentSelector","extractSelector","selector","__order","extractRules","selectorWithGlobals","replacementInfo","findGlobal","match","exec","v","trim","reverse","reduce","matchIndex","matchEndIndex","replacement","slice","expandCommaSeparatedGlobals","s","separatedSelector","stylesheet","currentRules","arg","expandedRules","propValue","selectors","expandQuads","getKeyForRules","serialized","hasProps","rulesForSelector","propName","repeatString","target","count","serializeRuleEntries","ruleEntries","allEntries","i","charAt","splice","styleToRegistration","registration","rulesToInsert","applyRegistration","specificityMultiplier","processedRule","hiddenContentStyle","position","width","height","margin","padding","border","overflow","_getGlobalClassNames","classNames","disableGlobalClassNames","styleSheet","acc","getGlobalClassNames","theme","HighContrastSelector","getEdgeChromiumNoHighContrastAdjustSelector","forcedColorAdjust","MsHighContrastAdjust","keyframes","timeline","rulesArray","packagesCache","_win","setVersion","packageName","packageVersion","packages","__packages__","_theme","_onThemeChangeCallbacks","ThemeSettingName","initializeThemeInCustomizations","win","getWindow","legacyTheme","depComments","palette","semanticColors","effects","lines","fonts","fontName","toUpperCase","_loadFonts","Customizations","applySettings","loadTheme","getSettings","props","state","isRendered","componentDidMount","delay","_timeoutId","setTimeout","setState","componentWillUnmount","clearTimeout","render","only","children","defaultProps","extractStyleParts","classes","objects","_processArgs","argsList","translatedArgs","mergeCssSets","classNameSet","concatenatedStyleSet","registrations","styleSetArea","concat","_isRTL","RTL_LOCAL_STORAGE_KEY","savedRTL","persistSetting","getDocument","body","_memoizedClassNames","retVal","classNamesFunction","Map","styleCalcCount","getClassNamesCount","currentMemoizedClassNames","useStaticStyles","__noStyleOverride__","current","disableCaching","_traverseMap","cacheSize","enableClassNameCacheFullWarning","console","warn","trace","clear","_traverseEdge","_normalizeValue","has","set","get","inputs","__cachedInputs__","getValue","defaultValue","globalSettings","_getGlobalSettings","setValue","callbacks","oldValue","changeDescription","id","addChangeListener","cb","__id__","_getCallbacks","removeChangeListener","globalObj","NO_CUSTOMIZATIONS","settings","scopedSettings","inCustomizerContext","_allSettings","GlobalSettings","_events","_raiseChange","applyScopedSettings","scopeName","properties","localSettings","localScopedSettings","globalScopedSettings","property","applyBatchedUpdates","code","suppressUpdate","_suppressUpdates","observe","onChange","unobserve","filter","rootElement","el","_window","defaultView","_isSSR","_language","STORAGE_KEY","getLanguage","persistenceType","savedLanguage","result","localStorage","getItem","_initializedStylesheetResets","_resetCounter","_emptyObject","empty","_dictionary","_weakMap","WeakMap","resetMemoizations","memoizeFunction","maxCacheSize","ignoreNullOrUndefinedResult","rootNode","localResetCounter","currentNode","_createNode","_normalizeArg","val","merge","_merge","source","circularReferences","isCircularReference","pop","toObjectMap","items","item","baseElementEvents","baseElementProperties","htmlElementProperties","audioProperties","buttonProperties","divProperties","getNativeProps","allowedPropNames","excludedPropNames","sessionStorage","setItem","data","CustomizerContext","customizations","useCustomizationSettings","forceUpdate","DefaultFields","styled","Component","baseStyles","getProps","customizable","pure","scope","fields","Wrapped","forwardedRef","styles","dir","additionalProps","cache","customizedStyles","concatenatedStyles","allStyles","concatStyleSetsWithProps","ref","rest","pureComponent","useUncontrolledProp","handler","wasPropRef","useRef","_useState","useState","stateValue","isProp","wasProp","useCallback","_len","arguments","_key","apply","root","self","g","global","previousUnderscore","_","ArrayProto","prototype","ObjProto","SymbolProto","Symbol","toString","nativeIsArray","nativeKeys","nativeCreate","create","Ctor","obj","_wrapped","exports","nodeType","module","VERSION","builtinIteratee","optimizeCb","func","context","argCount","call","collection","accumulator","iteratee","identity","isFunction","isObject","matcher","Infinity","restArguments","startIndex","Math","max","baseCreate","shallowProperty","path","deepGet","MAX_ARRAY_INDEX","pow","getLength","isArrayLike","each","collect","results","currentKey","createReduce","reducer","memo","initial","foldl","inject","reduceRight","foldr","find","detect","predicate","findIndex","findKey","select","list","reject","negate","every","all","some","any","includes","include","fromIndex","guard","values","invoke","contextPath","method","pluck","where","attrs","findWhere","computed","lastComputed","min","shuffle","sample","n","random","clone","last","rand","temp","sortBy","criteria","sort","left","right","a","b","group","behavior","partition","groupBy","indexBy","countBy","reStrSymbol","toArray","isString","size","pass","first","take","array","tail","drop","compact","Boolean","flatten","input","shallow","strict","output","idx","isArguments","j","len","without","otherArrays","difference","uniq","unique","isSorted","isBoolean","seen","union","arrays","intersection","argsLength","unzip","zip","object","createPredicateIndexFinder","findLastIndex","sortedIndex","low","high","mid","floor","createIndexFinder","predicateFind","isNaN","lastIndexOf","range","start","stop","step","ceil","chunk","executeBound","sourceFunc","boundFunc","callingContext","bind","TypeError","bound","callArgs","partial","boundArgs","placeholder","bindAll","Error","memoize","hasher","address","wait","defer","throttle","timeout","previous","later","leading","now","throttled","remaining","trailing","cancel","debounce","immediate","debounced","callNow","wrap","wrapper","compose","after","times","before","once","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","collectNonEnumProps","nonEnumIdx","constructor","proto","allKeys","mapObject","pairs","invert","functions","methods","names","createAssigner","keysFunc","defaults","l","extend","extendOwn","assign","eq","deepEq","keyInObj","pick","omit","tap","interceptor","isMatch","aStack","bStack","type","valueOf","areArrays","aCtor","bCtor","isEqual","isEmpty","isElement","nodelist","Int8Array","isFinite","isSymbol","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","unescapeMap","createEscaper","escaper","testRegexp","RegExp","replaceRegexp","string","escape","unescape","fallback","idCounter","uniqueId","prefix","templateSettings","evaluate","interpolate","noMatch","escapes","escapeRegExp","escapeChar","template","text","oldSettings","offset","variable","Function","argument","chain","instance","_chain","chainResult","mixin","toJSON","freeGlobal","punycode","maxInt","base","regexPunycode","regexNonASCII","regexSeparators","errors","stringFromCharCode","fromCharCode","error","RangeError","fn","mapDomain","ucs2decode","extra","counter","charCodeAt","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","k","baseMinusTMin","decode","out","basic","oldi","w","t","baseMinusT","codePoint","inputLength","bias","encode","handledCPCount","basicLength","m","q","handledCPCountPlusOne","qMinusT","percentTwenties","Format","formatters","RFC1738","RFC3986","stringify","parse","formats","utils","allowDots","allowEmptyArrays","allowPrototypes","allowSparse","arrayLimit","charset","charsetSentinel","comma","decodeDotInKeys","decoder","delimiter","depth","duplicates","ignoreQueryPrefix","interpretNumericEntities","parameterLimit","parseArrays","plainObjects","strictNullHandling","str","$0","numberStr","parseArrayValue","parseKeys","givenKey","valuesParsed","child","segment","parent","leaf","cleanRoot","decodedRoot","0","parseObject","opts","isRegExp","normalizeParseOptions","tempObj","__proto__","cleanStr","limit","skipIndex","part","bracketEqualsPos","pos","maybeMap","encodedVal","existing","combine","parseValues","newObj","getSideChannel","arrayPrefixGenerators","brackets","indices","repeat","pushToArray","arr","valueOrArray","toISO","toISOString","defaultFormat","addQueryPrefix","arrayFormat","encodeDotInKeys","encoder","encodeValuesOnly","format","formatter","serializeDate","date","skipNulls","sentinel","generateArrayPrefix","commaRoundTrip","sideChannel","tmpSc","findFlag","isBuffer","objKeys","encodedPrefix","adjustedPrefix","encodedKey","keyPrefix","valueSideChannel","normalizeStringifyOptions","joined","hexTable","arrayToObject","queue","o","refs","compacted","compactQueue","strWithoutPlus","decodeURIComponent","defaultEncoder","kind","c","mapped","mergeTarget","targetItem","Url","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","href","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","javascript","hostlessProtocol","slashedProtocol","http","https","ftp","gopher","file","querystring","urlParse","url","parseQueryString","slashesDenoteHost","u","queryIndex","splitter","uSplit","simplePath","substr","lowerProto","atSign","hostEnd","hec","parseHost","ipv6Hostname","hostparts","newpart","validParts","notHost","bit","unshift","toASCII","p","h","ae","esc","encodeURIComponent","qm","resolve","relative","resolveObject","rel","tkeys","tk","tkey","rkeys","rk","rkey","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","authInHost","hasTrailingSlash","up","isAbsolute","byteToHex","buf","bth","getRandomValues","crypto","msCrypto","rnds8","Uint8Array","rnds","r","_nodeId","_clockseq","rng","bytesToUuid","_lastMSecs","_lastNSecs","node","clockseq","seedBytes","msecs","nsecs","dt","tl","tmh","ii","warning","entries","PerformanceObserver","supportedEntryTypes","getEntries","buffered","visibilityState","removeEventListener","addEventListener","persisted","f","timeStamp","d","disconnect","startTime","firstHiddenTime","performance","getEntriesByName","hadRecentInput","takeRecords","T","passive","capture","y","E","entryType","cancelable","processingStart","S","L","F","P","getEntriesByType","timing","navigationStart","responseStart","readyState"],"sourceRoot":""}