{"version":3,"sources":["webpack://ViewerUtils/src/AlreadyConstructedMarker.js","webpack://ViewerUtils/src/Utilities.js","webpack://ViewerUtils/src/CustomElementInternals.js","webpack://ViewerUtils/src/DocumentConstructionObserver.js","webpack://ViewerUtils/src/Deferred.js","webpack://ViewerUtils/src/CustomElementRegistry.js","webpack://ViewerUtils/src/Patch/Native.js","webpack://ViewerUtils/src/Patch/Interface/ParentNode.js","webpack://ViewerUtils/src/custom-elements.js","webpack://ViewerUtils/src/Patch/HTMLElement.js","webpack://ViewerUtils/src/CustomElementState.js","webpack://ViewerUtils/src/Patch/Document.js","webpack://ViewerUtils/src/Patch/DocumentFragment.js","webpack://ViewerUtils/src/Patch/Node.js","webpack://ViewerUtils/src/Patch/Element.js","webpack://ViewerUtils/src/Patch/Interface/ChildNode.js","webpack://ViewerUtils/../mathworks/devel/bat/Bwiaui_artifacts/build/scm/mw-progress-indicator-project/release/mw-progress-indicator/src/main/ProgressIndicator.js","webpack://ViewerUtils/../mathworks/devel/bat/Bwiaui_artifacts/build/scm/mw-progress-indicator-project/release/mw-progress-indicator/src/main/enums/PropertyEnum.js","webpack://ViewerUtils/../mathworks/devel/bat/Bwiaui_artifacts/build/scm/mw-progress-indicator-project/release/mw-progress-indicator/src/main/enums/SizeEnum.js","webpack://ViewerUtils/../mathworks/devel/bat/Bwiaui_artifacts/build/scm/mw-progress-indicator-project/release/mw-progress-indicator/src/main/enums/TypeEnum.js","webpack://ViewerUtils/../mathworks/devel/bat/Bwiaui_artifacts/build/scm/mw-progress-indicator-project/release/mw-progress-indicator/src/main/view/SpinnerView.js","webpack://ViewerUtils/./build/ui/.target/dependencies/mw-widget-api/WidgetBase.js","webpack://ViewerUtils/./build/ui/.target/dependencies/mw-widget-api/_polyfills/_PatchedHtmlElement.js","webpack://ViewerUtils/./build/ui/.target/dependencies/mw-widget-api/_polyfills/_addEventListenerOptions.js","webpack://ViewerUtils/./build/ui/.target/dependencies/mw-widget-api/_polyfills/_createEvent.js","webpack://ViewerUtils/./build/ui/.target/dependencies/mw-widget-api/defineWidget.js","webpack://ViewerUtils/./internal/ui/src/js/ErrorUtils.js","webpack://ViewerUtils/./internal/ui/src/js/FetchUtils.js","webpack://ViewerUtils/./internal/ui/src/js/modelViewer.js","webpack://ViewerUtils/./node_modules/core-js/es/array/includes.js","webpack://ViewerUtils/./node_modules/core-js/es/object/values.js","webpack://ViewerUtils/./node_modules/core-js/features/array/includes.js","webpack://ViewerUtils/./node_modules/core-js/features/object/values.js","webpack://ViewerUtils/./node_modules/core-js/internals/a-function.js","webpack://ViewerUtils/./node_modules/core-js/internals/add-to-unscopables.js","webpack://ViewerUtils/./node_modules/core-js/internals/an-object.js","webpack://ViewerUtils/./node_modules/core-js/internals/array-includes.js","webpack://ViewerUtils/./node_modules/core-js/internals/classof-raw.js","webpack://ViewerUtils/./node_modules/core-js/internals/copy-constructor-properties.js","webpack://ViewerUtils/./node_modules/core-js/internals/create-non-enumerable-property.js","webpack://ViewerUtils/./node_modules/core-js/internals/create-property-descriptor.js","webpack://ViewerUtils/./node_modules/core-js/internals/descriptors.js","webpack://ViewerUtils/./node_modules/core-js/internals/document-create-element.js","webpack://ViewerUtils/./node_modules/core-js/internals/entry-unbind.js","webpack://ViewerUtils/./node_modules/core-js/internals/enum-bug-keys.js","webpack://ViewerUtils/./node_modules/core-js/internals/export.js","webpack://ViewerUtils/./node_modules/core-js/internals/fails.js","webpack://ViewerUtils/./node_modules/core-js/internals/function-bind-context.js","webpack://ViewerUtils/./node_modules/core-js/internals/get-built-in.js","webpack://ViewerUtils/./node_modules/core-js/internals/global.js","webpack://ViewerUtils/./node_modules/core-js/internals/has.js","webpack://ViewerUtils/./node_modules/core-js/internals/hidden-keys.js","webpack://ViewerUtils/./node_modules/core-js/internals/html.js","webpack://ViewerUtils/./node_modules/core-js/internals/ie8-dom-define.js","webpack://ViewerUtils/./node_modules/core-js/internals/indexed-object.js","webpack://ViewerUtils/./node_modules/core-js/internals/inspect-source.js","webpack://ViewerUtils/./node_modules/core-js/internals/internal-state.js","webpack://ViewerUtils/./node_modules/core-js/internals/is-forced.js","webpack://ViewerUtils/./node_modules/core-js/internals/is-object.js","webpack://ViewerUtils/./node_modules/core-js/internals/is-pure.js","webpack://ViewerUtils/./node_modules/core-js/internals/native-symbol.js","webpack://ViewerUtils/./node_modules/core-js/internals/native-weak-map.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-create.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-define-properties.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-define-property.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-get-own-property-names.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-keys-internal.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-keys.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-property-is-enumerable.js","webpack://ViewerUtils/./node_modules/core-js/internals/object-to-array.js","webpack://ViewerUtils/./node_modules/core-js/internals/own-keys.js","webpack://ViewerUtils/./node_modules/core-js/internals/path.js","webpack://ViewerUtils/./node_modules/core-js/internals/redefine.js","webpack://ViewerUtils/./node_modules/core-js/internals/require-object-coercible.js","webpack://ViewerUtils/./node_modules/core-js/internals/set-global.js","webpack://ViewerUtils/./node_modules/core-js/internals/shared-key.js","webpack://ViewerUtils/./node_modules/core-js/internals/shared-store.js","webpack://ViewerUtils/./node_modules/core-js/internals/shared.js","webpack://ViewerUtils/./node_modules/core-js/internals/to-absolute-index.js","webpack://ViewerUtils/./node_modules/core-js/internals/to-indexed-object.js","webpack://ViewerUtils/./node_modules/core-js/internals/to-integer.js","webpack://ViewerUtils/./node_modules/core-js/internals/to-length.js","webpack://ViewerUtils/./node_modules/core-js/internals/to-primitive.js","webpack://ViewerUtils/./node_modules/core-js/internals/uid.js","webpack://ViewerUtils/./node_modules/core-js/internals/use-symbol-as-uid.js","webpack://ViewerUtils/./node_modules/core-js/internals/well-known-symbol.js","webpack://ViewerUtils/./node_modules/core-js/modules/es.array.includes.js","webpack://ViewerUtils/./node_modules/core-js/modules/es.object.values.js","webpack://ViewerUtils/webpack/bootstrap","webpack://ViewerUtils/webpack/runtime/define property getters","webpack://ViewerUtils/webpack/runtime/global","webpack://ViewerUtils/webpack/runtime/hasOwnProperty shorthand","webpack://ViewerUtils/webpack/runtime/make namespace object","webpack://ViewerUtils/webpack/startup"],"names":["$jscompDefaultExport","AlreadyConstructedMarker","reservedTagList","Set","isValidCustomElementName$$module$$src$Utilities","isValidCustomElementName","reserved","validForm","test","isConnected$$module$$src$Utilities","isConnected","nativeValue","node","undefined","current","window","ShadowRoot","nextSiblingOrAncestorSibling$$module$$src$Utilities","nextSiblingOrAncestorSibling","nextSibling","walkDeepDescendantElements$$module$$src$Utilities","walkDeepDescendantElements","visitedImports","root","Node","element","callback","localName","importNode","child","shadowRoot","firstChild","setPropertyUnchecked$$module$$src$Utilities","setPropertyUnchecked","destination","CustomElementInternals","this","Map","addPatch","patchTree","patch","__CE_patched","i","connectTree","elements","upgradeElement","disconnectTree","patchAndUpgradeTree","options","upgrade","gatherElements","__CE_documentLoadHandled","clonedVisitedImports","ownerDocument","definition","localNameToDefinition","_localNameToDefinition","constructor","result","Error","e","observedAttributes","name","value","DocumentConstructionObserver","internals","doc","MutationObserver","childList","subtree","disconnect","Deferred","Promise","resolve","CustomElementRegistry","this._flushCallback","connectedCallback","disconnectedCallback","attributeChangedCallback","readyState","mutations","addedNodes","j","define","TypeError","SyntaxError","getCallback","callbackValue","prototype","adoptedCallback","constructionStack","setDefinition","_flush","pendingDefinitions","elementsWithStableDefinitions","elementsWithPendingDefinitions","pendingElements","pendingUpgradableElements","deferred","get","whenDefined","reject","prior","_promise","inner","Document_createElement","Document","Document_createElementNS","Document_importNode","Document_prepend","Document_append","DocumentFragment_prepend","DocumentFragment","DocumentFragment_append","Node_cloneNode","Node_appendChild","Node_insertBefore","Node_removeChild","Node_replaceChild","Node_textContent","getOwnPropertyDescriptor","Element_attachShadow","Element","Element_innerHTML","Object","Element_getAttribute","Element_setAttribute","Element_removeAttribute","Element_getAttributeNS","Element_setAttributeNS","Element_removeAttributeNS","Element_insertAdjacentElement","Element_prepend","Element_append","Element_before","Element_after","Element_replaceWith","Element_remove","HTMLElement","HTMLElement_innerHTML","HTMLElement_insertAdjacentElement","$jscompDefaultExport$$module$$src$Patch$Interface$ParentNode","appendPrependPatch","flattenedNodes","connectedElements","builtInMethod","builtIn","priorCustomElements","_constructorToDefinition","length","$jscompDefaultExport$$module$$src$Patch$Native.Document_createElement.call","setPrototypeOf","custom","lastIndex","$jscompDefaultExport$$module$$src$Patch$Native.HTMLElement","clone","$jscompDefaultExport$$module$$src$Patch$Native.Document_importNode.call","NS_HTML","$jscompDefaultExport$$module$$src$Patch$Native.Document_createElementNS.call","prepend","append","$jscompDefaultExport$$module$$src$Patch$Node","patch_textContent","enumerable","baseDescriptor","configurable","set","removedNodes","childNodes","childNodesLength","Array","insertedNodes","slice","apply","$jscompDefaultExport$$module$$src$Patch$Native.Node_insertBefore.call","nodeWasConnected","nativeResult","$jscompDefaultExport$$module$$src$Patch$Native.Node_appendChild.call","$jscompDefaultExport$$module$$src$Patch$Native.Node_cloneNode.call","$jscompDefaultExport$$module$$src$Patch$Native.Node_removeChild.call","nodeToInsert","$jscompDefaultExport$$module$$src$Patch$Native.Node_replaceChild.call","nodeToInsertWasConnected","thisIsConnected","$jscompDefaultExport$$module$$src$Patch$Native.Node_textContent","$jscompDefaultExport$$module$$src$Patch$Native.Node_textContent.get","parts","document","createTextNode","patch_innerHTML","removedElements","patch_insertAdjacentElement","wasConnected","insertedElement","baseMethod","$jscompDefaultExport$$module$$src$Patch$Native.Element_attachShadow","$jscompDefaultExport$$module$$src$Patch$Native.Element_attachShadow.call","$jscompDefaultExport$$module$$src$Patch$Native.Element_innerHTML","$jscompDefaultExport$$module$$src$Patch$Native.Element_innerHTML.get","$jscompDefaultExport$$module$$src$Patch$Native.HTMLElement_innerHTML","$jscompDefaultExport$$module$$src$Patch$Native.HTMLElement_innerHTML.get","isTemplate","content","rawElement","assignedValue","container","$jscompDefaultExport$$module$$src$Patch$Native.Element_setAttribute.call","oldValue","$jscompDefaultExport$$module$$src$Patch$Native.Element_getAttribute.call","newValue","$jscompDefaultExport$$module$$src$Patch$Native.Element_setAttributeNS.call","$jscompDefaultExport$$module$$src$Patch$Native.Element_getAttributeNS.call","$jscompDefaultExport$$module$$src$Patch$Native.Element_removeAttribute.call","$jscompDefaultExport$$module$$src$Patch$Native.Element_removeAttributeNS.call","$jscompDefaultExport$$module$$src$Patch$Native.HTMLElement_insertAdjacentElement","$jscompDefaultExport$$module$$src$Patch$Native.Element_insertAdjacentElement","console","warn","$jscompDefaultExport$$module$$src$Patch$Interface$ChildNode","beforeAfterPatch","$jscompDefaultExport$$module$$src$Patch$Native.Element_before","$jscompDefaultExport$$module$$src$Patch$Native.Element_replaceWith","nodes","$jscompDefaultExport$$module$$src$Patch$Native.Element_remove","call","customElements","defineWidget","WidgetBase","SpinnerView","TypeEnum","SizeEnum","PropertyEnum","baseClass","widgetClass","createElement","hasAttribute","strokeGap","strokeDash","view","createWidget","svg","valueLength","_artNode","children","cloneNode","getElementsByClassName","hexaColor","sizes","values","includes","property","toLowerCase","parseFloat","isNaN","isValidColor","_isHexaColor","getAttribute","customSize","removeAttribute","val","freeze","VALUE","SIZE","TYPE","COLOR","BORDER","XSMALL","SMALL","MEDIUM","LARGE","XLARGE","SPINNER","circleAttrs","size","outerRadius","strokeWidth","innerRadius","radius","cx","cy","dummyDiv","svgNode","createElementNS","innerGroup","progressIndicatorGutter","progressIndicatorArt","progressIndicatorArtTwo","outerGroup","circleOuterBoundary","outerDValue","circleInnerBoundary","innerDValue","Math","_createClass","defineProperties","target","props","descriptor","writable","defineProperty","key","Constructor","protoProps","staticProps","_addEventListenerOptions","_createEvent","_PatchedHtmlElement","noOp","_PatchedHtmlElement2","instance","_classCallCheck","_this","self","ReferenceError","_possibleConstructorReturn","__proto__","getPrototypeOf","_root","createDocumentFragment","subClass","superClass","create","_inherits","_connectedCallbackRan","init","appendChild","eventName","data","arguments","dispatchEvent","createEvent","eventObj","getOptions","addEventListener","removeFn","removeEventListener","bind","remove","O","gPO","sPO","construct","_typeof","Symbol","iterator","obj","_fixBabelExtend","o","p","Reflect","Parent","args","Class","a","push","PatchedHtmlElement","__CE_hasRegistry","_HTMLElement3","_class","_HTMLElement2","passiveSupported","err","capture","once","passive","hasCustomEventConstructor","CustomEvent","bubbles","cancelable","detail","event","initCustomEvent","widgetDefinition","substring","WidgetClass","_observedAttributes","params","widget","prop","hasOwnProperty","hideSpinner","querySelector","style","visibility","showErrorPage","display","innerHTML","showTimeoutPage","_fetchArtifact","async","contextRoot","url","filename","mwtypeMsg","timeout","controller","AbortController","setTimeout","abort","poll","method","mode","signal","headers","credentials","body","JSON","stringify","response","fetch","status","message","json","mwtype","faultId","fetchData","fetchModelArtifactURL","require","fetchUtils","errorUtils","module","exports","entryUnbind","path","parent","it","String","wellKnownSymbol","definePropertyModule","UNSCOPABLES","ArrayPrototype","f","isObject","toIndexedObject","toLength","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","index","indexOf","toString","has","ownKeys","getOwnPropertyDescriptorModule","source","keys","DESCRIPTORS","createPropertyDescriptor","object","bitmap","fails","global","EXISTS","Function","CONSTRUCTOR","METHOD","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","noTargetGet","forced","sham","exec","error","aFunction","fn","that","b","c","variable","namespace","check","globalThis","g","getBuiltIn","classof","split","propertyIsEnumerable","store","functionToString","inspectSource","NATIVE_WEAK_MAP","objectHas","shared","sharedKey","hiddenKeys","WeakMap","state","wmget","wmhas","wmset","metadata","facade","STATE","enforce","getterFor","type","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","replace","getOwnPropertySymbols","activeXDocument","anObject","enumBugKeys","html","documentCreateElement","IE_PROTO","EmptyConstructor","scriptTag","LT","NullProtoObject","domain","ActiveXObject","iframeDocument","iframe","write","close","temp","parentWindow","NullProtoObjectViaActiveX","src","contentWindow","open","F","Properties","objectKeys","IE8_DOM_DEFINE","toPrimitive","nativeDefineProperty","P","Attributes","propertyIsEnumerableModule","nativeGetOwnPropertyDescriptor","internalObjectKeys","concat","getOwnPropertyNames","names","nativePropertyIsEnumerable","NASHORN_BUG","1","V","TO_ENTRIES","entries","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","InternalStateModule","getInternalState","enforceInternalState","TEMPLATE","unsafe","simple","join","uid","SHARED","IS_PURE","version","copyright","toInteger","max","min","integer","IndexedObject","requireObjectCoercible","ceil","floor","argument","input","PREFERRED_STRING","valueOf","id","postfix","random","NATIVE_SYMBOL","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","$","$includes","addToUnscopables","proto","$values","__webpack_module_cache__","__webpack_require__","moduleId","__webpack_modules__","d","r","toStringTag","__webpack_exports__"],"mappings":"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","file":"modelviewerutils.min.js","sourcesContent":["/**\n * This class exists only to work around Closure's lack of a way to describe\n * singletons. It represents the 'already constructed marker' used in custom\n * element construction stacks.\n *\n * https://html.spec.whatwg.org/#concept-already-constructed-marker\n */\nclass AlreadyConstructedMarker {}\n\nexport default new AlreadyConstructedMarker();\n","const reservedTagList = new Set([\n  'annotation-xml',\n  'color-profile',\n  'font-face',\n  'font-face-src',\n  'font-face-uri',\n  'font-face-format',\n  'font-face-name',\n  'missing-glyph',\n]);\n\n/**\n * @param {string} localName\n * @returns {boolean}\n */\nexport function isValidCustomElementName(localName) {\n  const reserved = reservedTagList.has(localName);\n  const validForm = /^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/.test(localName);\n  return !reserved && validForm;\n}\n\n/**\n * @private\n * @param {!Node} node\n * @return {boolean}\n */\nexport function isConnected(node) {\n  // Use `Node#isConnected`, if defined.\n  const nativeValue = node.isConnected;\n  if (nativeValue !== undefined) {\n    return nativeValue;\n  }\n\n  /** @type {?Node|undefined} */\n  let current = node;\n  while (current && !(current.__CE_isImportDocument || current instanceof Document)) {\n    current = current.parentNode || (window.ShadowRoot && current instanceof ShadowRoot ? current.host : undefined);\n  }\n  return !!(current && (current.__CE_isImportDocument || current instanceof Document));\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextSiblingOrAncestorSibling(root, start) {\n  let node = start;\n  while (node && node !== root && !node.nextSibling) {\n    node = node.parentNode;\n  }\n  return (!node || node === root) ? null : node.nextSibling;\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextNode(root, start) {\n  return start.firstChild ? start.firstChild : nextSiblingOrAncestorSibling(root, start);\n}\n\n/**\n * @param {!Node} root\n * @param {!function(!Element)} callback\n * @param {!Set<Node>=} visitedImports\n */\nexport function walkDeepDescendantElements(root, callback, visitedImports = new Set()) {\n  let node = root;\n  while (node) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const element = /** @type {!Element} */(node);\n\n      callback(element);\n\n      const localName = element.localName;\n      if (localName === 'link' && element.getAttribute('rel') === 'import') {\n        // If this import (polyfilled or not) has it's root node available,\n        // walk it.\n        const importNode = /** @type {!Node} */ (element.import);\n        if (importNode instanceof Node && !visitedImports.has(importNode)) {\n          // Prevent multiple walks of the same import root.\n          visitedImports.add(importNode);\n\n          for (let child = importNode.firstChild; child; child = child.nextSibling) {\n            walkDeepDescendantElements(child, callback, visitedImports);\n          }\n        }\n\n        // Ignore descendants of import links to prevent attempting to walk the\n        // elements created by the HTML Imports polyfill that we just walked\n        // above.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      } else if (localName === 'template') {\n        // Ignore descendants of templates. There shouldn't be any descendants\n        // because they will be moved into `.content` during construction in\n        // browsers that support template but, in case they exist and are still\n        // waiting to be moved by a polyfill, they will be ignored.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      }\n\n      // Walk shadow roots.\n      const shadowRoot = element.__CE_shadowRoot;\n      if (shadowRoot) {\n        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {\n          walkDeepDescendantElements(child, callback, visitedImports);\n        }\n      }\n    }\n\n    node = nextNode(root, node);\n  }\n}\n\n/**\n * Used to suppress Closure's \"Modifying the prototype is only allowed if the\n * constructor is in the same scope\" warning without using\n * `@suppress {newCheckTypes, duplicate}` because `newCheckTypes` is too broad.\n *\n * @param {!Object} destination\n * @param {string} name\n * @param {*} value\n */\nexport function setPropertyUnchecked(destination, name, value) {\n  destination[name] = value;\n}\n","import * as Utilities from './Utilities.js';\nimport CEState from './CustomElementState.js';\n\nexport default class CustomElementInternals {\n  constructor() {\n    /** @type {!Map<string, !CustomElementDefinition>} */\n    this._localNameToDefinition = new Map();\n\n    /** @type {!Map<!Function, !CustomElementDefinition>} */\n    this._constructorToDefinition = new Map();\n\n    /** @type {!Array<!function(!Node)>} */\n    this._patches = [];\n\n    /** @type {boolean} */\n    this._hasPatches = false;\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!CustomElementDefinition} definition\n   */\n  setDefinition(localName, definition) {\n    this._localNameToDefinition.set(localName, definition);\n    this._constructorToDefinition.set(definition.constructor, definition);\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!CustomElementDefinition|undefined}\n   */\n  localNameToDefinition(localName) {\n    return this._localNameToDefinition.get(localName);\n  }\n\n  /**\n   * @param {!Function} constructor\n   * @return {!CustomElementDefinition|undefined}\n   */\n  constructorToDefinition(constructor) {\n    return this._constructorToDefinition.get(constructor);\n  }\n\n  /**\n   * @param {!function(!Node)} listener\n   */\n  addPatch(listener) {\n    this._hasPatches = true;\n    this._patches.push(listener);\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patchTree(node) {\n    if (!this._hasPatches) return;\n\n    Utilities.walkDeepDescendantElements(node, element => this.patch(element));\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patch(node) {\n    if (!this._hasPatches) return;\n\n    if (node.__CE_patched) return;\n    node.__CE_patched = true;\n\n    for (let i = 0; i < this._patches.length; i++) {\n      this._patches[i](node);\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  connectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.connectedCallback(element);\n      } else {\n        this.upgradeElement(element);\n      }\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  disconnectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.disconnectedCallback(element);\n      }\n    }\n  }\n\n  /**\n   * Upgrades all uncustomized custom elements at and below a root node for\n   * which there is a definition. When custom element reaction callbacks are\n   * assumed to be called synchronously (which, by the current DOM / HTML spec\n   * definitions, they are *not*), callbacks for both elements customized\n   * synchronously by the parser and elements being upgraded occur in the same\n   * relative order.\n   *\n   * NOTE: This function, when used to simulate the construction of a tree that\n   * is already created but not customized (i.e. by the parser), does *not*\n   * prevent the element from reading the 'final' (true) state of the tree. For\n   * example, the element, during truly synchronous parsing / construction would\n   * see that it contains no children as they have not yet been inserted.\n   * However, this function does not modify the tree, the element will\n   * (incorrectly) have children. Additionally, self-modification restrictions\n   * for custom element constructors imposed by the DOM spec are *not* enforced.\n   *\n   *\n   * The following nested list shows the steps extending down from the HTML\n   * spec's parsing section that cause elements to be synchronously created and\n   * upgraded:\n   *\n   * The \"in body\" insertion mode:\n   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n   * - Switch on token:\n   *   .. other cases ..\n   *   -> Any other start tag\n   *      - [Insert an HTML element](below) for the token.\n   *\n   * Insert an HTML element:\n   * https://html.spec.whatwg.org/multipage/syntax.html#insert-an-html-element\n   * - Insert a foreign element for the token in the HTML namespace:\n   *   https://html.spec.whatwg.org/multipage/syntax.html#insert-a-foreign-element\n   *   - Create an element for a token:\n   *     https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token\n   *     - Will execute script flag is true?\n   *       - (Element queue pushed to the custom element reactions stack.)\n   *     - Create an element:\n   *       https://dom.spec.whatwg.org/#concept-create-element\n   *       - Sync CE flag is true?\n   *         - Constructor called.\n   *         - Self-modification restrictions enforced.\n   *       - Sync CE flag is false?\n   *         - (Upgrade reaction enqueued.)\n   *     - Attributes appended to element.\n   *       (`attributeChangedCallback` reactions enqueued.)\n   *     - Will execute script flag is true?\n   *       - (Element queue popped from the custom element reactions stack.\n   *         Reactions in the popped stack are invoked.)\n   *   - (Element queue pushed to the custom element reactions stack.)\n   *   - Insert the element:\n   *     https://dom.spec.whatwg.org/#concept-node-insert\n   *     - Shadow-including descendants are connected. During parsing\n   *       construction, there are no shadow-*excluding* descendants.\n   *       However, the constructor may have validly attached a shadow\n   *       tree to itself and added descendants to that shadow tree.\n   *       (`connectedCallback` reactions enqueued.)\n   *   - (Element queue popped from the custom element reactions stack.\n   *     Reactions in the popped stack are invoked.)\n   *\n   * @param {!Node} root\n   * @param {{\n   *   visitedImports: (!Set<!Node>|undefined),\n   *   upgrade: (!function(!Element)|undefined),\n   * }=} options\n   */\n  patchAndUpgradeTree(root, options = {}) {\n    const visitedImports = options.visitedImports || new Set();\n    const upgrade = options.upgrade || (element => this.upgradeElement(element));\n\n    const elements = [];\n\n    const gatherElements = element => {\n      if (element.localName === 'link' && element.getAttribute('rel') === 'import') {\n        // The HTML Imports polyfill sets a descendant element of the link to\n        // the `import` property, specifically this is *not* a Document.\n        const importNode = /** @type {?Node} */ (element.import);\n\n        if (importNode instanceof Node) {\n          importNode.__CE_isImportDocument = true;\n          // Connected links are associated with the registry.\n          importNode.__CE_hasRegistry = true;\n        }\n\n        if (importNode && importNode.readyState === 'complete') {\n          importNode.__CE_documentLoadHandled = true;\n        } else {\n          // If this link's import root is not available, its contents can't be\n          // walked. Wait for 'load' and walk it when it's ready.\n          element.addEventListener('load', () => {\n            const importNode = /** @type {!Node} */ (element.import);\n\n            if (importNode.__CE_documentLoadHandled) return;\n            importNode.__CE_documentLoadHandled = true;\n\n            // Clone the `visitedImports` set that was populated sync during\n            // the `patchAndUpgradeTree` call that caused this 'load' handler to\n            // be added. Then, remove *this* link's import node so that we can\n            // walk that import again, even if it was partially walked later\n            // during the same `patchAndUpgradeTree` call.\n            const clonedVisitedImports = new Set(visitedImports);\n            clonedVisitedImports.delete(importNode);\n\n            this.patchAndUpgradeTree(importNode, {visitedImports: clonedVisitedImports, upgrade});\n          });\n        }\n      } else {\n        elements.push(element);\n      }\n    };\n\n    // `walkDeepDescendantElements` populates (and internally checks against)\n    // `visitedImports` when traversing a loaded import.\n    Utilities.walkDeepDescendantElements(root, gatherElements, visitedImports);\n\n    if (this._hasPatches) {\n      for (let i = 0; i < elements.length; i++) {\n        this.patch(elements[i]);\n      }\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      upgrade(elements[i]);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  upgradeElement(element) {\n    const currentState = element.__CE_state;\n    if (currentState !== undefined) return;\n\n    // Prevent elements created in documents without a browsing context from\n    // upgrading.\n    //\n    // https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition\n    //   \"If document does not have a browsing context, return null.\"\n    //\n    // https://html.spec.whatwg.org/multipage/window-object.html#dom-document-defaultview\n    //   \"The defaultView IDL attribute of the Document interface, on getting,\n    //   must return this Document's browsing context's WindowProxy object, if\n    //   this Document has an associated browsing context, or null otherwise.\"\n    const ownerDocument = element.ownerDocument;\n    if (\n      !ownerDocument.defaultView &&\n      !(ownerDocument.__CE_isImportDocument && ownerDocument.__CE_hasRegistry)\n    ) return;\n\n    const definition = this.localNameToDefinition(element.localName);\n    if (!definition) return;\n\n    definition.constructionStack.push(element);\n\n    const constructor = definition.constructor;\n    try {\n      try {\n        let result = new (constructor)();\n        if (result !== element) {\n          throw new Error('The custom element constructor did not produce the element being upgraded.');\n        }\n      } finally {\n        definition.constructionStack.pop();\n      }\n    } catch (e) {\n      element.__CE_state = CEState.failed;\n      throw e;\n    }\n\n    element.__CE_state = CEState.custom;\n    element.__CE_definition = definition;\n\n    if (definition.attributeChangedCallback) {\n      const observedAttributes = definition.observedAttributes;\n      for (let i = 0; i < observedAttributes.length; i++) {\n        const name = observedAttributes[i];\n        const value = element.getAttribute(name);\n        if (value !== null) {\n          this.attributeChangedCallback(element, name, null, value, null);\n        }\n      }\n    }\n\n    if (Utilities.isConnected(element)) {\n      this.connectedCallback(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  connectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.connectedCallback) {\n      definition.connectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  disconnectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.disconnectedCallback) {\n      definition.disconnectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   * @param {string} name\n   * @param {?string} oldValue\n   * @param {?string} newValue\n   * @param {?string} namespace\n   */\n  attributeChangedCallback(element, name, oldValue, newValue, namespace) {\n    const definition = element.__CE_definition;\n    if (\n      definition.attributeChangedCallback &&\n      definition.observedAttributes.indexOf(name) > -1\n    ) {\n      definition.attributeChangedCallback.call(element, name, oldValue, newValue, namespace);\n    }\n  }\n}\n","import CustomElementInternals from './CustomElementInternals.js';\n\nexport default class DocumentConstructionObserver {\n  constructor(internals, doc) {\n    /**\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @type {!Document}\n     */\n    this._document = doc;\n\n    /**\n     * @type {MutationObserver|undefined}\n     */\n    this._observer = undefined;\n\n\n    // Simulate tree construction for all currently accessible nodes in the\n    // document.\n    this._internals.patchAndUpgradeTree(this._document);\n\n    if (this._document.readyState === 'loading') {\n      this._observer = new MutationObserver(this._handleMutations.bind(this));\n\n      // Nodes created by the parser are given to the observer *before* the next\n      // task runs. Inline scripts are run in a new task. This means that the\n      // observer will be able to handle the newly parsed nodes before the inline\n      // script is run.\n      this._observer.observe(this._document, {\n        childList: true,\n        subtree: true,\n      });\n    }\n  }\n\n  disconnect() {\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  /**\n   * @param {!Array<!MutationRecord>} mutations\n   */\n  _handleMutations(mutations) {\n    // Once the document's `readyState` is 'interactive' or 'complete', all new\n    // nodes created within that document will be the result of script and\n    // should be handled by patching.\n    const readyState = this._document.readyState;\n    if (readyState === 'interactive' || readyState === 'complete') {\n      this.disconnect();\n    }\n\n    for (let i = 0; i < mutations.length; i++) {\n      const addedNodes = mutations[i].addedNodes;\n      for (let j = 0; j < addedNodes.length; j++) {\n        const node = addedNodes[j];\n        this._internals.patchAndUpgradeTree(node);\n      }\n    }\n  }\n}\n","/**\n * @template T\n */\nexport default class Deferred {\n  constructor() {\n    /**\n     * @private\n     * @type {T|undefined}\n     */\n    this._value = undefined;\n\n    /**\n     * @private\n     * @type {Function|undefined}\n     */\n    this._resolve = undefined;\n\n    /**\n     * @private\n     * @type {!Promise<T>}\n     */\n    this._promise = new Promise(resolve => {\n      this._resolve = resolve;\n\n      if (this._value) {\n        resolve(this._value);\n      }\n    });\n  }\n\n  /**\n   * @param {T} value\n   */\n  resolve(value) {\n    if (this._value) {\n      throw new Error('Already resolved.');\n    }\n\n    this._value = value;\n\n    if (this._resolve) {\n      this._resolve(value);\n    }\n  }\n\n  /**\n   * @return {!Promise<T>}\n   */\n  toPromise() {\n    return this._promise;\n  }\n}\n","import CustomElementInternals from './CustomElementInternals.js';\nimport DocumentConstructionObserver from './DocumentConstructionObserver.js';\nimport Deferred from './Deferred.js';\nimport * as Utilities from './Utilities.js';\n\n/**\n * @unrestricted\n */\nexport default class CustomElementRegistry {\n\n  /**\n   * @param {!CustomElementInternals} internals\n   */\n  constructor(internals) {\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._elementDefinitionIsRunning = false;\n\n    /**\n     * @private\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @private\n     * @type {!Map<string, !Deferred<undefined>>}\n     */\n    this._whenDefinedDeferred = new Map();\n\n    /**\n     * The default flush callback triggers the document walk synchronously.\n     * @private\n     * @type {!Function}\n     */\n    this._flushCallback = fn => fn();\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._flushPending = false;\n\n    /**\n     * @private\n     * @type {!Array<!CustomElementDefinition>}\n     */\n    this._pendingDefinitions = [];\n\n    /**\n     * @private\n     * @type {!DocumentConstructionObserver}\n     */\n    this._documentConstructionObserver = new DocumentConstructionObserver(internals, document);\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!Function} constructor\n   */\n  define(localName, constructor) {\n    if (!(constructor instanceof Function)) {\n      throw new TypeError('Custom element constructors must be functions.');\n    }\n\n    if (!Utilities.isValidCustomElementName(localName)) {\n      throw new SyntaxError(`The element name '${localName}' is not valid.`);\n    }\n\n    if (this._internals.localNameToDefinition(localName)) {\n      throw new Error(`A custom element with name '${localName}' has already been defined.`);\n    }\n\n    if (this._elementDefinitionIsRunning) {\n      throw new Error('A custom element is already being defined.');\n    }\n    this._elementDefinitionIsRunning = true;\n\n    let connectedCallback;\n    let disconnectedCallback;\n    let adoptedCallback;\n    let attributeChangedCallback;\n    let observedAttributes;\n    try {\n      /** @type {!Object} */\n      const prototype = constructor.prototype;\n      if (!(prototype instanceof Object)) {\n        throw new TypeError('The custom element constructor\\'s prototype is not an object.');\n      }\n\n      function getCallback(name) {\n        const callbackValue = prototype[name];\n        if (callbackValue !== undefined && !(callbackValue instanceof Function)) {\n          throw new Error(`The '${name}' callback must be a function.`);\n        }\n        return callbackValue;\n      }\n\n      connectedCallback = getCallback('connectedCallback');\n      disconnectedCallback = getCallback('disconnectedCallback');\n      adoptedCallback = getCallback('adoptedCallback');\n      attributeChangedCallback = getCallback('attributeChangedCallback');\n      observedAttributes = constructor['observedAttributes'] || [];\n    } catch (e) {\n      return;\n    } finally {\n      this._elementDefinitionIsRunning = false;\n    }\n\n    const definition = {\n      localName,\n      constructor,\n      connectedCallback,\n      disconnectedCallback,\n      adoptedCallback,\n      attributeChangedCallback,\n      observedAttributes,\n      constructionStack: [],\n    };\n\n    this._internals.setDefinition(localName, definition);\n    this._pendingDefinitions.push(definition);\n\n    // If we've already called the flush callback and it hasn't called back yet,\n    // don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  _flush() {\n    // If no new definitions were defined, don't attempt to flush. This could\n    // happen if a flush callback keeps the function it is given and calls it\n    // multiple times.\n    if (this._flushPending === false) return;\n    this._flushPending = false;\n\n    const pendingDefinitions = this._pendingDefinitions;\n\n    /**\n     * Unupgraded elements with definitions that were defined *before* the last\n     * flush, in document order.\n     * @type {!Array<!Element>}\n     */\n    const elementsWithStableDefinitions = [];\n\n    /**\n     * A map from `localName`s of definitions that were defined *after* the last\n     * flush to unupgraded elements matching that definition, in document order.\n     * @type {!Map<string, !Array<!Element>>}\n     */\n    const elementsWithPendingDefinitions = new Map();\n    for (let i = 0; i < pendingDefinitions.length; i++) {\n      elementsWithPendingDefinitions.set(pendingDefinitions[i].localName, []);\n    }\n\n    this._internals.patchAndUpgradeTree(document, {\n      upgrade: element => {\n        // Ignore the element if it has already upgraded or failed to upgrade.\n        if (element.__CE_state !== undefined) return;\n\n        const localName = element.localName;\n\n        // If there is an applicable pending definition for the element, add the\n        // element to the list of elements to be upgraded with that definition.\n        const pendingElements = elementsWithPendingDefinitions.get(localName);\n        if (pendingElements) {\n          pendingElements.push(element);\n        // If there is *any other* applicable definition for the element, add it\n        // to the list of elements with stable definitions that need to be upgraded.\n        } else if (this._internals.localNameToDefinition(localName)) {\n          elementsWithStableDefinitions.push(element);\n        }\n      },\n    });\n\n    // Upgrade elements with 'stable' definitions first.\n    for (let i = 0; i < elementsWithStableDefinitions.length; i++) {\n      this._internals.upgradeElement(elementsWithStableDefinitions[i]);\n    }\n\n    // Upgrade elements with 'pending' definitions in the order they were defined.\n    while (pendingDefinitions.length > 0) {\n      const definition = pendingDefinitions.shift();\n      const localName = definition.localName;\n\n      // Attempt to upgrade all applicable elements.\n      const pendingUpgradableElements = elementsWithPendingDefinitions.get(definition.localName);\n      for (let i = 0; i < pendingUpgradableElements.length; i++) {\n        this._internals.upgradeElement(pendingUpgradableElements[i]);\n      }\n\n      // Resolve any promises created by `whenDefined` for the definition.\n      const deferred = this._whenDefinedDeferred.get(localName);\n      if (deferred) {\n        deferred.resolve(undefined);\n      }\n    }\n  }\n\n  /**\n   * @param {string} localName\n   * @return {Function|undefined}\n   */\n  get(localName) {\n    const definition = this._internals.localNameToDefinition(localName);\n    if (definition) {\n      return definition.constructor;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!Promise<undefined>}\n   */\n  whenDefined(localName) {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      return Promise.reject(new SyntaxError(`'${localName}' is not a valid custom element name.`));\n    }\n\n    const prior = this._whenDefinedDeferred.get(localName);\n    if (prior) {\n      return prior.toPromise();\n    }\n\n    const deferred = new Deferred();\n    this._whenDefinedDeferred.set(localName, deferred);\n\n    const definition = this._internals.localNameToDefinition(localName);\n    // Resolve immediately only if the given local name has a definition *and*\n    // the full document walk to upgrade elements with that local name has\n    // already happened.\n    if (definition && !this._pendingDefinitions.some(d => d.localName === localName)) {\n      deferred.resolve(undefined);\n    }\n\n    return deferred.toPromise();\n  }\n\n  polyfillWrapFlushCallback(outer) {\n    this._documentConstructionObserver.disconnect();\n    const inner = this._flushCallback;\n    this._flushCallback = flush => outer(() => inner(flush));\n  }\n}\n\n// Closure compiler exports.\nwindow['CustomElementRegistry'] = CustomElementRegistry;\nCustomElementRegistry.prototype['define'] = CustomElementRegistry.prototype.define;\nCustomElementRegistry.prototype['get'] = CustomElementRegistry.prototype.get;\nCustomElementRegistry.prototype['whenDefined'] = CustomElementRegistry.prototype.whenDefined;\nCustomElementRegistry.prototype['polyfillWrapFlushCallback'] = CustomElementRegistry.prototype.polyfillWrapFlushCallback;\n","export default {\n  Document_createElement: window.Document.prototype.createElement,\n  Document_createElementNS: window.Document.prototype.createElementNS,\n  Document_importNode: window.Document.prototype.importNode,\n  Document_prepend: window.Document.prototype['prepend'],\n  Document_append: window.Document.prototype['append'],\n  DocumentFragment_prepend: window.DocumentFragment.prototype['prepend'],\n  DocumentFragment_append: window.DocumentFragment.prototype['append'],\n  Node_cloneNode: window.Node.prototype.cloneNode,\n  Node_appendChild: window.Node.prototype.appendChild,\n  Node_insertBefore: window.Node.prototype.insertBefore,\n  Node_removeChild: window.Node.prototype.removeChild,\n  Node_replaceChild: window.Node.prototype.replaceChild,\n  Node_textContent: Object.getOwnPropertyDescriptor(window.Node.prototype, 'textContent'),\n  Element_attachShadow: window.Element.prototype['attachShadow'],\n  Element_innerHTML: Object.getOwnPropertyDescriptor(window.Element.prototype, 'innerHTML'),\n  Element_getAttribute: window.Element.prototype.getAttribute,\n  Element_setAttribute: window.Element.prototype.setAttribute,\n  Element_removeAttribute: window.Element.prototype.removeAttribute,\n  Element_getAttributeNS: window.Element.prototype.getAttributeNS,\n  Element_setAttributeNS: window.Element.prototype.setAttributeNS,\n  Element_removeAttributeNS: window.Element.prototype.removeAttributeNS,\n  Element_insertAdjacentElement: window.Element.prototype['insertAdjacentElement'],\n  Element_prepend: window.Element.prototype['prepend'],\n  Element_append: window.Element.prototype['append'],\n  Element_before: window.Element.prototype['before'],\n  Element_after: window.Element.prototype['after'],\n  Element_replaceWith: window.Element.prototype['replaceWith'],\n  Element_remove: window.Element.prototype['remove'],\n  HTMLElement: window.HTMLElement,\n  HTMLElement_innerHTML: Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'innerHTML'),\n  HTMLElement_insertAdjacentElement: window.HTMLElement.prototype['insertAdjacentElement'],\n};\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   prepend: !function(...(!Node|string)),\n  *  append: !function(...(!Node|string)),\n * }}\n */\nlet ParentNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ParentNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {!function(...(!Node|string))} builtInMethod\n   * @return {!function(...(!Node|string))}\n   */\n  function appendPrependPatch(builtInMethod) {\n    return function(...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       * @type {!Array<!Node>}\n       */\n      const flattenedNodes = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       * @type {!Array<!Node>}\n       */\n      const connectedElements = [];\n\n      for (var i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.prepend !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'prepend', appendPrependPatch(builtIn.prepend));\n  }\n\n  if (builtIn.append !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'append', appendPrependPatch(builtIn.append));\n  }\n};\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\nimport CustomElementRegistry from './CustomElementRegistry.js';\n\nimport PatchHTMLElement from './Patch/HTMLElement.js';\nimport PatchDocument from './Patch/Document.js';\nimport PatchDocumentFragment from './Patch/DocumentFragment.js';\nimport PatchNode from './Patch/Node.js';\nimport PatchElement from './Patch/Element.js';\n\nconst priorCustomElements = window['customElements'];\n\nif (!priorCustomElements ||\n     priorCustomElements['forcePolyfill'] ||\n     (typeof priorCustomElements['define'] != 'function') ||\n     (typeof priorCustomElements['get'] != 'function')) {\n  /** @type {!CustomElementInternals} */\n  const internals = new CustomElementInternals();\n\n  PatchHTMLElement(internals);\n  PatchDocument(internals);\n  PatchDocumentFragment(internals);\n  PatchNode(internals);\n  PatchElement(internals);\n\n  // The main document is always associated with the registry.\n  document.__CE_hasRegistry = true;\n\n  /** @type {!CustomElementRegistry} */\n  const customElements = new CustomElementRegistry(internals);\n\n  Object.defineProperty(window, 'customElements', {\n    configurable: true,\n    enumerable: true,\n    value: customElements,\n  });\n}\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport AlreadyConstructedMarker from '../AlreadyConstructedMarker.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  window['HTMLElement'] = (function() {\n    /**\n     * @type {function(new: HTMLElement): !HTMLElement}\n     */\n    function HTMLElement() {\n      // This should really be `new.target` but `new.target` can't be emulated\n      // in ES5. Assuming the user keeps the default value of the constructor's\n      // prototype's `constructor` property, this is equivalent.\n      /** @type {!Function} */\n      const constructor = this.constructor;\n\n      const definition = internals.constructorToDefinition(constructor);\n      if (!definition) {\n        throw new Error('The custom element being constructed was not registered with `customElements`.');\n      }\n\n      const constructionStack = definition.constructionStack;\n\n      if (constructionStack.length === 0) {\n        const element = Native.Document_createElement.call(document, definition.localName);\n        Object.setPrototypeOf(element, constructor.prototype);\n        element.__CE_state = CEState.custom;\n        element.__CE_definition = definition;\n        internals.patch(element);\n        return element;\n      }\n\n      const lastIndex = constructionStack.length - 1;\n      const element = constructionStack[lastIndex];\n      if (element === AlreadyConstructedMarker) {\n        throw new Error('The HTMLElement constructor was either called reentrantly for this constructor or called multiple times.');\n      }\n      constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n      Object.setPrototypeOf(element, constructor.prototype);\n      internals.patch(/** @type {!HTMLElement} */ (element));\n\n      return element;\n    }\n\n    HTMLElement.prototype = Native.HTMLElement.prototype;\n\n    return HTMLElement;\n  })();\n};\n","/**\n * @enum {number}\n */\nconst CustomElementState = {\n  custom: 1,\n  failed: 2,\n};\n\nexport default CustomElementState;\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElement',\n    /**\n     * @this {Document}\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructor)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElement.call(this, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'importNode',\n    /**\n     * @this {Document}\n     * @param {!Node} node\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(node, deep) {\n      const clone = Native.Document_importNode.call(this, node, deep);\n      // Only create custom elements if this document is associated with the registry.\n      if (!this.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  const NS_HTML = \"http://www.w3.org/1999/xhtml\";\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElementNS',\n    /**\n     * @this {Document}\n     * @param {?string} namespace\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(namespace, localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry && (namespace === null || namespace === NS_HTML)) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructor)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElementNS.call(this, namespace, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  PatchParentNode(internals, Document.prototype, {\n    prepend: Native.Document_prepend,\n    append: Native.Document_append,\n  });\n};\n","import CustomElementInternals from '../CustomElementInternals.js';\nimport Native from './Native.js';\nimport PatchParentNode from './Interface/ParentNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  PatchParentNode(internals, DocumentFragment.prototype, {\n    prepend: Native.DocumentFragment_prepend,\n    append: Native.DocumentFragment_append,\n  });\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  // `Node#nodeValue` is implemented on `Attr`.\n  // `Node#textContent` is implemented on `Attr`, `Element`.\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'insertBefore',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @param {?Node} refNode\n     * @return {!Node}\n     */\n    function(node, refNode) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'appendChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_appendChild.call(this, node);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_appendChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'cloneNode',\n    /**\n     * @this {Node}\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(deep) {\n      const clone = Native.Node_cloneNode.call(this, deep);\n      // Only create custom elements if this element's owner document is\n      // associated with the registry.\n      if (!this.ownerDocument.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'removeChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_removeChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'replaceChild',\n    /**\n     * @this {Node}\n     * @param {!Node} nodeToInsert\n     * @param {!Node} nodeToRemove\n     * @return {!Node}\n     */\n    function(nodeToInsert, nodeToRemove) {\n      if (nodeToInsert instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(nodeToInsert.childNodes);\n        const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          internals.disconnectTree(nodeToRemove);\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeToInsertWasConnected = Utilities.isConnected(nodeToInsert);\n      const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n      const thisIsConnected = Utilities.isConnected(this);\n\n      if (thisIsConnected) {\n        internals.disconnectTree(nodeToRemove);\n      }\n\n      if (nodeToInsertWasConnected) {\n        internals.disconnectTree(nodeToInsert);\n      }\n\n      if (thisIsConnected) {\n        internals.connectTree(nodeToInsert);\n      }\n\n      return nativeResult;\n    });\n\n\n  function patch_textContent(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'textContent', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Node} */ function(assignedValue) {\n        // If this is a text node then there are no nodes to disconnect.\n        if (this.nodeType === Node.TEXT_NODE) {\n          baseDescriptor.set.call(this, assignedValue);\n          return;\n        }\n\n        let removedNodes = undefined;\n        // Checking for `firstChild` is faster than reading `childNodes.length`\n        // to compare with 0.\n        if (this.firstChild) {\n          // Using `childNodes` is faster than `children`, even though we only\n          // care about elements.\n          const childNodes = this.childNodes;\n          const childNodesLength = childNodes.length;\n          if (childNodesLength > 0 && Utilities.isConnected(this)) {\n            // Copying an array by iterating is faster than using slice.\n            removedNodes = new Array(childNodesLength);\n            for (let i = 0; i < childNodesLength; i++) {\n              removedNodes[i] = childNodes[i];\n            }\n          }\n        }\n\n        baseDescriptor.set.call(this, assignedValue);\n\n        if (removedNodes) {\n          for (let i = 0; i < removedNodes.length; i++) {\n            internals.disconnectTree(removedNodes[i]);\n          }\n        }\n      },\n    });\n  }\n\n  if (Native.Node_textContent && Native.Node_textContent.get) {\n    patch_textContent(Node.prototype, Native.Node_textContent);\n  } else {\n    internals.addPatch(function(element) {\n      patch_textContent(element, {\n        enumerable: true,\n        configurable: true,\n        // NOTE: This implementation of the `textContent` getter assumes that\n        // text nodes' `textContent` getter will not be patched.\n        get: /** @this {Node} */ function() {\n          /** @type {!Array<string>} */\n          const parts = [];\n\n          for (let i = 0; i < this.childNodes.length; i++) {\n            parts.push(this.childNodes[i].textContent);\n          }\n\n          return parts.join('');\n        },\n        set: /** @this {Node} */ function(assignedValue) {\n          while (this.firstChild) {\n            Native.Node_removeChild.call(this, this.firstChild);\n          }\n          Native.Node_appendChild.call(this, document.createTextNode(assignedValue));\n        },\n      });\n    });\n  }\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport PatchChildNode from './Interface/ChildNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  if (Native.Element_attachShadow) {\n    Utilities.setPropertyUnchecked(Element.prototype, 'attachShadow',\n      /**\n       * @this {Element}\n       * @param {!{mode: string}} init\n       * @return {ShadowRoot}\n       */\n      function(init) {\n        const shadowRoot = Native.Element_attachShadow.call(this, init);\n        this.__CE_shadowRoot = shadowRoot;\n        return shadowRoot;\n      });\n  }\n\n\n  function patch_innerHTML(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'innerHTML', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Element} */ function(htmlString) {\n        const isConnected = Utilities.isConnected(this);\n\n        // NOTE: In IE11, when using the native `innerHTML` setter, all nodes\n        // that were previously descendants of the context element have all of\n        // their children removed as part of the set - the entire subtree is\n        // 'disassembled'. This work around walks the subtree *before* using the\n        // native setter.\n        /** @type {!Array<!Element>|undefined} */\n        let removedElements = undefined;\n        if (isConnected) {\n          removedElements = [];\n          Utilities.walkDeepDescendantElements(this, element => {\n            if (element !== this) {\n              removedElements.push(element);\n            }\n          });\n        }\n\n        baseDescriptor.set.call(this, htmlString);\n\n        if (removedElements) {\n          for (let i = 0; i < removedElements.length; i++) {\n            const element = removedElements[i];\n            if (element.__CE_state === CEState.custom) {\n              internals.disconnectedCallback(element);\n            }\n          }\n        }\n\n        // Only create custom elements if this element's owner document is\n        // associated with the registry.\n        if (!this.ownerDocument.__CE_hasRegistry) {\n          internals.patchTree(this);\n        } else {\n          internals.patchAndUpgradeTree(this);\n        }\n        return htmlString;\n      },\n    });\n  }\n\n  if (Native.Element_innerHTML && Native.Element_innerHTML.get) {\n    patch_innerHTML(Element.prototype, Native.Element_innerHTML);\n  } else if (Native.HTMLElement_innerHTML && Native.HTMLElement_innerHTML.get) {\n    patch_innerHTML(HTMLElement.prototype, Native.HTMLElement_innerHTML);\n  } else {\n\n    internals.addPatch(function(element) {\n      patch_innerHTML(element, {\n        enumerable: true,\n        configurable: true,\n        // Implements getting `innerHTML` by performing an unpatched `cloneNode`\n        // of the element and returning the resulting element's `innerHTML`.\n        // TODO: Is this too expensive?\n        get: /** @this {Element} */ function() {\n          return Native.Node_cloneNode.call(this, true).innerHTML;\n        },\n        // Implements setting `innerHTML` by creating an unpatched element,\n        // setting `innerHTML` of that element and replacing the target\n        // element's children with those of the unpatched element.\n        set: /** @this {Element} */ function(assignedValue) {\n          // NOTE: re-route to `content` for `template` elements.\n          // We need to do this because `template.appendChild` does not\n          // route into `template.content`.\n          const isTemplate = (this.localName === 'template');\n          /** @type {!Node} */\n          const content = isTemplate ? (/** @type {!HTMLTemplateElement} */\n            (this)).content : this;\n          /** @type {!Node} */\n          const rawElement = Native.Document_createElement.call(document,\n            this.localName);\n          rawElement.innerHTML = assignedValue;\n\n          while (content.childNodes.length > 0) {\n            Native.Node_removeChild.call(content, content.childNodes[0]);\n          }\n          const container = isTemplate ? rawElement.content : rawElement;\n          while (container.childNodes.length > 0) {\n            Native.Node_appendChild.call(content, container.childNodes[0]);\n          }\n        },\n      });\n    });\n  }\n\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttribute.call(this, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_setAttribute.call(this, name, newValue);\n      newValue = Native.Element_getAttribute.call(this, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, null);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(namespace, name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     */\n    function(name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttribute.call(this, name);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_removeAttribute.call(this, name);\n      if (oldValue !== null) {\n        internals.attributeChangedCallback(this, name, oldValue, null, null);\n      }\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     */\n    function(namespace, name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttributeNS.call(this, namespace, name);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_removeAttributeNS.call(this, namespace, name);\n      // In older browsers, `Element#getAttributeNS` may return the empty string\n      // instead of null if the attribute does not exist. For details, see;\n      // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttributeNS#Notes\n      const newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      if (oldValue !== newValue) {\n        internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n      }\n    });\n\n\n  function patch_insertAdjacentElement(destination, baseMethod) {\n    Utilities.setPropertyUnchecked(destination, 'insertAdjacentElement',\n      /**\n       * @this {Element}\n       * @param {string} where\n       * @param {!Element} element\n       * @return {?Element}\n       */\n      function(where, element) {\n        const wasConnected = Utilities.isConnected(element);\n        const insertedElement = /** @type {!Element} */\n          (baseMethod.call(this, where, element));\n\n        if (wasConnected) {\n          internals.disconnectTree(element);\n        }\n\n        if (Utilities.isConnected(insertedElement)) {\n          internals.connectTree(element);\n        }\n        return insertedElement;\n      });\n  }\n\n  if (Native.HTMLElement_insertAdjacentElement) {\n    patch_insertAdjacentElement(HTMLElement.prototype, Native.HTMLElement_insertAdjacentElement);\n  } else if (Native.Element_insertAdjacentElement) {\n    patch_insertAdjacentElement(Element.prototype, Native.Element_insertAdjacentElement);\n  } else {\n    console.warn('Custom Elements: `Element#insertAdjacentElement` was not patched.');\n  }\n\n\n  PatchParentNode(internals, Element.prototype, {\n    prepend: Native.Element_prepend,\n    append: Native.Element_append,\n  });\n\n  PatchChildNode(internals, Element.prototype, {\n    before: Native.Element_before,\n    after: Native.Element_after,\n    replaceWith: Native.Element_replaceWith,\n    remove: Native.Element_remove,\n  });\n};\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   before: !function(...(!Node|string)),\n *   after: !function(...(!Node|string)),\n *   replaceWith: !function(...(!Node|string)),\n *   remove: !function(),\n * }}\n */\nlet ChildNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ChildNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {!function(...(!Node|string))} builtInMethod\n   * @return {!function(...(!Node|string))}\n   */\n  function beforeAfterPatch(builtInMethod) {\n    return function(...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       * @type {!Array<!Node>}\n       */\n      const flattenedNodes = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       * @type {!Array<!Node>}\n       */\n      const connectedElements = [];\n\n      for (var i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.before !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'before', beforeAfterPatch(builtIn.before));\n  }\n\n  if (builtIn.before !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'after', beforeAfterPatch(builtIn.after));\n  }\n\n  if (builtIn.replaceWith !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'replaceWith',\n      /**\n       * @param {...(!Node|string)} nodes\n       */\n      function(...nodes) {\n        /**\n         * A copy of `nodes`, with any DocumentFragment replaced by its children.\n         * @type {!Array<!Node>}\n         */\n        const flattenedNodes = [];\n\n        /**\n         * Elements in `nodes` that were connected before this call.\n         * @type {!Array<!Node>}\n         */\n        const connectedElements = [];\n\n        for (var i = 0; i < nodes.length; i++) {\n          const node = nodes[i];\n\n          if (node instanceof Element && Utilities.isConnected(node)) {\n            connectedElements.push(node);\n          }\n\n          if (node instanceof DocumentFragment) {\n            for (let child = node.firstChild; child; child = child.nextSibling) {\n              flattenedNodes.push(child);\n            }\n          } else {\n            flattenedNodes.push(node);\n          }\n        }\n\n        const wasConnected = Utilities.isConnected(this);\n\n        builtIn.replaceWith.apply(this, nodes);\n\n        for (let i = 0; i < connectedElements.length; i++) {\n          internals.disconnectTree(connectedElements[i]);\n        }\n\n        if (wasConnected) {\n          internals.disconnectTree(this);\n          for (let i = 0; i < flattenedNodes.length; i++) {\n            const node = flattenedNodes[i];\n            if (node instanceof Element) {\n              internals.connectTree(node);\n            }\n          }\n        }\n      });\n    }\n\n  if (builtIn.remove !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'remove',\n      function() {\n        const wasConnected = Utilities.isConnected(this);\n\n        builtIn.remove.call(this);\n\n        if (wasConnected) {\n          internals.disconnectTree(this);\n        }\n      });\n  }\n};\n","/* Copyright 2019-2020 The MathWorks, Inc. */\ndefine(['mw-widget-api/defineWidget',\n  'mw-widget-api/WidgetBase',\n  'mw-progress-indicator/view/SpinnerView',\n  'mw-progress-indicator/enums/TypeEnum',\n  'mw-progress-indicator/enums/SizeEnum',\n  'mw-progress-indicator/enums/PropertyEnum'\n], function (defineWidget, WidgetBase, SpinnerView, TypeEnum, SizeEnum, PropertyEnum) {\n  'use strict';\n\n  const baseClass = 'mw-progress-indicator';\n  const defaultColor = '#0095ff';\n  /**\n     * Progress Indicator widget can be created in 3 ways:\n     * <pre>\n     *  1. Using the ProgressIndicator class\n     *  2. Using createElement\n     *  3. Using HTML\n     *\n     * </pre>\n     * 1. Using ProgressIndicator class:\n     * Progress Indicator can be created by passing in an object to set its\n     * properties.\n     *\n     * NOTE: DO NOT use new operator while creating the Progress Indicator object\n     * <pre>\n     * config = {\n     *    type : 'spinner',\n     *     value : 0\n     * }\n     * let progressIndicator= ProgressIndicator(config);\n     * document.body.appendChild(progressIndicator);\n     * </pre>\n     *\n     * 2. Using createElement\n     * Progress Indicator can also be created using createElement in the code\n     * <pre>\n     * let progressIndicator = document.createElement('mw-progress-indicator');\n     * progressIndicator.size='xsmall';\n     * document.body.appendChild(progressIndicator);\n     * </pre>\n     *\n     * 3. Using HTML\n     * Progress Indicator  can be added as a tag in the html\n     *<pre>\n     * &lt;mw-progress-indicator size=”small” &gt;&lt;/mw-progress-indicator&gt;\n     *</pre>\n     *\n     *\n     * @param {Object} config An object which can be used to configure the properties.\n     * <pre>\n     * config = {\n     *   size: 'small',\n     *   type: 'Spinner'\n     * }\n     * let progressIndicator= ProgressIndicator(config);\n     * document.body.appendChild(progressIndicator);\n     * </pre>\n     *\n     */\n\n  class ProgressIndicator extends WidgetBase {\n    static get _observedAttributes () {\n      return [PropertyEnum.VALUE, PropertyEnum.SIZE, PropertyEnum.TYPE, PropertyEnum.COLOR, PropertyEnum.BORDER];\n    }\n\n    constructor () {\n      super();\n      this._artNode = document.createElement('div');\n      this._progressNode = document.createElement('div');\n      this._progressNodeTwo = document.createElement('div');\n      this._customSize = null;\n    }\n\n    init () {\n      super.init();\n      this._artNode.classList.add(`${baseClass}-Art`);\n      this._root.appendChild(this._artNode);\n\n      if (!this.hasAttribute('role')) {\n        this.setAttribute('role', 'progress');\n      }\n      if (!this.hasAttribute('tabindex')) {\n        this.setAttribute('tabindex', 0);\n      }\n\n      if (!this.hasAttribute(PropertyEnum.VALUE)) {\n        this.setAttribute('indeterminate', '');\n      }\n      // Set the default attributes\n      // NOTE: The default type should be changed when the progress indicator is extended to progress bar\n      if (!this.hasAttribute(PropertyEnum.TYPE)) {\n        this.setAttribute(PropertyEnum.TYPE, TypeEnum.SPINNER);\n      }\n\n      if (!this.hasAttribute(PropertyEnum.SIZE) && !this._customSize) {\n        this.setAttribute(PropertyEnum.SIZE, SizeEnum.SMALL);\n      }\n      this._updateSize(this.size);\n      this._updateStroke();\n    }\n\n    /**\n         * Set 'type' attribute on the Progress Indicator. This attribute take value:\n         * <pre>\n         * 1. Spinner\n         * </pre>\n         *\n         * If the type is not defined, the default type will be Spinner.\n         *\n         * @type {String}\n         * @default spinner\n         * @example\n         * config = {\n         *    type : 'spinner',\n         *     value : 0\n         * }\n         * let progressIndicator= ProgressIndicator(config);\n         *\n         */\n    set type (value) {\n      this._validate(value, PropertyEnum.TYPE);\n      value = value.toLowerCase();\n      this.view = new SpinnerView();\n      this.setAttribute(PropertyEnum.TYPE, value);\n    }\n    get type () {\n      return this.getAttribute(PropertyEnum.TYPE);\n    }\n\n    /**\n         * Set 'size' attribute on the Progress Indicator. This attribute can take 5 values:\n         * <pre>\n         * 1. xsmall\n         * 2. small\n         * 3. medium\n         * 4. large\n         * 5. xlarge\n         * </pre>\n         *\n         * 'size' attribute can also take an object to support custom size progress-indicator of any given size\n         *  size can take an object with customSize property and its value should be number, the given number will create progress-indicator of given size in pixels,\n         *  Note: customSize property in size API is not supported through HTML creation method\n         *  @param {Number} size.customSize\n         *\n         * @example\n         *\n         * let progressIndicator= ProgressIndicator();\n         * progressIndicator.size= {customSize:100};\n         *\n         * If the size is not defined, the default size will be small.\n         *\n         * @type {String || object}\n         * @default small\n         * @example\n         *\n         *\n         * let progressIndicator= ProgressIndicator();\n         * progressIndicator.size= medium;\n         *\n         *\n         */\n    set size (value) {\n      if (typeof value === 'object') {\n        this._validate(value.customSize, 'customSize');\n        this.style.width = value.customSize + 'px';\n        this.style.height = value.customSize + 'px';\n        this._customSize = value.customSize;\n        this.hasAttribute(PropertyEnum.SIZE) && this.removeAttribute(PropertyEnum.SIZE);\n        this._updateSize(value.customSize);\n      } else {\n        this._validate(value, PropertyEnum.SIZE);\n        value = value.toLowerCase();\n        this._customSize = null;\n        // removing style will remove custom size and width\n        this.hasAttribute('style') && this.removeAttribute('style');\n        this.setAttribute(PropertyEnum.SIZE, value);\n      }\n    }\n    get size () {\n      return this.getAttribute(PropertyEnum.SIZE) || this._customSize;\n    }\n    /**\n     * Set 'border' attribute on the Progress Indicator. This attribute take value:\n     * <pre>\n     * 1. true\n     * 2. false\n     * </pre>\n     *\n     * If the border is not defined, the default type will be false.\n     * When background-color of container is same as progress-indicator path color, it's hard to see the progress indicator.\n     * having a border would helps in making progress indicator visible. This API would add border around progress-indicator.\n     * @type {Boolean}\n     * @default false\n     * @example\n     * config = {\n     *    type : 'spinner',\n     *     value : 0,\n     *    border: true\n     * }\n     * let progressIndicator= ProgressIndicator(config);\n     */\n    set border (value) {\n      this._validate(value, PropertyEnum.BORDER);\n      if (value) {\n        this.setAttribute(PropertyEnum.BORDER, '');\n      } else {\n        this.hasAttribute(PropertyEnum.BORDER) && this.removeAttribute(PropertyEnum.BORDER);\n      }\n    }\n\n    get border () {\n      let value = this.hasAttribute(PropertyEnum.BORDER);\n      return value;\n    }\n\n    get indeterminate () {\n      let state = this.hasAttribute('indeterminate');\n      return state;\n    }\n    /**\n         * 'value' attribute of the Progress Indicator determines whether the progress indicator\n         * is determinate or indeterminate.\n         * If the value attribute is set, then the progress indicator will be determinate and the\n         * value attribute holds the current progress value.\n         * The value attribute has to be updated to show the progress.\n         *\n         * If the value is not defined, the progress indicator will be indeterminate\n         *\n         *\n         * @type {number}\n         * @example\n         *\n         *\n         * config = {\n         *     value : 0\n         * }\n         * let progressIndicator= ProgressIndicator(config);\n         * progressIndicator.value = 10;\n         */\n    set value (newValue) {\n      this._validate(newValue, PropertyEnum.VALUE);\n      this.setAttribute(PropertyEnum.VALUE, newValue);\n      this.setAttribute('aria-valuenow', newValue);\n      this.removeAttribute('indeterminate');\n    }\n\n    get value () {\n      let val = this.getAttribute(PropertyEnum.VALUE);\n      if (val === null) {\n        return 0;\n      } else {\n        return parseFloat(val);\n      }\n    }\n\n    /**\n     * Set 'color' attribute on the Progress Indicator. This attribute takes value:\n     * <pre>\n     * 1. any valid CSS color of 6 digit hex code or 3 digit hex code only like #ABC'.\n     * </pre>\n     * This attribute will change the indication color in progress-indicator.\n     * error will be thrown on invalid color format or any other css color format.\n     *\n     * @type {String}\n     * @example\n     * config = {\n     *    type : 'spinner',\n     *     value : 0,\n     *     color: '#BBB'\n     * }\n     * let progressIndicator= ProgressIndicator(config);\n     *\n     */\n    set color (newValue) {\n      this._validate(newValue, PropertyEnum.COLOR);\n      this.setAttribute(PropertyEnum.COLOR, newValue);\n    }\n\n    get color () {\n      let val = this.getAttribute(PropertyEnum.COLOR);\n      let isValidColor = this._isHexaColor(val);\n      if (!isValidColor) {\n        return defaultColor;\n      }\n      return val;\n    }\n\n    attributeChangedCallback (name, oldValue, newValue) {\n      super.attributeChangedCallback(name, oldValue, newValue);\n\n      // Prevent recursive sets from property vs attribute changes\n      if (oldValue !== newValue) {\n        switch (name) {\n          case PropertyEnum.VALUE:\n            this.value = newValue;\n            this._updateStroke();\n            break;\n          case PropertyEnum.TYPE:\n            this.type = newValue;\n            break;\n          case PropertyEnum.SIZE:\n            if (this.hasAttribute(PropertyEnum.SIZE)) {\n              this.size = newValue;\n              this._updateSize(this.size);\n            }\n            break;\n          case PropertyEnum.COLOR:\n            this.color = newValue;\n            this._updateColor(this.color);\n            break;\n          case PropertyEnum.BORDER:\n            this._updateBorder();\n            break;\n        }\n      }\n    }\n\n    _updateStroke () {\n      var strokeGap = this.valueLength;\n      let strokeDash = this.value * this.valueLength / 100;\n      if (this.indeterminate) {\n        strokeDash = strokeGap / 4;\n      }\n\n      this._progressNode.setAttribute('stroke-dasharray', `${strokeDash}, ${strokeGap}`);\n      // for value less than 100 white patch around stroke-color should be visible otherwise it shouldn't.\n      if (this.value < 100) {\n        this._progressNodeTwo.setAttribute('stroke-dasharray', `${1}, ${strokeDash - 1}, ${1}, ${strokeGap - 1}`);\n      } else {\n        this._progressNodeTwo.setAttribute('stroke-dasharray', `${0}, ${strokeDash}, ${0}, ${strokeGap}`);\n      }\n    }\n\n    _updateBorder () {\n      this._redrawSVG();\n    }\n\n    _updateColor (color) {\n      this._progressNode.setAttribute('stroke', `${color}`);\n    }\n\n    _updateSize () {\n      this._redrawSVG();\n    }\n\n    _redrawSVG () {\n      if (!this.view) {\n        return;\n      }\n      var { svg, valueLength } = this.view.createWidget(this.size, this.border);\n      this.valueLength = valueLength;\n      if (this._artNode.children.length === 1) {\n        this._artNode.removeChild(this._artNode.firstElementChild);\n        this._artNode.appendChild(svg.cloneNode(true));\n\n        this._progressNode = this._artNode.getElementsByClassName(`${baseClass}`)[0];\n        this._progressNodeTwo = this._artNode.getElementsByClassName(`${baseClass}`)[1];\n        this._updateStroke();\n        this._updateColor(this.color);\n      } else {\n        this._artNode.appendChild(svg.cloneNode(true));\n        this._progressNode = this._artNode.getElementsByClassName(`${baseClass}`)[0];\n        this._progressNodeTwo = this._artNode.getElementsByClassName(`${baseClass}`)[1];\n        this._updateColor(this.color);\n      }\n    }\n\n    _isHexaColor (hexaColor) {\n      return /^#([0-9A-F]{3}){1,2}$/i.test(hexaColor);\n    }\n\n    _validate (value, property) {\n      switch (property) {\n        case PropertyEnum.SIZE:\n          let sizes = Object.values(SizeEnum);\n          if ((typeof value !== 'string') || !sizes.includes(value.toLowerCase())) {\n            throw new Error('Value of ' + property + ' property should be xsmall/small/medium/large/xlarge');\n          }\n          break;\n        case PropertyEnum.TYPE:\n          if ((typeof value !== 'string') || !(value.toLowerCase() === TypeEnum.SPINNER)) {\n            throw new Error('Value of ' + property + ' property should be spinner');\n          }\n          break;\n        case PropertyEnum.VALUE:\n          if (parseFloat(value) < 0 || parseFloat(value) > 100) {\n            throw new Error('Value of ' + property + ' property should be Number between 0-100');\n          } else if (isNaN(parseFloat(value))) {\n            throw new Error('Value of ' + property + ' property should be Number between 0-100');\n          }\n          break;\n        case PropertyEnum.COLOR:\n          let isValidColor = this._isHexaColor(value);\n          if ((typeof value !== 'string') || !isValidColor) {\n            throw new Error('Value of ' + property + ' css should be in valid supported css color in hex code');\n          }\n          break;\n        case 'customSize':\n          if (isNaN(value) || parseFloat(value) < 0 || value === null) {\n            throw new Error('Value of ' + property + '  should be a Number greater than 0');\n          }\n          break;\n        case PropertyEnum.BORDER:\n          if (!(value === true || value === false)) {\n            throw new Error('Value of ' + property + '  should be a true or false value');\n          }\n          break;\n      }\n    }\n  }\n  return defineWidget({\n    name: 'mw-progress-indicator',\n    widgetClass: ProgressIndicator\n  });\n});\n","define([\n], function () {\n  'use strict';\n  const PROPERTY = Object.freeze({\n    VALUE: 'value',\n    SIZE: 'size',\n    TYPE: 'type',\n    COLOR: 'color',\n    BORDER: 'border'\n  });\n  return PROPERTY;\n});\n","define([\n], function () {\n  'use strict';\n  const SIZE = Object.freeze({\n    XSMALL: 'xsmall',\n    SMALL: 'small',\n    MEDIUM: 'medium',\n    LARGE: 'large',\n    XLARGE: 'xlarge'\n  });\n\n  return SIZE;\n});\n","define([\n], function () {\n  'use strict';\n  const TYPE = Object.freeze({\n    SPINNER: 'spinner'\n  });\n\n  return TYPE;\n});\n","define([\n], function () {\n  // This class creates appropriate sized cinnerRadiuscle SVG for the progress indicator\n  class SpinnerView {\n    createWidget (size, border) {\n      const baseClass = 'mw-progress-indicator';\n      let circleAttrs = {};\n\n      switch (size) {\n        case 'xsmall':\n          size = 16;\n          break;\n        case 'small':\n          size = 24;\n          break;\n        case 'medium':\n          size = 32;\n          break;\n        case 'large':\n          size = 48;\n          break;\n        case 'xlarge':\n          size = 64;\n          break;\n      }\n\n      // this will not change size to be 2px when given as in 1px but making size = 2 will help\n      // in displaying the SVG for 1px, since SVG display is vector based and size = 1 return\n      // few calculation in negative which in turn doesn't create SVG\n      if (size <= 1) {\n        size = 2;\n      }\n      let outerRadius = size / 2;\n      let strokeWidth = (outerRadius / 4) + 1;\n      let halfStrokeWidth = (strokeWidth / 2);\n      let innerRadius = outerRadius - halfStrokeWidth;\n      circleAttrs = {\n        radius: innerRadius,\n        strokeWidth: strokeWidth,\n        cx: 0,\n        cy: 0\n      };\n\n      let dummyDiv = document.createElement('div');\n      let svgNode = document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n      svgNode.setAttribute('class', 'progressIndicatorSvg');\n      svgNode.setAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');\n      svgNode.setAttribute('width', '100%');\n      svgNode.setAttribute('height', '100%');\n      svgNode.setAttribute('viewBox', `${-(outerRadius)} ${-(outerRadius)} ${2 * (outerRadius)} ${2 * (outerRadius)}`);\n\n      let innerGroup = document.createElementNS('http://www.w3.org/2000/svg', 'g');\n      let progressIndicatorGutter = document.createElementNS('http://www.w3.org/2000/svg', 'circle');\n      progressIndicatorGutter.classList.add(`${baseClass}-gutter`);\n      progressIndicatorGutter.setAttribute('r', circleAttrs.radius);\n      progressIndicatorGutter.setAttribute('cx', circleAttrs.cx);\n      progressIndicatorGutter.setAttribute('cy', circleAttrs.cy);\n      progressIndicatorGutter.setAttribute('stroke-width', circleAttrs.strokeWidth);\n\n      let progressIndicatorArt = document.createElementNS('http://www.w3.org/2000/svg', 'circle');\n      progressIndicatorArt.classList.add(`${baseClass}`);\n      progressIndicatorArt.setAttribute('r', circleAttrs.radius);\n      progressIndicatorArt.setAttribute('cx', circleAttrs.cx);\n      progressIndicatorArt.setAttribute('cy', circleAttrs.cy);\n      progressIndicatorArt.setAttribute('stroke-width', circleAttrs.strokeWidth);\n\n      let progressIndicatorArtTwo = document.createElementNS('http://www.w3.org/2000/svg', 'circle');\n      progressIndicatorArtTwo.classList.add(`${baseClass}`);\n      progressIndicatorArtTwo.setAttribute('r', circleAttrs.radius);\n      progressIndicatorArtTwo.setAttribute('cx', circleAttrs.cx);\n      progressIndicatorArtTwo.setAttribute('cy', circleAttrs.cy);\n      progressIndicatorArtTwo.setAttribute('stroke-width', circleAttrs.strokeWidth);\n      progressIndicatorArtTwo.setAttribute('stroke', '#ffffff');\n\n      innerGroup.appendChild(progressIndicatorGutter);\n      innerGroup.appendChild(progressIndicatorArt);\n      innerGroup.appendChild(progressIndicatorArtTwo);\n      svgNode.appendChild(innerGroup);\n\n      if (border) {\n        let outerGroup = document.createElementNS('http://www.w3.org/2000/svg', 'g');\n        outerGroup.classList.add('outer-group');\n        let circleOuterBoundary = document.createElementNS('http://www.w3.org/2000/svg', 'path');\n        let outerDValue = `M 0 ${-outerRadius} A ${outerRadius} ${outerRadius} 0 1 0 0 ${outerRadius} A ${outerRadius} ${outerRadius} 0 1 0 0 ${-outerRadius} Z M 0 ${-outerRadius + 1} A ${outerRadius - 1} ${outerRadius - 1} 0 1 1 0 ${outerRadius - 1} A ${outerRadius - 1} ${outerRadius - 1} 0 1 1 0 ${-outerRadius + 1} Z`;\n        circleOuterBoundary.setAttribute('d', `${outerDValue}`);\n        innerRadius = outerRadius - strokeWidth;\n        let circleInnerBoundary = document.createElementNS('http://www.w3.org/2000/svg', 'path');\n        let innerDValue = `M 0 ${-innerRadius} A ${innerRadius} ${innerRadius} 0 1 0 0 ${innerRadius} A ${innerRadius} ${innerRadius} 0 1 0 0 ${-innerRadius} Z M 0 ${-innerRadius + 1} A ${innerRadius - 1} ${innerRadius - 1} 0 1 1 0 ${innerRadius - 1} A ${innerRadius - 1} ${innerRadius - 1} 0 1 1 0 ${-innerRadius + 1} Z`;\n        circleInnerBoundary.setAttribute('d', `${innerDValue}`);\n        outerGroup.appendChild(circleInnerBoundary);\n        outerGroup.appendChild(circleOuterBoundary);\n        svgNode.appendChild(outerGroup);\n      }\n\n      dummyDiv.appendChild(svgNode);\n      const valueLength = 2 * Math.PI * circleAttrs.radius;\n      let svg = dummyDiv.firstChild;\n      dummyDiv = null;\n      let returnvalue = {\n        valueLength: valueLength,\n        svg: svg\n      };\n      return returnvalue;\n    }\n  }\n  return SpinnerView;\n});\n","\"use strict\";\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n// Copyright 2017-2018 The MathWorks, Inc.\ndefine([\"./_polyfills/_addEventListenerOptions\", \"./_polyfills/_createEvent\", \"./_polyfills/_PatchedHtmlElement\", \"custom-elements/custom-elements.min\"], function (_addEventListenerOptions, _createEvent, _PatchedHtmlElement) {\n\n    // no-op (no operation) function\n    var noOp = function noOp() {};\n\n    var WidgetBase = function (_PatchedHtmlElement2) {\n        _inherits(WidgetBase, _PatchedHtmlElement2);\n\n        function WidgetBase() {\n            _classCallCheck(this, WidgetBase);\n\n            var _this = _possibleConstructorReturn(this, (WidgetBase.__proto__ || Object.getPrototypeOf(WidgetBase)).call(this));\n\n            _this._root = document.createDocumentFragment();\n            return _this;\n        }\n\n        _createClass(WidgetBase, [{\n            key: \"init\",\n            value: function init() {}\n        }, {\n            key: \"connectedCallback\",\n            value: function connectedCallback() {\n                if (!this._connectedCallbackRan) {\n                    this.init();\n                    this.appendChild(this._root);\n                    delete this._root;\n                    this._connectedCallbackRan = true;\n                }\n            }\n        }, {\n            key: \"disconnectedCallback\",\n            value: function disconnectedCallback() {}\n        }, {\n            key: \"adoptedCallback\",\n            value: function adoptedCallback() {}\n        }, {\n            key: \"attributeChangedCallback\",\n            value: function attributeChangedCallback(name, oldValue, newValue) {}\n\n            /**\n             * Emits custom events from the widget.\n             *\n             * @param {string} eventName name of the event\n             * @param {object} data an object with the\n             * data that should be attached to the event\n             * this ends up in the event's detail\n             * @param {object} options an options object.\n             * Can specify cancelable, bubbles (defaults\n             * bubbles: false, canceable: false)\n             */\n\n        }, {\n            key: \"emit\",\n            value: function emit(eventName, data) {\n                var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n                this.dispatchEvent(_createEvent.createEvent(eventName, data, options));\n            }\n\n            /**\n             * Listens on events that the widget throws.\n             * @param {string} eventName The name of the event to listen on\n             * @param {function} callback The function to call when the event occurs\n             * @param {object} options an object that specifies if the event should be\n             * passive, capture (defaults - passive: browser/event dependent,\n             * capture: false)\n             * @returns {object} - object with a remove function.  Calling remove twice\n             * does nothing\n             */\n\n        }, {\n            key: \"on\",\n            value: function on(eventName, callback) {\n                var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n                var eventObj = _addEventListenerOptions.getOptions(options);\n                this.addEventListener(eventName, callback, eventObj);\n\n                var removeFn = this.removeEventListener.bind(this, eventName, callback, eventObj);\n                return {\n                    remove: function remove() {\n                        removeFn();\n                        removeFn = noOp;\n                    }\n                };\n            }\n        }]);\n\n        return WidgetBase;\n    }(_PatchedHtmlElement);\n\n    ;\n    return WidgetBase;\n});\n//# sourceMappingURL=WidgetBase.js.map\n","\"use strict\";\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _fixBabelExtend = function (O) {\n    var gPO = O.getPrototypeOf || function (o) {\n        return o.__proto__;\n    },\n        sPO = O.setPrototypeOf || function (o, p) {\n        o.__proto__ = p;\n        return o;\n    },\n        construct = (typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) === 'object' ? Reflect.construct : function (Parent, args, Class) {\n        var Constructor,\n            a = [null];\n        a.push.apply(a, args);\n        Constructor = Parent.bind.apply(Parent, a);\n        return sPO(new Constructor(), Class.prototype);\n    };\n\n    return function fixBabelExtend(Class) {\n        var Parent = gPO(Class);\n        return sPO(Class, sPO(function Super() {\n            return construct(Parent, arguments, gPO(this).constructor);\n        }, Parent));\n    };\n}(Object);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n// Copyright 2017-2018 The MathWorks, Inc.\n/* global Reflect */\ndefine([\"custom-elements/custom-elements.min\"], function () {\n    var PatchedHtmlElement = void 0;\n    if (((typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) !== \"object\" || !Reflect.construct) && document.__CE_hasRegistry) {\n        // IE11 (and possibly QTWebKit) does not have Reflect.construct\n        // This causes problems when we are extending from the HTMLElement polyfill.\n        //\n        // If we are in this if, We are in Polyfill Mode (document.__CE_hasRegistry)\n        // without Reflect.contruct\n        // Do NOT treat HTMLElement as a built-in\n\n        // If we do the polyfill will complain:\n        // The custom element being constructed was not registered with `customElements`\n        // We can switch over to directly extending custom element without the intermediate\n        // class if Reflect.construct is available in all of our supported browsers\n        //\n        // To avoid treating \"HTMLElement\" as a built-in, it is not directly extended.\n        // Instead it is copied to a variable _HTMLElement and then extended.  Because\n        // Babel does not do static analysis, and the built in names are \"Hard Coded\"\n        // this causes Babel to treat this as a standard extension, and not a built-in\n        // extension\n        var _HTMLElement = HTMLElement;\n        PatchedHtmlElement = function (_HTMLElement2) {\n            _inherits(PatchedHtmlElement, _HTMLElement2);\n\n            function PatchedHtmlElement() {\n                _classCallCheck(this, PatchedHtmlElement);\n\n                return _possibleConstructorReturn(this, (PatchedHtmlElement.__proto__ || Object.getPrototypeOf(PatchedHtmlElement)).apply(this, arguments));\n            }\n\n            return PatchedHtmlElement;\n        }(_HTMLElement);\n    } else {\n        PatchedHtmlElement = _fixBabelExtend(function (_HTMLElement3) {\n            _inherits(_class, _HTMLElement3);\n\n            function _class() {\n                _classCallCheck(this, _class);\n\n                return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));\n            }\n\n            return _class;\n        }(HTMLElement));\n    }\n\n    return PatchedHtmlElement;\n});\n//# sourceMappingURL=_PatchedHtmlElement.js.map\n","\"use strict\";\n\ndefine([], function () {\n    var passiveSupported = false;\n    try {\n        var options = Object.defineProperty({}, \"passive\", {\n            get: function get() {\n                passiveSupported = true;\n            }\n        });\n\n        window.addEventListener(\"test\", null, options);\n    } catch (err) {}\n\n    var getEventListenerOptions = void 0;\n    if (passiveSupported) {\n        getEventListenerOptions = function setupEventListenerOptions(options) {\n            var eventObj = {};\n            var capture = options.capture || false;\n            var once = options.once || false;\n            eventObj.capture = capture;\n            eventObj.once = once;\n            var passive = options.passive;\n            if (passive === true || passive === false) {\n                // If statement to so we use \"browser default\"\n                // if \"passive\" is not explicitly set.\n                eventObj.passive = passive;\n            }\n            return eventObj;\n        };\n    } else {\n        getEventListenerOptions = function setupEventListenerOptions(options) {\n            return options.capture || false;\n        };\n    }\n\n    return {\n        passiveSupported: passiveSupported,\n        getOptions: getEventListenerOptions\n    };\n});\n//# sourceMappingURL=_addEventListenerOptions.js.map\n","'use strict';\n\ndefine([], function () {\n\n    var hasCustomEventConstructor = false;\n    if (typeof CustomEvent === 'function') {\n        hasCustomEventConstructor = true;\n    }\n\n    var createEvent = void 0;\n    if (hasCustomEventConstructor) {\n        createEvent = function createEvent(name, data, options) {\n            var bubbles = options.bubbles || false;\n            var cancelable = options.cancelable || false;\n            return new CustomEvent(name, {\n                detail: data || {},\n                bubbles: bubbles,\n                cancelable: cancelable\n            });\n        };\n    } else {\n        createEvent = function createEvent(name, data, options) {\n            var bubbles = options.bubbles || false;\n            var cancelable = options.cancelable || false;\n            var event = document.createEvent('CustomEvent');\n            event.initCustomEvent(name, bubbles, cancelable, data);\n            return event;\n        };\n    }\n\n    return {\n        hasCustomEventConstructor: hasCustomEventConstructor,\n        createEvent: createEvent\n    };\n});\n//# sourceMappingURL=_createEvent.js.map\n","\"use strict\";\n\n// Copyright 2017-2018 The MathWorks, Inc.\ndefine([\"custom-elements/custom-elements.min\"], function () {\n    \"use strict\";\n\n    /**\n    * @typedef widgetDefinition\n    * @property {string} name Registered name of the widget.  Used\n    * by the browser when intantiating a widget via HTML or\n    * document.createElement.  Needs to be a  kebab-case string starting\n    * with \"mw-\" e.g. mw-some-widget\n    * @property {instanceOf} widgetClass the class used as\n    * the widget class.  Should extend from WidgetBase\n    */\n\n    /**\n     * Defines a Widget, registers the widget with\n     * the browser, and returns a factory that can be\n     * used to instantiate a widget programmatically.\n     * @param {widgetDefinition} widgetDefinition\n     * @returns CreateWidgetFunction\n     */\n\n    var defineWidget = function defineWidget(widgetDefinition) {\n        if (!widgetDefinition.widgetClass) {\n            throw new Error(\"The widgetClass object must have a widget widgetClass property\");\n        }\n        if (!widgetDefinition.name) {\n            throw new Error(\"The widgetDefinition object must have a name property\");\n        }\n        if (widgetDefinition.name.length < 3 || widgetDefinition.name.substring(0, 3) !== \"mw-\") {\n            throw new Error(\"The widgetDefinition object must have a name\" + \"property starting with 'mw-'\");\n        }\n\n        var WidgetClass = widgetDefinition.widgetClass;\n\n        // Copy _observedAttributes from\n        // Widget widgetClass to avoid accidental mutation\n        // at runtime.  Then define the\n        // observedAttributes static getter\n        var observedAttributes = [];\n        if (WidgetClass._observedAttributes) {\n            observedAttributes = WidgetClass._observedAttributes.slice(0);\n        }\n        Object.defineProperty(WidgetClass, \"observedAttributes\", {\n            enumerable: false,\n            get: function get() {\n                return observedAttributes;\n            }\n        });\n        customElements.define(widgetDefinition.name, WidgetClass);\n\n        // Return a function that applies parameters to an instance of\n        // the Widget\n        return function create() {\n            var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n            if (this instanceof create) {\n                throw new Error(\"Do not use 'w = new Widget()' to create a widget instance. \" + \"Just use 'w = Widget()'\");\n            }\n            var widget = new WidgetClass();\n            for (var prop in params) {\n                if (Object.prototype.hasOwnProperty.call(params, prop)) {\n                    widget[prop] = params[prop];\n                }\n            }\n            return widget;\n        };\n    };\n\n    return defineWidget;\n});\n//# sourceMappingURL=defineWidget.js.map\n","const showErrorPage = function () {\n    document.querySelector('.dialog').style.display = 'block';\n    document.querySelector('.dialog').querySelector('h1').innerHTML = 'We are sorry, but something went wrong.';\n    hideSpinner();\n};\nconst showTimeoutPage = function () {\n    document.querySelector('.dialog').style.display = 'block';\n    document.querySelector('.dialog').querySelector('h1').innerHTML = 'Request is taking too long. Please try again later.';\n    hideSpinner();\n};\n\nconst hideSpinner = function () {\n    document.querySelector('.loader').style.visibility = 'hidden';\n    document.querySelector('.loading_large_file').style.visibility = 'hidden';\n};\n\nexport default { showErrorPage, showTimeoutPage };\n","const fetchData = async function (contextRoot, url, filename, timeout = 45000) {\n    return _fetchArtifact(contextRoot, url, filename, 'renderer/GetData', timeout)\n};\n\nconst fetchModelArtifactURL = async function (contextRoot, url, filename, timeout = 45000) {\n    return _fetchArtifact(contextRoot, url, filename, 'renderer/GetModelArtifactURL', timeout)\n};\n\nconst _fetchArtifact = async function (contextRoot, url, filename, mwtypeMsg, timeout) {\n    // eslint-disable-next-line no-undef\n    const controller = new AbortController();\n    setTimeout(() => controller.abort(), timeout);\n    const headers = {\n        'Accept': 'application/json',\n        'Content-Type': 'application/json'\n    };\n\n    const data = {\n        'mwtype': mwtypeMsg,\n        'url': url,\n        'filename': filename\n    };\n    return poll(`${contextRoot}data/v1/api`, {\n        method: 'POST',\n        mode: 'cors',\n        signal: controller.signal,\n        headers,\n        credentials: 'include',\n        body: JSON.stringify(data)\n    });\n}\n\nconst poll = async (url, options) => {\n    try {\n        // eslint-disable-next-line no-undef\n        let response = await fetch(url, options);\n        // in case of a browser time (504) out or a status not found (204) from server, poll again\n        if (response.status === 204 || response.status === 504) {\n            await poll(url, options);\n        }\n        let message = await response.json();\n        if (message.mwtype === 'core/Fault') {\n            if (message.faultId[0] === 'TimeoutFault') {\n                throw new Error('TimeoutError');\n            } else {\n                throw new Error('ServerError');\n            }\n        }\n        return message;\n    } catch (e) {\n        if (e.name === 'AbortError') {\n            throw new Error('TimeoutError');\n        }\n        throw e;\n    }\n};\n\nexport default { fetchData, fetchModelArtifactURL };\n","require('core-js/features/object/values');\nrequire('core-js/features/array/includes');\nrequire('mw-progress-indicator/ProgressIndicator');\n\n// import ProgressIndicator from 'mw-progress-indicator/ProgressIndicator'\n// the import format above works, but since this module is using module.exports\n// webpack does not allow importing in ES6 and exporting in CJS.\n// See https://www.seancdavis.com/blog/export-es6-class-globally-webpack/\nrequire('mw-progress-indicator/css/main.css');\nrequire('../css/index.css');\nconst fetchUtils = require('./FetchUtils').default;\nconst errorUtils = require('./ErrorUtils').default;\n\nmodule.exports = { ...fetchUtils, ...errorUtils };\n","require('../../modules/es.array.includes');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'includes');\n","require('../../modules/es.object.values');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.values;\n","var parent = require('../../es/array/includes');\n\nmodule.exports = parent;\n","var parent = require('../../es/object/values');\n\nmodule.exports = parent;\n","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\n\nvar call = Function.call;\n\nmodule.exports = function (CONSTRUCTOR, METHOD, length) {\n  return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0: return function () {\n      return fn.call(that);\n    };\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  /* global globalThis -- safe */\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","module.exports = {};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    metadata.facade = it;\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","module.exports = false;\n","var fails = require('../internals/fails');\n\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  // Chrome 38 Symbol has incorrect toString conversion\n  /* global Symbol -- required for testing */\n  return !String(Symbol());\n});\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject -- old IE */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return nativeDefineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return nativeGetOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","exports.f = Object.getOwnPropertySymbols;\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) {\n        result.push(TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.es/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  values: createMethod(false)\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var state;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) {\n      createNonEnumerableProperty(value, 'name', key);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.9.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.es/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","var NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  /* global Symbol -- safe */\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name)) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];\n    else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n  } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true }, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","var $ = require('../internals/export');\nvar $values = require('../internals/object-to-array').values;\n\n// `Object.values` method\n// https://tc39.es/ecma262/#sec-object.values\n$({ target: 'Object', stat: true }, {\n  values: function values(O) {\n    return $values(O);\n  }\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(348);\n"],"sourceRoot":""}