{"version":3,"sources":["webpack://_N_E/./node_modules/@next/polyfill-module/dist/polyfill-module.js","webpack://_N_E/./node_modules/core-js/modules/web.dom-collections.iterator.js","webpack://_N_E/./node_modules/core-js/internals/object-get-prototype-of.js","webpack://_N_E/./node_modules/core-js/internals/correct-prototype-getter.js","webpack://_N_E/./node_modules/core-js/modules/es.array.iterator.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/inherits.js","webpack://_N_E/./node_modules/core-js/internals/internal-metadata.js","webpack://_N_E/./node_modules/core-js/modules/esnext.promise.all-settled.js","webpack://_N_E/../../client/next.js","webpack://_N_E/./node_modules/raf/polyfill.js","webpack://_N_E/../../client/head-manager.ts","webpack://_N_E/../../../next-server/lib/head-manager-context.ts","webpack://_N_E/../../client/index.tsx","webpack://_N_E/./node_modules/core-js/features/promise/all-settled.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://_N_E/./node_modules/core-js/modules/es.string.iterator.js","webpack://_N_E/./node_modules/abortcontroller-polyfill/dist/polyfill-patch-fetch.js","webpack://_N_E/./node_modules/core-js/internals/add-to-unscopables.js","webpack://_N_E/./node_modules/core-js/es/promise/all-settled.js","webpack://_N_E/./node_modules/core-js/modules/es.map.js","webpack://_N_E/./node_modules/intersection-observer/intersection-observer.js","webpack://_N_E/./node_modules/core-js/es/map/index.js","webpack://_N_E/./node_modules/core-js/modules/es.set.js","webpack://_N_E/./node_modules/child-replace-with-polyfill/index.js","webpack://_N_E/./node_modules/core-js/internals/collection-strong.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://_N_E/../../client/performance-relayer.ts","webpack://_N_E/./node_modules/performance-now/lib/performance-now.js","webpack://_N_E/./node_modules/core-js/internals/collection.js","webpack://_N_E/./node_modules/core-js/internals/define-iterator.js","webpack://_N_E/./client/polyfills.js","webpack://_N_E/./node_modules/core-js/modules/es.promise.all-settled.js","webpack://_N_E/./node_modules/core-js/es/set/index.js","webpack://_N_E/./node_modules/core-js/internals/create-iterator-constructor.js","webpack://_N_E/./node_modules/next/dist/compiled/web-vitals/web-vitals.es5.umd.min.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/extends.js","webpack://_N_E/./node_modules/core-js/internals/iterators-core.js","webpack://_N_E/./node_modules/core-js/internals/freezing.js","webpack://_N_E/./node_modules/raf/index.js","webpack://_N_E/../../../next-server/lib/runtime-config.ts","webpack://_N_E/../../client/page-loader.ts"],"names":["String","prototype","trimStart","trimLeft","trimEnd","trimRight","Symbol","Object","defineProperty","configurable","get","t","exec","this","toString","Array","flat","r","concat","apply","some","isArray","flatMap","map","Promise","finally","then","constructor","o","resolve","global","DOMIterables","ArrayIteratorMethods","createNonEnumerableProperty","wellKnownSymbol","ITERATOR","TO_STRING_TAG","ArrayValues","values","COLLECTION_NAME","Collection","CollectionPrototype","error","METHOD_NAME","has","toObject","sharedKey","CORRECT_PROTOTYPE_GETTER","IE_PROTO","ObjectPrototype","module","exports","getPrototypeOf","O","fails","F","toIndexedObject","addToUnscopables","Iterators","InternalStateModule","defineIterator","setInternalState","set","getInternalState","getterFor","iterated","kind","type","target","index","state","length","undefined","value","done","Arguments","setPrototypeOf","subClass","superClass","TypeError","create","writable","hiddenKeys","isObject","f","uid","FREEZING","METADATA","id","isExtensible","setMetadata","it","objectID","weakData","meta","REQUIRED","fastKey","getWeakData","onFreeze","window","console","polyfill","updatePromise","mountedInstances","updateHead","head","promise","tags","h","components","titleComponent","title","children","document","headEl","headCountEl","headCount","Number","oldTags","i","j","newTags","newTag","k","len","oldTag","updateElements","DOMAttributeNames","acceptCharset","className","htmlFor","httpEquiv","reactElementToDOM","el","props","p","attr","dangerouslySetInnerHTML","HeadManagerContext","React","data","JSON","process","__NEXT_VERSION","looseToArray","err","locales","prefix","__webpack_public_path__","envConfig","serverRuntimeConfig","publicRuntimeConfig","runtimeConfig","asPath","hasBasePath","delBasePath","pageLoader","PageLoader","register","setTimeout","headManager","appElement","router","isFallback","isDynamicRoute","location","hydrateProps","querystring","URLSearchParams","_h","shallow","hash","Component","emitter","appEntrypoint","component","CachedApp","mod","onPerfEntry","uniqueID","Date","Math","entries","perfStartEntry","name","startTime","label","entryType","initialErr","pageEntrypoint","CachedComponent","createRouter","initialProps","App","wrapApp","Boolean","subscription","render","locale","defaultLocale","renderCtx","initial","renderingProps","renderError","doRender","renderErr","renderErrorProps","page","AppTree","appCtx","ctx","pathname","query","loadGetInitialProps","initProps","styleSheets","shouldUseHydrate","ReactDOM","markHydrateComplete","ST","performance","clearMarks","markRenderComplete","navStartEntries","measure","mark","AppContainer","fn","makePublicRouterInstance","wrappedAppProps","appProps","input","lastAppProps","canceled","renderPromise","lastRenderReject","resolvePromise","Error","reject","reactEl","elem","callback","desiredHrefs","Set","s","currentStyleTags","currentHrefs","tag","idx","referenceNode","targetTag","getComputedStyle","noscript","nonce","styleTag","onStart","renderReactElement","Root","Head","parent","_getPrototypeOf","__proto__","self","ReferenceError","charAt","string","point","_classCallCheck","instance","Constructor","_defineProperties","descriptor","enumerable","key","_createClass","protoProps","staticProps","_inherits","_setPrototypeOf","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","call","e","_assertThisInitialized","_possibleConstructorReturn","_createSuper","Derived","hasNativeReflectConstruct","result","Super","NewTarget","arguments","_superPropBase","object","property","hasOwnProperty","_get","receiver","base","desc","getOwnPropertyDescriptor","Emitter","options","listeners","push","stack","l","splice","event","stackToCall","slice","listener","once","removeEventListener","defaultPrevented","AbortSignal","_Emitter","_super","_this","aborted","onabort","AbortController","Event","createEvent","initEvent","createEventObject","bubbles","cancelable","signal","dispatchEvent","polyfillNeeded","__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL","log","Request","abortableFetchDecorator","patchTargets","fetch","_patchTargets","_patchTargets$Request","NativeRequest","NativeAbortController","_patchTargets$__FORCE","init","request","realFetch","isPrototypeOf","abortError","DOMException","cancellation","_","addEventListener","race","toStringTag","_abortableFetch","warn","definePropertyModule","UNSCOPABLES","ArrayPrototype","$allSettled","allSettled","iterable","collection","collectionStrong","IntersectionObserverEntry","intersectionRatio","registry","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","_observationTargets","item","element","nodeType","_registerInstance","entry","_monitorIntersections","_checkForIntersections","unobserve","filter","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","sort","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","margin","parts","parseFloat","unit","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","top","bottom","left","right","width","height","forEach","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","time","now","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","display","getParentNode","atRoot","parentRect","parentComputedStyle","root","body","documentElement","overflow","computeRectIntersection","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","indexOf","targetArea","intersectionArea","toFixed","opt_options","timeout","timer","throttle","bind","rootMargin","join","node","opt_useCapture","attachEvent","detatchEvent","rect1","rect2","max","min","child","parentNode","host","path","Map","ReplaceWithPolyfill","currentNode","removeChild","ownerDocument","createTextNode","insertBefore","previousSibling","replaceChild","Element","replaceWith","CharacterData","DocumentType","redefineAll","anInstance","iterate","setSpecies","DESCRIPTORS","internalStateGetterFor","getConstructor","wrapper","CONSTRUCTOR_NAME","IS_MAP","ADDER","C","that","first","last","size","define","previous","getEntry","next","removed","clear","prev","callbackfn","boundFunction","add","setStrong","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","_typeof","assertThisInitialized","isRegistered","onReport","metric","userReportHandler","getCLS","getFID","getFCP","getLCP","getTTFB","getNanoSeconds","hrtime","loadTime","moduleLoadTime","nodeLoadTime","upTime","hr","uptime","getTime","$","isForced","redefine","InternalMetadataModule","checkCorrectnessOfIteration","setToStringTag","inheritIfRequired","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","KEY","nativeMethod","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","dummy","forced","createIteratorConstructor","IS_PURE","IteratorsCore","IteratorPrototype","BUGGY_SAFARI_ITERATORS","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","keys","proto","aFunction","newPromiseCapabilityModule","perform","stat","capability","promiseResolve","counter","remaining","alreadyCalled","status","reason","createPropertyDescriptor","692","n","floor","random","delta","isFinal","PerformanceObserver","supportedEntryTypes","includes","getEntries","buffered","u","persisted","c","timeStamp","visibilityState","isUnloading","capture","d","passive","hadRecentInput","processingStart","perfMetrics","onFirstInputDelay","getEntriesByType","timing","navigationStart","responseStart","readyState","__webpack_require__","ab","__dirname","_extends","assign","source","PrototypeOfArrayIteratorPrototype","arrayIterator","preventExtensions","vendors","suffix","raf","caf","queue","_now","cp","cancelled","round","handle","cancel","requestAnimationFrame","cancelAnimationFrame","configValue","normalizeRoute","route","buildId","assetPrefix","promisedSsgManifest","promisedDevPagesManifest","routeLoader","getClientBuildManifest","manifest","parseRelativeUrl","getHrefForSlug","dataRoute","addLocale","addBasePath","ssg","isDynamic","interpolatedRoute","interpolateAs","loadRoute","res","href","text","prefetch"],"mappings":"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","file":"static/chunks/main-1e164b3bd610867990eb.js","sourcesContent":["\"trimStart\"in String.prototype||(String.prototype.trimStart=String.prototype.trimLeft),\"trimEnd\"in String.prototype||(String.prototype.trimEnd=String.prototype.trimRight),\"description\"in Symbol.prototype||Object.defineProperty(Symbol.prototype,\"description\",{configurable:!0,get:function(){var t=/\\((.*)\\)/.exec(this.toString());return t?t[1]:void 0}}),Array.prototype.flat||(Array.prototype.flat=function(t,r){return r=this.concat.apply([],this),t>1&&r.some(Array.isArray)?r.flat(t-1):r},Array.prototype.flatMap=function(t,r){return this.map(t,r).flat()}),Promise.prototype.finally||(Promise.prototype.finally=function(t){if(\"function\"!=typeof t)return this.then(t,t);var r=this.constructor||Promise;return this.then(function(o){return r.resolve(t()).then(function(){return o})},function(o){return r.resolve(t()).then(function(){throw o})})});\n","var global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nfor (var COLLECTION_NAME in DOMIterables) {\n  var Collection = global[COLLECTION_NAME];\n  var CollectionPrototype = Collection && Collection.prototype;\n  if (CollectionPrototype) {\n    // some Chrome versions have non-configurable methods on DOMTokenList\n    if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n      createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n    } catch (error) {\n      CollectionPrototype[ITERATOR] = ArrayValues;\n    }\n    if (!CollectionPrototype[TO_STRING_TAG]) {\n      createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);\n    }\n    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n      // some Chrome versions have non-configurable methods on DOMTokenList\n      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n      } catch (error) {\n        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n      }\n    }\n  }\n}\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.github.io/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;","var hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar defineProperty = require('../internals/object-define-property').f;\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + ++id, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar meta = module.exports = {\n  REQUIRED: false,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","// TODO: Remove from `core-js@4`\nrequire('./es.promise.all-settled.js');\n","import initNext, * as next from './'\n\nwindow.next = next\n\ninitNext().catch(console.error)\n","require('./').polyfill()\n","const DOMAttributeNames: Record<string, string> = {\n  acceptCharset: 'accept-charset',\n  className: 'class',\n  htmlFor: 'for',\n  httpEquiv: 'http-equiv',\n}\n\nfunction reactElementToDOM({ type, props }: JSX.Element): HTMLElement {\n  const el = document.createElement(type)\n  for (const p in props) {\n    if (!props.hasOwnProperty(p)) continue\n    if (p === 'children' || p === 'dangerouslySetInnerHTML') continue\n\n    // we don't render undefined props to the DOM\n    if (props[p] === undefined) continue\n\n    const attr = DOMAttributeNames[p] || p.toLowerCase()\n    el.setAttribute(attr, props[p])\n  }\n\n  const { children, dangerouslySetInnerHTML } = props\n  if (dangerouslySetInnerHTML) {\n    el.innerHTML = dangerouslySetInnerHTML.__html || ''\n  } else if (children) {\n    el.textContent =\n      typeof children === 'string'\n        ? children\n        : Array.isArray(children)\n        ? children.join('')\n        : ''\n  }\n  return el\n}\n\nfunction updateElements(type: string, components: JSX.Element[]) {\n  const headEl = document.getElementsByTagName('head')[0]\n  const headCountEl: HTMLMetaElement = headEl.querySelector(\n    'meta[name=next-head-count]'\n  ) as HTMLMetaElement\n  if (process.env.NODE_ENV !== 'production') {\n    if (!headCountEl) {\n      console.error(\n        'Warning: next-head-count is missing. https://err.sh/next.js/next-head-count-missing'\n      )\n      return\n    }\n  }\n\n  const headCount = Number(headCountEl.content)\n  const oldTags: Element[] = []\n\n  for (\n    let i = 0, j = headCountEl.previousElementSibling;\n    i < headCount;\n    i++, j = j!.previousElementSibling\n  ) {\n    if (j!.tagName.toLowerCase() === type) {\n      oldTags.push(j!)\n    }\n  }\n  const newTags = (components.map(reactElementToDOM) as HTMLElement[]).filter(\n    (newTag) => {\n      for (let k = 0, len = oldTags.length; k < len; k++) {\n        const oldTag = oldTags[k]\n        if (oldTag.isEqualNode(newTag)) {\n          oldTags.splice(k, 1)\n          return false\n        }\n      }\n      return true\n    }\n  )\n\n  oldTags.forEach((t) => t.parentNode!.removeChild(t))\n  newTags.forEach((t) => headEl.insertBefore(t, headCountEl))\n  headCountEl.content = (headCount - oldTags.length + newTags.length).toString()\n}\n\nexport default function initHeadManager() {\n  let updatePromise: Promise<void> | null = null\n\n  return {\n    mountedInstances: new Set(),\n    updateHead: (head: JSX.Element[]) => {\n      const promise = (updatePromise = Promise.resolve().then(() => {\n        if (promise !== updatePromise) return\n\n        updatePromise = null\n        const tags: Record<string, JSX.Element[]> = {}\n\n        head.forEach((h) => {\n          const components = tags[h.type] || []\n          components.push(h)\n          tags[h.type] = components\n        })\n\n        const titleComponent = tags.title ? tags.title[0] : null\n        let title = ''\n        if (titleComponent) {\n          const { children } = titleComponent.props\n          title =\n            typeof children === 'string'\n              ? children\n              : Array.isArray(children)\n              ? children.join('')\n              : ''\n        }\n        if (title !== document.title) document.title = title\n        ;['meta', 'base', 'link', 'style', 'script'].forEach((type) => {\n          updateElements(type, tags[type] || [])\n        })\n      }))\n    },\n  }\n}\n","import React from 'react'\n\nexport const HeadManagerContext: React.Context<{\n  updateHead?: (state: any) => void\n  mountedInstances?: any\n}> = React.createContext({})\n\nif (process.env.NODE_ENV !== 'production') {\n  HeadManagerContext.displayName = 'HeadManagerContext'\n}\n","/* global location */\nimport '@next/polyfill-module'\nimport React from 'react'\nimport ReactDOM from 'react-dom'\nimport { HeadManagerContext } from '../next-server/lib/head-manager-context'\nimport mitt from '../next-server/lib/mitt'\nimport { RouterContext } from '../next-server/lib/router-context'\nimport type Router from '../next-server/lib/router/router'\nimport type {\n  AppComponent,\n  AppProps,\n  PrivateRouteInfo,\n} from '../next-server/lib/router/router'\nimport { delBasePath, hasBasePath } from '../next-server/lib/router/router'\nimport { isDynamicRoute } from '../next-server/lib/router/utils/is-dynamic'\nimport * as querystring from '../next-server/lib/router/utils/querystring'\nimport * as envConfig from '../next-server/lib/runtime-config'\nimport type { NEXT_DATA } from '../next-server/lib/utils'\nimport { getURL, loadGetInitialProps, ST } from '../next-server/lib/utils'\nimport initHeadManager from './head-manager'\nimport PageLoader, { StyleSheetTuple } from './page-loader'\nimport measureWebVitals from './performance-relayer'\nimport { createRouter, makePublicRouterInstance } from './router'\n\n/// <reference types=\"react-dom/experimental\" />\n\ndeclare let __webpack_public_path__: string\n\ndeclare global {\n  interface Window {\n    /* test fns */\n    __NEXT_HYDRATED?: boolean\n    __NEXT_HYDRATED_CB?: () => void\n\n    /* prod */\n    __NEXT_PRELOADREADY?: (ids?: string[]) => void\n    __NEXT_DATA__: NEXT_DATA\n    __NEXT_P: any[]\n  }\n}\n\ntype RenderRouteInfo = PrivateRouteInfo & { App: AppComponent }\ntype RenderErrorProps = Omit<RenderRouteInfo, 'Component' | 'styleSheets'>\n\nconst data: typeof window['__NEXT_DATA__'] = JSON.parse(\n  document.getElementById('__NEXT_DATA__')!.textContent!\n)\nwindow.__NEXT_DATA__ = data\n\nexport const version = process.env.__NEXT_VERSION\n\nconst looseToArray = <T extends {}>(input: any): T[] => [].slice.call(input)\n\nconst {\n  props: hydrateProps,\n  err: hydrateErr,\n  page,\n  query,\n  buildId,\n  assetPrefix,\n  runtimeConfig,\n  dynamicIds,\n  isFallback,\n  locales,\n} = data\n\nlet { locale, defaultLocale } = data\n\nconst prefix = assetPrefix || ''\n\n// With dynamic assetPrefix it's no longer possible to set assetPrefix at the build time\n// So, this is how we do it in the client side at runtime\n__webpack_public_path__ = `${prefix}/_next/` //eslint-disable-line\n// Initialize next/config with the environment configuration\nenvConfig.setConfig({\n  serverRuntimeConfig: {},\n  publicRuntimeConfig: runtimeConfig || {},\n})\n\nlet asPath = getURL()\n\n// make sure not to attempt stripping basePath for 404s\nif (hasBasePath(asPath)) {\n  asPath = delBasePath(asPath)\n}\n\nif (process.env.__NEXT_I18N_SUPPORT) {\n  const {\n    normalizeLocalePath,\n  } = require('../next-server/lib/i18n/normalize-locale-path') as typeof import('../next-server/lib/i18n/normalize-locale-path')\n\n  const {\n    detectDomainLocale,\n  } = require('../next-server/lib/i18n/detect-domain-locale') as typeof import('../next-server/lib/i18n/detect-domain-locale')\n\n  const {\n    parseRelativeUrl,\n  } = require('../next-server/lib/router/utils/parse-relative-url') as typeof import('../next-server/lib/router/utils/parse-relative-url')\n\n  const {\n    formatUrl,\n  } = require('../next-server/lib/router/utils/format-url') as typeof import('../next-server/lib/router/utils/format-url')\n\n  if (locales) {\n    const parsedAs = parseRelativeUrl(asPath)\n    const localePathResult = normalizeLocalePath(parsedAs.pathname, locales)\n\n    if (localePathResult.detectedLocale) {\n      parsedAs.pathname = localePathResult.pathname\n      asPath = formatUrl(parsedAs)\n    } else {\n      // derive the default locale if it wasn't detected in the asPath\n      // since we don't prerender static pages with all possible default\n      // locales\n      defaultLocale = locale\n    }\n\n    // attempt detecting default locale based on hostname\n    const detectedDomain = detectDomainLocale(\n      process.env.__NEXT_I18N_DOMAINS as any,\n      window.location.hostname\n    )\n\n    // TODO: investigate if defaultLocale needs to be populated after\n    // hydration to prevent mismatched renders\n    if (detectedDomain) {\n      defaultLocale = detectedDomain.defaultLocale\n    }\n  }\n}\n\ntype RegisterFn = (input: [string, () => void]) => void\n\nconst pageLoader = new PageLoader(buildId, prefix)\nconst register: RegisterFn = ([r, f]) =>\n  pageLoader.routeLoader.onEntrypoint(r, f)\nif (window.__NEXT_P) {\n  // Defer page registration for another tick. This will increase the overall\n  // latency in hydrating the page, but reduce the total blocking time.\n  window.__NEXT_P.map((p) => setTimeout(() => register(p), 0))\n}\nwindow.__NEXT_P = []\n;(window.__NEXT_P as any).push = register\n\nconst headManager = initHeadManager()\nconst appElement = document.getElementById('__next')\n\nlet lastAppProps: AppProps\nlet lastRenderReject: (() => void) | null\nlet webpackHMR: any\nexport let router: Router\nlet CachedComponent: React.ComponentType\nlet CachedApp: AppComponent, onPerfEntry: (metric: any) => void\n\nclass Container extends React.Component<{\n  fn: (err: Error, info?: any) => void\n}> {\n  componentDidCatch(componentErr: Error, info: any) {\n    this.props.fn(componentErr, info)\n  }\n\n  componentDidMount() {\n    this.scrollToHash()\n\n    // We need to replace the router state if:\n    // - the page was (auto) exported and has a query string or search (hash)\n    // - it was auto exported and is a dynamic route (to provide params)\n    // - if it is a client-side skeleton (fallback render)\n    if (\n      router.isSsr &&\n      (isFallback ||\n        (data.nextExport &&\n          (isDynamicRoute(router.pathname) || location.search)) ||\n        (hydrateProps && hydrateProps.__N_SSG && location.search))\n    ) {\n      // update query on mount for exported pages\n      router.replace(\n        router.pathname +\n          '?' +\n          String(\n            querystring.assign(\n              querystring.urlQueryToSearchParams(router.query),\n              new URLSearchParams(location.search)\n            )\n          ),\n        asPath,\n        {\n          // @ts-ignore\n          // WARNING: `_h` is an internal option for handing Next.js\n          // client-side hydration. Your app should _never_ use this property.\n          // It may change at any time without notice.\n          _h: 1,\n          // Fallback pages must trigger the data fetch, so the transition is\n          // not shallow.\n          // Other pages (strictly updating query) happens shallowly, as data\n          // requirements would already be present.\n          shallow: !isFallback,\n        }\n      )\n    }\n  }\n\n  componentDidUpdate() {\n    this.scrollToHash()\n  }\n\n  scrollToHash() {\n    let { hash } = location\n    hash = hash && hash.substring(1)\n    if (!hash) return\n\n    const el = document.getElementById(hash)\n    if (!el) return\n\n    // If we call scrollIntoView() in here without a setTimeout\n    // it won't scroll properly.\n    setTimeout(() => el.scrollIntoView(), 0)\n  }\n\n  render() {\n    if (process.env.NODE_ENV === 'production') {\n      return this.props.children\n    } else {\n      const { ReactDevOverlay } = require('@next/react-dev-overlay/lib/client')\n      return <ReactDevOverlay>{this.props.children}</ReactDevOverlay>\n    }\n  }\n}\n\nexport const emitter = mitt()\n\nexport default async (opts: { webpackHMR?: any } = {}) => {\n  // This makes sure this specific lines are removed in production\n  if (process.env.NODE_ENV === 'development') {\n    webpackHMR = opts.webpackHMR\n  }\n\n  const appEntrypoint = await pageLoader.routeLoader.whenEntrypoint('/_app')\n  if ('error' in appEntrypoint) {\n    throw appEntrypoint.error\n  }\n\n  const { component: app, exports: mod } = appEntrypoint\n  CachedApp = app as AppComponent\n\n  if (mod && mod.reportWebVitals) {\n    onPerfEntry = ({\n      id,\n      name,\n      startTime,\n      value,\n      duration,\n      entryType,\n      entries,\n    }) => {\n      // Combines timestamp with random number for unique ID\n      const uniqueID = `${Date.now()}-${\n        Math.floor(Math.random() * (9e12 - 1)) + 1e12\n      }`\n      let perfStartEntry\n\n      if (entries && entries.length) {\n        perfStartEntry = entries[0].startTime\n      }\n\n      mod.reportWebVitals({\n        id: id || uniqueID,\n        name,\n        startTime: startTime || perfStartEntry,\n        value: value == null ? duration : value,\n        label:\n          entryType === 'mark' || entryType === 'measure'\n            ? 'custom'\n            : 'web-vital',\n      })\n    }\n  }\n\n  let initialErr = hydrateErr\n\n  try {\n    const pageEntrypoint =\n      // The dev server fails to serve script assets when there's a hydration\n      // error, so we need to skip waiting for the entrypoint.\n      process.env.NODE_ENV === 'development' && hydrateErr\n        ? { error: hydrateErr }\n        : await pageLoader.routeLoader.whenEntrypoint(page)\n    if ('error' in pageEntrypoint) {\n      throw pageEntrypoint.error\n    }\n    CachedComponent = pageEntrypoint.component\n\n    if (process.env.NODE_ENV !== 'production') {\n      const { isValidElementType } = require('react-is')\n      if (!isValidElementType(CachedComponent)) {\n        throw new Error(\n          `The default export is not a React Component in page: \"${page}\"`\n        )\n      }\n    }\n  } catch (error) {\n    // This catches errors like throwing in the top level of a module\n    initialErr = error\n  }\n\n  if (process.env.NODE_ENV === 'development') {\n    const { getNodeError } = require('@next/react-dev-overlay/lib/client')\n    // Server-side runtime errors need to be re-thrown on the client-side so\n    // that the overlay is rendered.\n    if (initialErr) {\n      if (initialErr === hydrateErr) {\n        setTimeout(() => {\n          let error\n          try {\n            // Generate a new error object. We `throw` it because some browsers\n            // will set the `stack` when thrown, and we want to ensure ours is\n            // not overridden when we re-throw it below.\n            throw new Error(initialErr!.message)\n          } catch (e) {\n            error = e\n          }\n\n          error.name = initialErr!.name\n          error.stack = initialErr!.stack\n\n          const node = getNodeError(error)\n          throw node\n        })\n      }\n      // We replaced the server-side error with a client-side error, and should\n      // no longer rewrite the stack trace to a Node error.\n      else {\n        setTimeout(() => {\n          throw initialErr\n        })\n      }\n    }\n  }\n\n  if (window.__NEXT_PRELOADREADY) {\n    await window.__NEXT_PRELOADREADY(dynamicIds)\n  }\n\n  router = createRouter(page, query, asPath, {\n    initialProps: hydrateProps,\n    pageLoader,\n    App: CachedApp,\n    Component: CachedComponent,\n    wrapApp,\n    err: initialErr,\n    isFallback: Boolean(isFallback),\n    subscription: (info, App) => render(Object.assign({}, info, { App })),\n    locale,\n    locales,\n    defaultLocale,\n  })\n\n  // call init-client middleware\n  if (process.env.__NEXT_PLUGINS) {\n    // @ts-ignore\n    // eslint-disable-next-line\n    import('next-plugin-loader?middleware=on-init-client!')\n      .then((initClientModule) => {\n        return initClientModule.default({ router })\n      })\n      .catch((initClientErr) => {\n        console.error('Error calling client-init for plugins', initClientErr)\n      })\n  }\n\n  const renderCtx: RenderRouteInfo = {\n    App: CachedApp,\n    initial: true,\n    Component: CachedComponent,\n    props: hydrateProps,\n    err: initialErr,\n  }\n\n  if (process.env.NODE_ENV === 'production') {\n    render(renderCtx)\n    return emitter\n  } else {\n    return { emitter, render, renderCtx }\n  }\n}\n\nexport async function render(renderingProps: RenderRouteInfo) {\n  if (renderingProps.err) {\n    await renderError(renderingProps)\n    return\n  }\n\n  try {\n    await doRender(renderingProps)\n  } catch (renderErr) {\n    // bubble up cancelation errors\n    if (renderErr.cancelled) {\n      throw renderErr\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      // Ensure this error is displayed in the overlay in development\n      setTimeout(() => {\n        throw renderErr\n      })\n    }\n    await renderError({ ...renderingProps, err: renderErr })\n  }\n}\n\n// This method handles all runtime and debug errors.\n// 404 and 500 errors are special kind of errors\n// and they are still handle via the main render method.\nexport function renderError(renderErrorProps: RenderErrorProps) {\n  const { App, err } = renderErrorProps\n\n  // In development runtime errors are caught by our overlay\n  // In production we catch runtime errors using componentDidCatch which will trigger renderError\n  if (process.env.NODE_ENV !== 'production') {\n    // A Next.js rendering runtime error is always unrecoverable\n    // FIXME: let's make this recoverable (error in GIP client-transition)\n    webpackHMR.onUnrecoverableError()\n\n    // We need to render an empty <App> so that the `<ReactDevOverlay>` can\n    // render itself.\n    return doRender({\n      App: () => null,\n      props: {},\n      Component: () => null,\n      styleSheets: [],\n    })\n  }\n  if (process.env.__NEXT_PLUGINS) {\n    // @ts-ignore\n    // eslint-disable-next-line\n    import('next-plugin-loader?middleware=on-error-client!')\n      .then((onClientErrorModule) => {\n        return onClientErrorModule.default({ err })\n      })\n      .catch((onClientErrorErr) => {\n        console.error(\n          'error calling on-error-client for plugins',\n          onClientErrorErr\n        )\n      })\n  }\n\n  // Make sure we log the error to the console, otherwise users can't track down issues.\n  console.error(err)\n  return pageLoader\n    .loadPage('/_error')\n    .then(({ page: ErrorComponent, styleSheets }) => {\n      // In production we do a normal render with the `ErrorComponent` as component.\n      // If we've gotten here upon initial render, we can use the props from the server.\n      // Otherwise, we need to call `getInitialProps` on `App` before mounting.\n      const AppTree = wrapApp(App)\n      const appCtx = {\n        Component: ErrorComponent,\n        AppTree,\n        router,\n        ctx: { err, pathname: page, query, asPath, AppTree },\n      }\n      return Promise.resolve(\n        renderErrorProps.props\n          ? renderErrorProps.props\n          : loadGetInitialProps(App, appCtx)\n      ).then((initProps) =>\n        doRender({\n          ...renderErrorProps,\n          err,\n          Component: ErrorComponent,\n          styleSheets,\n          props: initProps,\n        })\n      )\n    })\n}\n\nlet reactRoot: any = null\nlet shouldUseHydrate = typeof ReactDOM.hydrate === 'function'\nfunction renderReactElement(reactEl: JSX.Element, domEl: HTMLElement) {\n  if (process.env.__NEXT_REACT_MODE !== 'legacy') {\n    if (!reactRoot) {\n      const opts = { hydrate: true }\n      reactRoot =\n        process.env.__NEXT_REACT_MODE === 'concurrent'\n          ? (ReactDOM as any).unstable_createRoot(domEl, opts)\n          : (ReactDOM as any).unstable_createBlockingRoot(domEl, opts)\n    }\n    reactRoot.render(reactEl)\n  } else {\n    // mark start of hydrate/render\n    if (ST) {\n      performance.mark('beforeRender')\n    }\n\n    // The check for `.hydrate` is there to support React alternatives like preact\n    if (shouldUseHydrate) {\n      ReactDOM.hydrate(reactEl, domEl, markHydrateComplete)\n      shouldUseHydrate = false\n    } else {\n      ReactDOM.render(reactEl, domEl, markRenderComplete)\n    }\n  }\n}\n\nfunction markHydrateComplete() {\n  if (!ST) return\n\n  performance.mark('afterHydrate') // mark end of hydration\n\n  performance.measure(\n    'Next.js-before-hydration',\n    'navigationStart',\n    'beforeRender'\n  )\n  performance.measure('Next.js-hydration', 'beforeRender', 'afterHydrate')\n\n  if (onPerfEntry) {\n    performance.getEntriesByName('Next.js-hydration').forEach(onPerfEntry)\n  }\n  clearMarks()\n}\n\nfunction markRenderComplete() {\n  if (!ST) return\n\n  performance.mark('afterRender') // mark end of render\n  const navStartEntries = performance.getEntriesByName('routeChange', 'mark')\n\n  if (!navStartEntries.length) {\n    return\n  }\n\n  performance.measure(\n    'Next.js-route-change-to-render',\n    navStartEntries[0].name,\n    'beforeRender'\n  )\n  performance.measure('Next.js-render', 'beforeRender', 'afterRender')\n  if (onPerfEntry) {\n    performance.getEntriesByName('Next.js-render').forEach(onPerfEntry)\n    performance\n      .getEntriesByName('Next.js-route-change-to-render')\n      .forEach(onPerfEntry)\n  }\n  clearMarks()\n  ;['Next.js-route-change-to-render', 'Next.js-render'].forEach((measure) =>\n    performance.clearMeasures(measure)\n  )\n}\n\nfunction clearMarks() {\n  ;[\n    'beforeRender',\n    'afterHydrate',\n    'afterRender',\n    'routeChange',\n  ].forEach((mark) => performance.clearMarks(mark))\n}\n\nfunction AppContainer({\n  children,\n}: React.PropsWithChildren<{}>): React.ReactElement {\n  return (\n    <Container\n      fn={(error) =>\n        renderError({ App: CachedApp, err: error }).catch((err) =>\n          console.error('Error rendering page: ', err)\n        )\n      }\n    >\n      <RouterContext.Provider value={makePublicRouterInstance(router)}>\n        <HeadManagerContext.Provider value={headManager}>\n          {children}\n        </HeadManagerContext.Provider>\n      </RouterContext.Provider>\n    </Container>\n  )\n}\n\nconst wrapApp = (App: AppComponent) => (\n  wrappedAppProps: Record<string, any>\n) => {\n  const appProps: AppProps = {\n    ...wrappedAppProps,\n    Component: CachedComponent,\n    err: hydrateErr,\n    router,\n  }\n  return (\n    <AppContainer>\n      <App {...appProps} />\n    </AppContainer>\n  )\n}\n\nfunction doRender(input: RenderRouteInfo): Promise<any> {\n  let { App, Component, props, err } = input\n  let styleSheets: StyleSheetTuple[] | undefined =\n    'initial' in input ? undefined : input.styleSheets\n  Component = Component || lastAppProps.Component\n  props = props || lastAppProps.props\n\n  const appProps: AppProps = {\n    ...props,\n    Component,\n    err,\n    router,\n  }\n  // lastAppProps has to be set before ReactDom.render to account for ReactDom throwing an error.\n  lastAppProps = appProps\n\n  let canceled = false\n  let resolvePromise: () => void\n  const renderPromise = new Promise((resolve, reject) => {\n    if (lastRenderReject) {\n      lastRenderReject()\n    }\n    resolvePromise = () => {\n      lastRenderReject = null\n      resolve()\n    }\n    lastRenderReject = () => {\n      canceled = true\n      lastRenderReject = null\n\n      const error: any = new Error('Cancel rendering route')\n      error.cancelled = true\n      reject(error)\n    }\n  })\n\n  // This function has a return type to ensure it doesn't start returning a\n  // Promise. It should remain synchronous.\n  function onStart(): boolean {\n    if (\n      !styleSheets ||\n      // We use `style-loader` in development, so we don't need to do anything\n      // unless we're in production:\n      process.env.NODE_ENV !== 'production'\n    ) {\n      return false\n    }\n\n    const currentStyleTags = looseToArray<HTMLStyleElement>(\n      document.querySelectorAll('style[data-n-href]')\n    )\n    const currentHrefs = new Set(\n      currentStyleTags.map((tag) => tag.getAttribute('data-n-href'))\n    )\n\n    const noscript = document.querySelector('noscript[data-n-css]')\n    const nonce = noscript?.getAttribute('data-n-css')\n\n    styleSheets.forEach(({ href, text }) => {\n      if (!currentHrefs.has(href)) {\n        const styleTag = document.createElement('style')\n        styleTag.setAttribute('data-n-href', href)\n        styleTag.setAttribute('media', 'x')\n\n        if (nonce) {\n          styleTag.setAttribute('nonce', nonce)\n        }\n\n        document.head.appendChild(styleTag)\n        styleTag.appendChild(document.createTextNode(text))\n      }\n    })\n    return true\n  }\n\n  function onHeadCommit() {\n    if (\n      // We use `style-loader` in development, so we don't need to do anything\n      // unless we're in production:\n      process.env.NODE_ENV === 'production' &&\n      // We can skip this during hydration. Running it wont cause any harm, but\n      // we may as well save the CPU cycles:\n      styleSheets &&\n      // Ensure this render was not canceled\n      !canceled\n    ) {\n      const desiredHrefs = new Set(styleSheets.map((s) => s.href))\n      const currentStyleTags = looseToArray<HTMLStyleElement>(\n        document.querySelectorAll('style[data-n-href]')\n      )\n      const currentHrefs = currentStyleTags.map(\n        (tag) => tag.getAttribute('data-n-href')!\n      )\n\n      // Toggle `<style>` tags on or off depending on if they're needed:\n      for (let idx = 0; idx < currentHrefs.length; ++idx) {\n        if (desiredHrefs.has(currentHrefs[idx])) {\n          currentStyleTags[idx].removeAttribute('media')\n        } else {\n          currentStyleTags[idx].setAttribute('media', 'x')\n        }\n      }\n\n      // Reorder styles into intended order:\n      let referenceNode = document.querySelector('noscript[data-n-css]')\n      if (\n        // This should be an invariant:\n        referenceNode\n      ) {\n        styleSheets.forEach(({ href }) => {\n          const targetTag = document.querySelector(\n            `style[data-n-href=\"${href}\"]`\n          )\n          if (\n            // This should be an invariant:\n            targetTag\n          ) {\n            referenceNode!.parentNode!.insertBefore(\n              targetTag,\n              referenceNode!.nextSibling\n            )\n            referenceNode = targetTag\n          }\n        })\n      }\n\n      // Finally, clean up server rendered stylesheets:\n      looseToArray<HTMLLinkElement>(\n        document.querySelectorAll('link[data-n-p]')\n      ).forEach((el) => {\n        el.parentNode!.removeChild(el)\n      })\n\n      // Force browser to recompute layout, which should prevent a flash of\n      // unstyled content:\n      getComputedStyle(document.body, 'height')\n    }\n  }\n\n  function onRootCommit() {\n    resolvePromise()\n  }\n\n  const elem = (\n    <Root callback={onRootCommit}>\n      <Head callback={onHeadCommit} />\n      <AppContainer>\n        <App {...appProps} />\n      </AppContainer>\n    </Root>\n  )\n\n  onStart()\n\n  // We catch runtime errors using componentDidCatch which will trigger renderError\n  renderReactElement(\n    process.env.__NEXT_STRICT_MODE ? (\n      <React.StrictMode>{elem}</React.StrictMode>\n    ) : (\n      elem\n    ),\n    appElement!\n  )\n\n  return renderPromise\n}\n\nfunction Root({\n  callback,\n  children,\n}: React.PropsWithChildren<{\n  callback: () => void\n}>): React.ReactElement {\n  // We use `useLayoutEffect` to guarantee the callback is executed\n  // as soon as React flushes the update.\n  React.useLayoutEffect(() => callback(), [callback])\n  if (process.env.__NEXT_TEST_MODE) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      window.__NEXT_HYDRATED = true\n\n      if (window.__NEXT_HYDRATED_CB) {\n        window.__NEXT_HYDRATED_CB()\n      }\n    }, [])\n  }\n  // We should ask to measure the Web Vitals after rendering completes so we\n  // don't cause any hydration delay:\n  React.useEffect(() => {\n    measureWebVitals(onPerfEntry)\n  }, [])\n  return children as React.ReactElement\n}\n\n// Dummy component that we render as a child of Root so that we can\n// toggle the correct styles before the page is rendered.\nfunction Head({ callback }: { callback: () => void }) {\n  // We use `useLayoutEffect` to guarantee the callback is executed\n  // as soon as React flushes the update.\n  React.useLayoutEffect(() => callback(), [callback])\n  return null\n}\n","// TODO: Remove from `core-js@4`\nrequire('../../modules/esnext.promise.all-settled');\n\nvar parent = require('../../es/promise/all-settled');\n\nmodule.exports = parent;\n","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: String(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","(function (factory) {\n  typeof define === 'function' && define.amd ? define(factory) :\n  factory();\n}((function () { 'use strict';\n\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n  }\n\n  function _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        writable: true,\n        configurable: true\n      }\n    });\n    if (superClass) _setPrototypeOf(subClass, superClass);\n  }\n\n  function _getPrototypeOf(o) {\n    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n      return o.__proto__ || Object.getPrototypeOf(o);\n    };\n    return _getPrototypeOf(o);\n  }\n\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n      o.__proto__ = p;\n      return o;\n    };\n\n    return _setPrototypeOf(o, p);\n  }\n\n  function _isNativeReflectConstruct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n\n    try {\n      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  function _assertThisInitialized(self) {\n    if (self === void 0) {\n      throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n\n    return self;\n  }\n\n  function _possibleConstructorReturn(self, call) {\n    if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n      return call;\n    }\n\n    return _assertThisInitialized(self);\n  }\n\n  function _createSuper(Derived) {\n    var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n    return function _createSuperInternal() {\n      var Super = _getPrototypeOf(Derived),\n          result;\n\n      if (hasNativeReflectConstruct) {\n        var NewTarget = _getPrototypeOf(this).constructor;\n\n        result = Reflect.construct(Super, arguments, NewTarget);\n      } else {\n        result = Super.apply(this, arguments);\n      }\n\n      return _possibleConstructorReturn(this, result);\n    };\n  }\n\n  function _superPropBase(object, property) {\n    while (!Object.prototype.hasOwnProperty.call(object, property)) {\n      object = _getPrototypeOf(object);\n      if (object === null) break;\n    }\n\n    return object;\n  }\n\n  function _get(target, property, receiver) {\n    if (typeof Reflect !== \"undefined\" && Reflect.get) {\n      _get = Reflect.get;\n    } else {\n      _get = function _get(target, property, receiver) {\n        var base = _superPropBase(target, property);\n\n        if (!base) return;\n        var desc = Object.getOwnPropertyDescriptor(base, property);\n\n        if (desc.get) {\n          return desc.get.call(receiver);\n        }\n\n        return desc.value;\n      };\n    }\n\n    return _get(target, property, receiver || target);\n  }\n\n  var Emitter = /*#__PURE__*/function () {\n    function Emitter() {\n      _classCallCheck(this, Emitter);\n\n      Object.defineProperty(this, 'listeners', {\n        value: {},\n        writable: true,\n        configurable: true\n      });\n    }\n\n    _createClass(Emitter, [{\n      key: \"addEventListener\",\n      value: function addEventListener(type, callback, options) {\n        if (!(type in this.listeners)) {\n          this.listeners[type] = [];\n        }\n\n        this.listeners[type].push({\n          callback: callback,\n          options: options\n        });\n      }\n    }, {\n      key: \"removeEventListener\",\n      value: function removeEventListener(type, callback) {\n        if (!(type in this.listeners)) {\n          return;\n        }\n\n        var stack = this.listeners[type];\n\n        for (var i = 0, l = stack.length; i < l; i++) {\n          if (stack[i].callback === callback) {\n            stack.splice(i, 1);\n            return;\n          }\n        }\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        if (!(event.type in this.listeners)) {\n          return;\n        }\n\n        var stack = this.listeners[event.type];\n        var stackToCall = stack.slice();\n\n        for (var i = 0, l = stackToCall.length; i < l; i++) {\n          var listener = stackToCall[i];\n\n          try {\n            listener.callback.call(this, event);\n          } catch (e) {\n            Promise.resolve().then(function () {\n              throw e;\n            });\n          }\n\n          if (listener.options && listener.options.once) {\n            this.removeEventListener(event.type, listener.callback);\n          }\n        }\n\n        return !event.defaultPrevented;\n      }\n    }]);\n\n    return Emitter;\n  }();\n\n  var AbortSignal = /*#__PURE__*/function (_Emitter) {\n    _inherits(AbortSignal, _Emitter);\n\n    var _super = _createSuper(AbortSignal);\n\n    function AbortSignal() {\n      var _this;\n\n      _classCallCheck(this, AbortSignal);\n\n      _this = _super.call(this); // Some versions of babel does not transpile super() correctly for IE <= 10, if the parent\n      // constructor has failed to run, then \"this.listeners\" will still be undefined and then we call\n      // the parent constructor directly instead as a workaround. For general details, see babel bug:\n      // https://github.com/babel/babel/issues/3041\n      // This hack was added as a fix for the issue described here:\n      // https://github.com/Financial-Times/polyfill-library/pull/59#issuecomment-477558042\n\n      if (!_this.listeners) {\n        Emitter.call(_assertThisInitialized(_this));\n      } // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController().signal) to be [] for compat with the native impl\n\n\n      Object.defineProperty(_assertThisInitialized(_this), 'aborted', {\n        value: false,\n        writable: true,\n        configurable: true\n      });\n      Object.defineProperty(_assertThisInitialized(_this), 'onabort', {\n        value: null,\n        writable: true,\n        configurable: true\n      });\n      return _this;\n    }\n\n    _createClass(AbortSignal, [{\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortSignal]';\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        if (event.type === 'abort') {\n          this.aborted = true;\n\n          if (typeof this.onabort === 'function') {\n            this.onabort.call(this, event);\n          }\n        }\n\n        _get(_getPrototypeOf(AbortSignal.prototype), \"dispatchEvent\", this).call(this, event);\n      }\n    }]);\n\n    return AbortSignal;\n  }(Emitter);\n  var AbortController = /*#__PURE__*/function () {\n    function AbortController() {\n      _classCallCheck(this, AbortController);\n\n      // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController()) to be [] for compat with the native impl\n      Object.defineProperty(this, 'signal', {\n        value: new AbortSignal(),\n        writable: true,\n        configurable: true\n      });\n    }\n\n    _createClass(AbortController, [{\n      key: \"abort\",\n      value: function abort() {\n        var event;\n\n        try {\n          event = new Event('abort');\n        } catch (e) {\n          if (typeof document !== 'undefined') {\n            if (!document.createEvent) {\n              // For Internet Explorer 8:\n              event = document.createEventObject();\n              event.type = 'abort';\n            } else {\n              // For Internet Explorer 11:\n              event = document.createEvent('Event');\n              event.initEvent('abort', false, false);\n            }\n          } else {\n            // Fallback where document isn't available:\n            event = {\n              type: 'abort',\n              bubbles: false,\n              cancelable: false\n            };\n          }\n        }\n\n        this.signal.dispatchEvent(event);\n      }\n    }, {\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortController]';\n      }\n    }]);\n\n    return AbortController;\n  }();\n\n  if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n    // These are necessary to make sure that we get correct output for:\n    // Object.prototype.toString.call(new AbortController())\n    AbortController.prototype[Symbol.toStringTag] = 'AbortController';\n    AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal';\n  }\n\n  function polyfillNeeded(self) {\n    if (self.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {\n      console.log('__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL=true is set, will force install polyfill');\n      return true;\n    } // Note that the \"unfetch\" minimal fetch polyfill defines fetch() without\n    // defining window.Request, and this polyfill need to work on top of unfetch\n    // so the below feature detection needs the !self.AbortController part.\n    // The Request.prototype check is also needed because Safari versions 11.1.2\n    // up to and including 12.1.x has a window.AbortController present but still\n    // does NOT correctly implement abortable fetch:\n    // https://bugs.webkit.org/show_bug.cgi?id=174980#c2\n\n\n    return typeof self.Request === 'function' && !self.Request.prototype.hasOwnProperty('signal') || !self.AbortController;\n  }\n\n  /**\n   * Note: the \"fetch.Request\" default value is available for fetch imported from\n   * the \"node-fetch\" package and not in browsers. This is OK since browsers\n   * will be importing umd-polyfill.js from that path \"self\" is passed the\n   * decorator so the default value will not be used (because browsers that define\n   * fetch also has Request). One quirky setup where self.fetch exists but\n   * self.Request does not is when the \"unfetch\" minimal fetch polyfill is used\n   * on top of IE11; for this case the browser will try to use the fetch.Request\n   * default value which in turn will be undefined but then then \"if (Request)\"\n   * will ensure that you get a patched fetch but still no Request (as expected).\n   * @param {fetch, Request = fetch.Request}\n   * @returns {fetch: abortableFetch, Request: AbortableRequest}\n   */\n\n  function abortableFetchDecorator(patchTargets) {\n    if ('function' === typeof patchTargets) {\n      patchTargets = {\n        fetch: patchTargets\n      };\n    }\n\n    var _patchTargets = patchTargets,\n        fetch = _patchTargets.fetch,\n        _patchTargets$Request = _patchTargets.Request,\n        NativeRequest = _patchTargets$Request === void 0 ? fetch.Request : _patchTargets$Request,\n        NativeAbortController = _patchTargets.AbortController,\n        _patchTargets$__FORCE = _patchTargets.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL,\n        __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL = _patchTargets$__FORCE === void 0 ? false : _patchTargets$__FORCE;\n\n    if (!polyfillNeeded({\n      fetch: fetch,\n      Request: NativeRequest,\n      AbortController: NativeAbortController,\n      __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL: __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL\n    })) {\n      return {\n        fetch: fetch,\n        Request: Request\n      };\n    }\n\n    var Request = NativeRequest; // Note that the \"unfetch\" minimal fetch polyfill defines fetch() without\n    // defining window.Request, and this polyfill need to work on top of unfetch\n    // hence we only patch it if it's available. Also we don't patch it if signal\n    // is already available on the Request prototype because in this case support\n    // is present and the patching below can cause a crash since it assigns to\n    // request.signal which is technically a read-only property. This latter error\n    // happens when you run the main5.js node-fetch example in the repo\n    // \"abortcontroller-polyfill-examples\". The exact error is:\n    //   request.signal = init.signal;\n    //   ^\n    // TypeError: Cannot set property signal of #<Request> which has only a getter\n\n    if (Request && !Request.prototype.hasOwnProperty('signal') || __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {\n      Request = function Request(input, init) {\n        var signal;\n\n        if (init && init.signal) {\n          signal = init.signal; // Never pass init.signal to the native Request implementation when the polyfill has\n          // been installed because if we're running on top of a browser with a\n          // working native AbortController (i.e. the polyfill was installed due to\n          // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our\n          // fake AbortSignal to the native fetch will trigger:\n          // TypeError: Failed to construct 'Request': member signal is not of type AbortSignal.\n\n          delete init.signal;\n        }\n\n        var request = new NativeRequest(input, init);\n\n        if (signal) {\n          Object.defineProperty(request, 'signal', {\n            writable: false,\n            enumerable: false,\n            configurable: true,\n            value: signal\n          });\n        }\n\n        return request;\n      };\n\n      Request.prototype = NativeRequest.prototype;\n    }\n\n    var realFetch = fetch;\n\n    var abortableFetch = function abortableFetch(input, init) {\n      var signal = Request && Request.prototype.isPrototypeOf(input) ? input.signal : init ? init.signal : undefined;\n\n      if (signal) {\n        var abortError;\n\n        try {\n          abortError = new DOMException('Aborted', 'AbortError');\n        } catch (err) {\n          // IE 11 does not support calling the DOMException constructor, use a\n          // regular error object on it instead.\n          abortError = new Error('Aborted');\n          abortError.name = 'AbortError';\n        } // Return early if already aborted, thus avoiding making an HTTP request\n\n\n        if (signal.aborted) {\n          return Promise.reject(abortError);\n        } // Turn an event into a promise, reject it once `abort` is dispatched\n\n\n        var cancellation = new Promise(function (_, reject) {\n          signal.addEventListener('abort', function () {\n            return reject(abortError);\n          }, {\n            once: true\n          });\n        });\n\n        if (init && init.signal) {\n          // Never pass .signal to the native implementation when the polyfill has\n          // been installed because if we're running on top of a browser with a\n          // working native AbortController (i.e. the polyfill was installed due to\n          // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our\n          // fake AbortSignal to the native fetch will trigger:\n          // TypeError: Failed to execute 'fetch' on 'Window': member signal is not of type AbortSignal.\n          delete init.signal;\n        } // Return the fastest promise (don't need to wait for request to finish)\n\n\n        return Promise.race([cancellation, realFetch(input, init)]);\n      }\n\n      return realFetch(input, init);\n    };\n\n    return {\n      fetch: abortableFetch,\n      Request: Request\n    };\n  }\n\n  (function (self) {\n\n    if (!polyfillNeeded(self)) {\n      return;\n    }\n\n    if (!self.fetch) {\n      console.warn('fetch() is not available, cannot install abortcontroller-polyfill');\n      return;\n    }\n\n    var _abortableFetch = abortableFetchDecorator(self),\n        fetch = _abortableFetch.fetch,\n        Request = _abortableFetch.Request;\n\n    self.fetch = fetch;\n    self.Request = Request;\n    Object.defineProperty(self, 'AbortController', {\n      writable: true,\n      enumerable: false,\n      configurable: true,\n      value: AbortController\n    });\n    Object.defineProperty(self, 'AbortSignal', {\n      writable: true,\n      enumerable: false,\n      configurable: true,\n      value: AbortSignal\n    });\n  })(typeof self !== 'undefined' ? self : global);\n\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.github.io/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","'use strict';\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nvar path = require('../../internals/path');\n\nvar Promise = path.Promise;\nvar $allSettled = Promise.allSettled;\n\nmodule.exports = function allSettled(iterable) {\n  return $allSettled.call(typeof this === 'function' ? this : Promise, iterable);\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.github.io/ecma262/#sec-map-objects\nmodule.exports = collection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n","require('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.github.io/ecma262/#sec-set-objects\nmodule.exports = collection('Set', function (init) {\n  return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","// From https://developer.mozilla.org/en-US/docs/Web/API/ChildNode/replaceWith\nfunction ReplaceWithPolyfill() {\n  \"use-strict\"; // For safari, and IE > 10\n  var parent = this.parentNode,\n    i = arguments.length,\n    currentNode;\n  if (!parent) return;\n  if (!i)\n    // if there are no arguments\n    parent.removeChild(this);\n  while (i--) {\n    // i-- decrements i and returns the value of i before the decrement\n    currentNode = arguments[i];\n    if (typeof currentNode !== \"object\") {\n      currentNode = this.ownerDocument.createTextNode(currentNode);\n    } else if (currentNode.parentNode) {\n      currentNode.parentNode.removeChild(currentNode);\n    }\n    // the value of \"i\" below is after the decrement\n    if (!i)\n      // if currentNode is the first argument (currentNode === arguments[0])\n      parent.replaceChild(currentNode, this);\n    // if currentNode isn't the first\n    else parent.insertBefore(this.previousSibling, currentNode);\n  }\n}\n\nif (!Element.prototype.replaceWith)\n  Element.prototype.replaceWith = ReplaceWithPolyfill;\nif (!CharacterData.prototype.replaceWith)\n  CharacterData.prototype.replaceWith = ReplaceWithPolyfill;\nif (!DocumentType.prototype.replaceWith)\n  DocumentType.prototype.replaceWith = ReplaceWithPolyfill;\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, CONSTRUCTOR_NAME);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n    });\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(C.prototype, {\n      // 23.1.3.1 Map.prototype.clear()\n      // 23.2.3.2 Set.prototype.clear()\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // 23.1.3.3 Map.prototype.delete(key)\n      // 23.2.3.4 Set.prototype.delete(value)\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // 23.1.3.7 Map.prototype.has(key)\n      // 23.2.3.7 Set.prototype.has(value)\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(C.prototype, IS_MAP ? {\n      // 23.1.3.6 Map.prototype.get(key)\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // 23.1.3.9 Map.prototype.set(key, value)\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // 23.2.3.1 Set.prototype.add(value)\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(C.prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return C;\n  },\n  setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // add .keys, .values, .entries, [@@iterator]\n    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n    defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // add [@@species], 23.1.2.2, 23.2.2.2\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;","import {\n  getCLS,\n  getFCP,\n  getFID,\n  getLCP,\n  getTTFB,\n  Metric,\n  ReportHandler,\n} from 'next/dist/compiled/web-vitals'\n\nconst initialHref = location.href\nlet isRegistered = false\nlet userReportHandler: ReportHandler | undefined\n\nfunction onReport(metric: Metric) {\n  if (userReportHandler) {\n    userReportHandler(metric)\n  }\n\n  // This code is not shipped, executed, or present in the client-side\n  // JavaScript bundle unless explicitly enabled in your application.\n  //\n  // When this feature is enabled, we'll make it very clear by printing a\n  // message during the build (`next build`).\n  if (\n    process.env.NODE_ENV === 'production' &&\n    // This field is empty unless you explicitly configure it:\n    process.env.__NEXT_ANALYTICS_ID\n  ) {\n    const body: Record<string, string> = {\n      dsn: process.env.__NEXT_ANALYTICS_ID,\n      id: metric.id,\n      page: window.__NEXT_DATA__.page,\n      href: initialHref,\n      event_name: metric.name,\n      value: metric.value.toString(),\n      speed:\n        'connection' in navigator &&\n        navigator['connection'] &&\n        'effectiveType' in navigator['connection']\n          ? (navigator['connection']['effectiveType'] as string)\n          : '',\n    }\n\n    const blob = new Blob([new URLSearchParams(body).toString()], {\n      // This content type is necessary for `sendBeacon`:\n      type: 'application/x-www-form-urlencoded',\n    })\n    const vitalsUrl = 'https://vitals.vercel-insights.com/v1/vitals'\n    ;(navigator.sendBeacon && navigator.sendBeacon(vitalsUrl, blob)) ||\n      fetch(vitalsUrl, {\n        body: blob,\n        method: 'POST',\n        credentials: 'omit',\n        keepalive: true,\n      })\n  }\n}\n\nexport default (onPerfEntry?: ReportHandler) => {\n  // Update function if it changes:\n  userReportHandler = onPerfEntry\n\n  // Only register listeners once:\n  if (isRegistered) {\n    return\n  }\n  isRegistered = true\n\n  getCLS(onReport)\n  getFID(onReport)\n  getFCP(onReport)\n  getLCP(onReport)\n  getTTFB(onReport)\n}\n","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var nativeMethod = NativePrototype[KEY];\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        nativeMethod.call(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        nativeMethod.call(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  // eslint-disable-next-line max-len\n  if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n    new NativeConstructor().entries().next();\n  })))) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.REQUIRED = true;\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, Constructor, CONSTRUCTOR_NAME);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    INCORRECT_VALUES_NAME = true;\n    defaultIterator = function values() { return nativeIterator.call(this); };\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n  }\n  Iterators[NAME] = defaultIterator;\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  return methods;\n};\n","import 'intersection-observer'\nimport 'raf/polyfill'\n// import 'core-js/features/array/from'\n// import 'core-js'\n// import 'core-js/features/set'\n// import 'core-js/features/map'\nimport 'core-js/es/set'\nimport 'core-js/es/map'\nimport 'child-replace-with-polyfill'\nimport 'abortcontroller-polyfill/dist/polyfill-patch-fetch'\n// import 'core-js/features/promise'\nimport 'core-js/features/promise/all-settled'\n","'use strict';\nvar $ = require('../internals/export');\nvar aFunction = require('../internals/a-function');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://github.com/tc39/proposal-promise-allSettled\n$({ target: 'Promise', stat: true }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aFunction(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        promiseResolve.call(C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (e) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: e };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","require('../../modules/es.set');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Set;\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","module.exports=function(){var t={692:function(t,e){!function(t,n){true?n(e):0}(this,function(t){\"use strict\";var e,n,i=function(){return\"\".concat(Date.now(),\"-\").concat(Math.floor(8999999999999*Math.random())+1e12)},a=function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1;return{name:t,value:e,delta:0,entries:[],id:i(),isFinal:!1}},r=function(t,e){try{if(PerformanceObserver.supportedEntryTypes.includes(t)){var n=new PerformanceObserver(function(t){return t.getEntries().map(e)});return n.observe({type:t,buffered:!0}),n}}catch(t){}},o=!1,u=!1,s=function(t){o=!t.persisted},c=function(){addEventListener(\"pagehide\",s),addEventListener(\"beforeunload\",function(){})},p=function(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1];u||(c(),u=!0),addEventListener(\"visibilitychange\",function(e){var n=e.timeStamp;\"hidden\"===document.visibilityState&&t({timeStamp:n,isUnloading:o})},{capture:!0,once:e})},l=function(t,e,n,i){var a;return function(){n&&e.isFinal&&n.disconnect(),e.value>=0&&(i||e.isFinal||\"hidden\"===document.visibilityState)&&(e.delta=e.value-(a||0),(e.delta||e.isFinal||void 0===a)&&(t(e),a=e.value))}},f=function(){return void 0===e&&(e=\"hidden\"===document.visibilityState?0:1/0,p(function(t){var n=t.timeStamp;return e=n},!0)),{get timeStamp(){return e}}},d=function(){return n||(n=new Promise(function(t){return[\"scroll\",\"keydown\",\"pointerdown\"].map(function(e){addEventListener(e,t,{once:!0,passive:!0,capture:!0})})})),n};t.getCLS=function(t){var e,n=arguments.length>1&&void 0!==arguments[1]&&arguments[1],i=a(\"CLS\",0),o=function(t){t.hadRecentInput||(i.value+=t.value,i.entries.push(t),e())},u=r(\"layout-shift\",o);u&&(e=l(t,i,u,n),p(function(t){var n=t.isUnloading;u.takeRecords().map(o),n&&(i.isFinal=!0),e()}))},t.getFCP=function(t){var e,n=a(\"FCP\"),i=f(),o=r(\"paint\",function(t){\"first-contentful-paint\"===t.name&&t.startTime<i.timeStamp&&(n.value=t.startTime,n.isFinal=!0,n.entries.push(t),e())});o&&(e=l(t,n,o))},t.getFID=function(t){var e=a(\"FID\"),n=f(),i=function(t){t.startTime<n.timeStamp&&(e.value=t.processingStart-t.startTime,e.entries.push(t),e.isFinal=!0,u())},o=r(\"first-input\",i),u=l(t,e,o);o?p(function(){o.takeRecords().map(i),o.disconnect()},!0):window.perfMetrics&&window.perfMetrics.onFirstInputDelay&&window.perfMetrics.onFirstInputDelay(function(t,i){i.timeStamp<n.timeStamp&&(e.value=t,e.isFinal=!0,e.entries=[{entryType:\"first-input\",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+t}],u())})},t.getLCP=function(t){var e,n=arguments.length>1&&void 0!==arguments[1]&&arguments[1],i=a(\"LCP\"),o=f(),u=function(t){var n=t.startTime;n<o.timeStamp?(i.value=n,i.entries.push(t)):i.isFinal=!0,e()},s=r(\"largest-contentful-paint\",u);if(s){e=l(t,i,s,n);var c=function(){i.isFinal||(s.takeRecords().map(u),i.isFinal=!0,e())};d().then(c),p(c,!0)}},t.getTTFB=function(t){var e,n=a(\"TTFB\");e=function(){try{var e=performance.getEntriesByType(\"navigation\")[0]||function(){var t=performance.timing,e={entryType:\"navigation\",startTime:0};for(var n in t)\"navigationStart\"!==n&&\"toJSON\"!==n&&(e[n]=Math.max(t[n]-t.navigationStart,0));return e}();n.value=n.delta=e.responseStart,n.entries=[e],n.isFinal=!0,t(n)}catch(t){}},\"complete\"===document.readyState?setTimeout(e,0):addEventListener(\"pageshow\",e)},Object.defineProperty(t,\"__esModule\",{value:!0})})}};var e={};function __webpack_require__(n){if(e[n]){return e[n].exports}var i=e[n]={exports:{}};var a=true;try{t[n].call(i.exports,i,i.exports,__webpack_require__);a=false}finally{if(a)delete e[n]}return i.exports}__webpack_require__.ab=__dirname+\"/\";return __webpack_require__(692)}();","function _extends() {\n  module.exports = _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nmodule.exports = _extends;","'use strict';\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nif (IteratorPrototype == undefined) IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nif (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {\n  createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n","let runtimeConfig: any\n\nexport default () => {\n  return runtimeConfig\n}\n\nexport function setConfig(configValue: any): void {\n  runtimeConfig = configValue\n}\n","import { ComponentType } from 'react'\nimport type { ClientSsgManifest } from '../build'\nimport {\n  addBasePath,\n  addLocale,\n  interpolateAs,\n} from '../next-server/lib/router/router'\nimport getAssetPathFromRoute from '../next-server/lib/router/utils/get-asset-path-from-route'\nimport { isDynamicRoute } from '../next-server/lib/router/utils/is-dynamic'\nimport { parseRelativeUrl } from '../next-server/lib/router/utils/parse-relative-url'\nimport createRouteLoader, {\n  getClientBuildManifest,\n  RouteLoader,\n} from './route-loader'\n\nfunction normalizeRoute(route: string) {\n  if (route[0] !== '/') {\n    throw new Error(`Route name should start with a \"/\", got \"${route}\"`)\n  }\n\n  if (route === '/') return route\n  return route.replace(/\\/$/, '')\n}\n\nexport type StyleSheetTuple = { href: string; text: string }\nexport type GoodPageCache = {\n  page: ComponentType\n  mod: any\n  styleSheets: StyleSheetTuple[]\n}\n\nexport default class PageLoader {\n  private buildId: string\n  private assetPrefix: string\n\n  private promisedSsgManifest?: Promise<ClientSsgManifest>\n  private promisedDevPagesManifest?: Promise<any>\n  public routeLoader: RouteLoader\n\n  constructor(buildId: string, assetPrefix: string) {\n    this.routeLoader = createRouteLoader(assetPrefix)\n\n    this.buildId = buildId\n    this.assetPrefix = assetPrefix\n\n    /** @type {Promise<Set<string>>} */\n    this.promisedSsgManifest = new Promise((resolve) => {\n      if ((window as any).__SSG_MANIFEST) {\n        resolve((window as any).__SSG_MANIFEST)\n      } else {\n        ;(window as any).__SSG_MANIFEST_CB = () => {\n          resolve((window as any).__SSG_MANIFEST)\n        }\n      }\n    })\n  }\n\n  getPageList() {\n    if (process.env.NODE_ENV === 'production') {\n      return getClientBuildManifest().then((manifest) => manifest.sortedPages)\n    } else {\n      if ((window as any).__DEV_PAGES_MANIFEST) {\n        return (window as any).__DEV_PAGES_MANIFEST.pages\n      } else {\n        if (!this.promisedDevPagesManifest) {\n          this.promisedDevPagesManifest = fetch(\n            `${this.assetPrefix}/_next/static/development/_devPagesManifest.json`\n          )\n            .then((res) => res.json())\n            .then((manifest) => {\n              ;(window as any).__DEV_PAGES_MANIFEST = manifest\n              return manifest.pages\n            })\n            .catch((err) => {\n              console.log(`Failed to fetch devPagesManifest`, err)\n            })\n        }\n        return this.promisedDevPagesManifest\n      }\n    }\n  }\n\n  /**\n   * @param {string} href the route href (file-system path)\n   * @param {string} asPath the URL as shown in browser (virtual path); used for dynamic routes\n   */\n  getDataHref(\n    href: string,\n    asPath: string,\n    ssg: boolean,\n    locale?: string | false\n  ) {\n    const { pathname: hrefPathname, query, search } = parseRelativeUrl(href)\n    const { pathname: asPathname } = parseRelativeUrl(asPath)\n    const route = normalizeRoute(hrefPathname)\n\n    const getHrefForSlug = (path: string) => {\n      const dataRoute = getAssetPathFromRoute(addLocale(path, locale), '.json')\n      return addBasePath(\n        `/_next/data/${this.buildId}${dataRoute}${ssg ? '' : search}`\n      )\n    }\n\n    const isDynamic: boolean = isDynamicRoute(route)\n    const interpolatedRoute = isDynamic\n      ? interpolateAs(hrefPathname, asPathname, query).result\n      : ''\n\n    return isDynamic\n      ? interpolatedRoute && getHrefForSlug(interpolatedRoute)\n      : getHrefForSlug(route)\n  }\n\n  /**\n   * @param {string} href the route href (file-system path)\n   */\n  _isSsg(href: string): Promise<boolean> {\n    const { pathname: hrefPathname } = parseRelativeUrl(href)\n    const route = normalizeRoute(hrefPathname)\n    return this.promisedSsgManifest!.then((s: ClientSsgManifest) =>\n      s.has(route)\n    )\n  }\n\n  loadPage(route: string): Promise<GoodPageCache> {\n    return this.routeLoader.loadRoute(route).then((res) => {\n      if ('component' in res) {\n        return {\n          page: res.component,\n          mod: res.exports,\n          styleSheets: res.styles.map((o) => ({\n            href: o.href,\n            text: o.content,\n          })),\n        }\n      }\n      throw res.error\n    })\n  }\n\n  prefetch(route: string): Promise<void> {\n    return this.routeLoader.prefetch(route)\n  }\n}\n"],"sourceRoot":""}