[Summary view] [Print] [Text view]

   1  /* ES Module Shims Wasm 1.8.2 */
   2  (function () {
   3  
   4    const hasWindow = typeof window !== 'undefined';
   5    const hasDocument = typeof document !== 'undefined';
   6  
   7    const noop = () => {};
   8  
   9    const optionsScript = hasDocument ? document.querySelector('script[type=esms-options]') : undefined;
  10  
  11    const esmsInitOptions = optionsScript ? JSON.parse(optionsScript.innerHTML) : {};
  12    Object.assign(esmsInitOptions, self.esmsInitOptions || {});
  13  
  14    let shimMode = hasDocument ? !!esmsInitOptions.shimMode : true;
  15  
  16    const importHook = globalHook(shimMode && esmsInitOptions.onimport);
  17    const resolveHook = globalHook(shimMode && esmsInitOptions.resolve);
  18    let fetchHook = esmsInitOptions.fetch ? globalHook(esmsInitOptions.fetch) : fetch;
  19    const metaHook = esmsInitOptions.meta ? globalHook(shimMode && esmsInitOptions.meta) : noop;
  20  
  21    const mapOverrides = esmsInitOptions.mapOverrides;
  22  
  23    let nonce = esmsInitOptions.nonce;
  24    if (!nonce && hasDocument) {
  25      const nonceElement = document.querySelector('script[nonce]');
  26      if (nonceElement)
  27        nonce = nonceElement.nonce || nonceElement.getAttribute('nonce');
  28    }
  29  
  30    const onerror = globalHook(esmsInitOptions.onerror || noop);
  31    const onpolyfill = esmsInitOptions.onpolyfill ? globalHook(esmsInitOptions.onpolyfill) : () => {
  32      console.log('%c^^ Module TypeError above is polyfilled and can be ignored ^^', 'font-weight:900;color:#391');
  33    };
  34  
  35    const { revokeBlobURLs, noLoadEventRetriggers, enforceIntegrity } = esmsInitOptions;
  36  
  37    function globalHook (name) {
  38      return typeof name === 'string' ? self[name] : name;
  39    }
  40  
  41    const enable = Array.isArray(esmsInitOptions.polyfillEnable) ? esmsInitOptions.polyfillEnable : [];
  42    const cssModulesEnabled = enable.includes('css-modules');
  43    const jsonModulesEnabled = enable.includes('json-modules');
  44  
  45    const edge = !navigator.userAgentData && !!navigator.userAgent.match(/Edge\/\d+\.\d+/);
  46  
  47    const baseUrl = hasDocument
  48      ? document.baseURI
  49      : `$location.protocol}//${location.host}${location.pathname.includes('/') 

  50      ? location.pathname.slice(0, location.pathname.lastIndexOf('/') + 1) 
  51      : location.pathname}`;
  52  
  53    const createBlob = (source, type = 'text/javascript') => URL.createObjectURL(new Blob([source], { type }));
  54    let { skip } = esmsInitOptions;
  55    if (Array.isArray(skip)) {
  56      const l = skip.map(s => new URL(s, baseUrl).href);
  57      skip = s => l.some(i => i[i.length - 1] === '/' && s.startsWith(i) || s === i);
  58    }
  59    else if (typeof skip === 'string') {
  60      const r = new RegExp(skip);
  61      skip = s => r.test(s);
  62    } else if (skip instanceof RegExp) {
  63      skip = s => skip.test(s);
  64    }
  65  
  66    const eoop = err => setTimeout(() => { throw err });
  67  
  68    const throwError = err => { (self.reportError || hasWindow && window.safari && console.error || eoop)(err), void onerror(err); };
  69  
  70    function fromParent (parent) {
  71      return parent ? ` imported from $parent}` : '';
  72    }
  73  
  74    let importMapSrcOrLazy = false;
  75  
  76    function setImportMapSrcOrLazy () {
  77      importMapSrcOrLazy = true;
  78    }
  79  
  80    // shim mode is determined on initialization, no late shim mode

  81    if (!shimMode) {
  82      if (document.querySelectorAll('script[type=module-shim],script[type=importmap-shim],link[rel=modulepreload-shim]').length) {
  83        shimMode = true;
  84      }
  85      else {
  86        let seenScript = false;
  87        for (const script of document.querySelectorAll('script[type=module],script[type=importmap]')) {
  88          if (!seenScript) {
  89            if (script.type === 'module' && !script.ep)
  90              seenScript = true;
  91          }
  92          else if (script.type === 'importmap' && seenScript) {
  93            importMapSrcOrLazy = true;
  94            break;
  95          }
  96        }
  97      }
  98    }
  99  
 100    const backslashRegEx = /\\/g;
 101  
 102    function asURL (url) {
 103      try {
 104        if (url.indexOf(':') !== -1)
 105          return new URL(url).href;
 106      }
 107      catch (_) {}
 108    }
 109  
 110    function resolveUrl (relUrl, parentUrl) {
 111      return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (asURL(relUrl) || resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
 112    }
 113  
 114    function resolveIfNotPlainOrUrl (relUrl, parentUrl) {
 115      const hIdx = parentUrl.indexOf('#'), qIdx = parentUrl.indexOf('?');
 116      if (hIdx + qIdx > -2)
 117        parentUrl = parentUrl.slice(0, hIdx === -1 ? qIdx : qIdx === -1 || qIdx > hIdx ? hIdx : qIdx);
 118      if (relUrl.indexOf('\\') !== -1)
 119        relUrl = relUrl.replace(backslashRegEx, '/');
 120      // protocol-relative

 121      if (relUrl[0] === '/' && relUrl[1] === '/') {
 122        return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
 123      }
 124      // relative-url

 125      else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) ||
 126          relUrl.length === 1  && (relUrl += '/')) ||
 127          relUrl[0] === '/') {
 128        const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
 129        if (parentProtocol === 'blob:') {
 130          throw new TypeError(`Failed to resolve module specifier "$relUrl}". Invalid relative url or base scheme isn't hierarchical.`);
 131        }
 132        // Disabled, but these cases will give inconsistent results for deep backtracking

 133        //if (parentUrl[parentProtocol.length] !== '/')

 134        //  throw new Error('Cannot resolve');

 135        // read pathname from parent URL

 136        // pathname taken to be part after leading "/"

 137        let pathname;
 138        if (parentUrl[parentProtocol.length + 1] === '/') {
 139          // resolving to a :// so we need to read out the auth and host

 140          if (parentProtocol !== 'file:') {
 141            pathname = parentUrl.slice(parentProtocol.length + 2);
 142            pathname = pathname.slice(pathname.indexOf('/') + 1);
 143          }
 144          else {
 145            pathname = parentUrl.slice(8);
 146          }
 147        }
 148        else {
 149          // resolving to :/ so pathname is the /... part

 150          pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/'));
 151        }
 152  
 153        if (relUrl[0] === '/')
 154          return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
 155  
 156        // join together and split for removal of .. and . segments

 157        // looping the string instead of anything fancy for perf reasons

 158        // '../../../../../z' resolved to 'x/y' is just 'z'

 159        const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
 160  
 161        const output = [];
 162        let segmentIndex = -1;
 163        for (let i = 0; i < segmented.length; i++) {
 164          // busy reading a segment - only terminate on '/'

 165          if (segmentIndex !== -1) {
 166            if (segmented[i] === '/') {
 167              output.push(segmented.slice(segmentIndex, i + 1));
 168              segmentIndex = -1;
 169            }
 170            continue;
 171          }
 172          // new segment - check if it is relative

 173          else if (segmented[i] === '.') {
 174            // ../ segment

 175            if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
 176              output.pop();
 177              i += 2;
 178              continue;
 179            }
 180            // ./ segment

 181            else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
 182              i += 1;
 183              continue;
 184            }
 185          }
 186          // it is the start of a new segment

 187          while (segmented[i] === '/') i++;
 188          segmentIndex = i; 
 189        }
 190        // finish reading out the last segment

 191        if (segmentIndex !== -1)
 192          output.push(segmented.slice(segmentIndex));
 193        return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
 194      }
 195    }
 196  
 197    function resolveAndComposeImportMap (json, baseUrl, parentMap) {
 198      const outMap = { imports: Object.assign({}, parentMap.imports), scopes: Object.assign({}, parentMap.scopes) };
 199  
 200      if (json.imports)
 201        resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap);
 202  
 203      if (json.scopes)
 204        for (let s in json.scopes) {
 205          const resolvedScope = resolveUrl(s, baseUrl);
 206          resolveAndComposePackages(json.scopes[s], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, parentMap);
 207        }
 208  
 209      return outMap;
 210    }
 211  
 212    function getMatch (path, matchObj) {
 213      if (matchObj[path])
 214        return path;
 215      let sepIndex = path.length;
 216      do {
 217        const segment = path.slice(0, sepIndex + 1);
 218        if (segment in matchObj)
 219          return segment;
 220      } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1)
 221    }
 222  
 223    function applyPackages (id, packages) {
 224      const pkgName = getMatch(id, packages);
 225      if (pkgName) {
 226        const pkg = packages[pkgName];
 227        if (pkg === null) return;
 228        return pkg + id.slice(pkgName.length);
 229      }
 230    }
 231  
 232  
 233    function resolveImportMap (importMap, resolvedOrPlain, parentUrl) {
 234      let scopeUrl = parentUrl && getMatch(parentUrl, importMap.scopes);
 235      while (scopeUrl) {
 236        const packageResolution = applyPackages(resolvedOrPlain, importMap.scopes[scopeUrl]);
 237        if (packageResolution)
 238          return packageResolution;
 239        scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), importMap.scopes);
 240      }
 241      return applyPackages(resolvedOrPlain, importMap.imports) || resolvedOrPlain.indexOf(':') !== -1 && resolvedOrPlain;
 242    }
 243  
 244    function resolveAndComposePackages (packages, outPackages, baseUrl, parentMap) {
 245      for (let p in packages) {
 246        const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
 247        if ((!shimMode || !mapOverrides) && outPackages[resolvedLhs] && (outPackages[resolvedLhs] !== packages[resolvedLhs])) {
 248          throw Error(`Rejected map override "$resolvedLhs}" from $outPackages[resolvedLhs]} to $packages[resolvedLhs]}.`);
 249        }
 250        let target = packages[p];
 251        if (typeof target !== 'string')
 252          continue;
 253        const mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(target, baseUrl) || target, baseUrl);
 254        if (mapped) {
 255          outPackages[resolvedLhs] = mapped;
 256          continue;
 257        }
 258        console.warn(`Mapping "$p}" -> "$packages[p]}" does not resolve`);
 259      }
 260    }
 261  
 262    let dynamicImport = !hasDocument && (0, eval)('u=>import(u)');
 263  
 264    let supportsDynamicImport;
 265  
 266    const dynamicImportCheck = hasDocument && new Promise(resolve => {
 267      const s = Object.assign(document.createElement('script'), {
 268        src: createBlob('self._d=u=>import(u)'),
 269        ep: true
 270      });
 271      s.setAttribute('nonce', nonce);
 272      s.addEventListener('load', () => {
 273        if (!(supportsDynamicImport = !!(dynamicImport = self._d))) {
 274          let err;
 275          window.addEventListener('error', _err => err = _err);
 276          dynamicImport = (url, opts) => new Promise((resolve, reject) => {
 277            const s = Object.assign(document.createElement('script'), {
 278              type: 'module',
 279              src: createBlob(`import*as m from'$url}';self._esmsi=m`)
 280            });
 281            err = undefined;
 282            s.ep = true;
 283            if (nonce)
 284              s.setAttribute('nonce', nonce);
 285            // Safari is unique in supporting module script error events

 286            s.addEventListener('error', cb);
 287            s.addEventListener('load', cb);
 288            function cb (_err) {
 289              document.head.removeChild(s);
 290              if (self._esmsi) {
 291                resolve(self._esmsi, baseUrl);
 292                self._esmsi = undefined;
 293              }
 294              else {
 295                reject(!(_err instanceof Event) && _err || err && err.error || new Error(`Error loading $opts && opts.errUrl || url} ($s.src}).`));
 296                err = undefined;
 297              }
 298            }
 299            document.head.appendChild(s);
 300          });
 301        }
 302        document.head.removeChild(s);
 303        delete self._d;
 304        resolve();
 305      });
 306      document.head.appendChild(s);
 307    });
 308  
 309    // support browsers without dynamic import support (eg Firefox 6x)

 310    let supportsJsonAssertions = false;
 311    let supportsCssAssertions = false;
 312  
 313    const supports = hasDocument && HTMLScriptElement.supports;
 314  
 315    let supportsImportMaps = supports && supports.name === 'supports' && supports('importmap');
 316    let supportsImportMeta = supportsDynamicImport;
 317  
 318    const importMetaCheck = 'import.meta';
 319    const cssModulesCheck = `import"x"assert{type:"css"}`;
 320    const jsonModulesCheck = `import"x"assert{type:"json"}`;
 321  
 322    let featureDetectionPromise = Promise.resolve(dynamicImportCheck).then(() => {
 323      if (!supportsDynamicImport)
 324        return;
 325  
 326      if (!hasDocument)
 327        return Promise.all([
 328          supportsImportMaps || dynamicImport(createBlob(importMetaCheck)).then(() => supportsImportMeta = true, noop),
 329          cssModulesEnabled && dynamicImport(createBlob(cssModulesCheck.replace('x', createBlob('', 'text/css')))).then(() => supportsCssAssertions = true, noop),
 330          jsonModulesEnabled && dynamicImport(createBlob(jsonModulescheck.replace('x', createBlob('{}', 'text/json')))).then(() => supportsJsonAssertions = true, noop),
 331        ]);
 332  
 333      return new Promise(resolve => {
 334        const iframe = document.createElement('iframe');
 335        iframe.style.display = 'none';
 336        iframe.setAttribute('nonce', nonce);
 337        function cb ({ data }) {
 338          const isFeatureDetectionMessage = Array.isArray(data) && data[0] === 'esms';
 339          if (!isFeatureDetectionMessage) {
 340            return;
 341          }
 342          supportsImportMaps = data[1];
 343          supportsImportMeta = data[2];
 344          supportsCssAssertions = data[3];
 345          supportsJsonAssertions = data[4];
 346          resolve();
 347          document.head.removeChild(iframe);
 348          window.removeEventListener('message', cb, false);
 349        }
 350        window.addEventListener('message', cb, false);
 351  
 352        const importMapTest = `<script nonce=$nonce || ''}>b=(s,type='text/javascript')=>URL.createObjectURL(new Blob([s],{type}));document.head.appendChild(Object.assign(document.createElement('script'),{type:'importmap',nonce:"$nonce}",innerText:\`{"imports":{"x":"\$b('')}"}}\`}));Promise.all([${
 353        supportsImportMaps ? 'true,true' : `'x',b('$importMetaCheck}')`}, $cssModulesEnabled ? `b('$cssModulesCheck}'.replace('x',b('','text/css')))` : 'false'}, ${
 354        jsonModulesEnabled ? `b('$jsonModulesCheck}'.replace('x',b('{}','text/json')))` : 'false'}].map(x =>typeof x==='string'?import(x).then(x =>!!x,()=>false):x)).then(a=>parent.postMessage(['esms'].concat(a),'*'))<${''}/script>`;
 355  
 356        // Safari will call onload eagerly on head injection, but we don't want the Wechat

 357        // path to trigger before setting srcdoc, therefore we track the timing

 358        let readyForOnload = false, onloadCalledWhileNotReady = false;
 359        function doOnload () {
 360          if (!readyForOnload) {
 361            onloadCalledWhileNotReady = true;
 362            return;
 363          }
 364          // WeChat browser doesn't support setting srcdoc scripts

 365          // But iframe sandboxes don't support contentDocument so we do this as a fallback

 366          const doc = iframe.contentDocument;
 367          if (doc && doc.head.childNodes.length === 0) {
 368            const s = doc.createElement('script');
 369            if (nonce)
 370              s.setAttribute('nonce', nonce);
 371            s.innerHTML = importMapTest.slice(15 + (nonce ? nonce.length : 0), -9);
 372            doc.head.appendChild(s);
 373          }
 374        }
 375  
 376        iframe.onload = doOnload;
 377        // WeChat browser requires append before setting srcdoc

 378        document.head.appendChild(iframe);
 379  
 380        // setting srcdoc is not supported in React native webviews on iOS

 381        // setting src to a blob URL results in a navigation event in webviews

 382        // document.write gives usability warnings

 383        readyForOnload = true;
 384        if ('srcdoc' in iframe)
 385          iframe.srcdoc = importMapTest;
 386        else
 387          iframe.contentDocument.write(importMapTest);
 388        // retrigger onload for Safari only if necessary

 389        if (onloadCalledWhileNotReady) doOnload();
 390      });
 391    });
 392  
 393    /* es-module-lexer 1.4.1 */
 394    const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(E,g="@"){if(!C)return init.then((()=>parse(E)));const I=E.length+1,k=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;k>0&&C.memory.grow(Math.ceil(k/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error $g}:$E.slice(0,C.e()).split("\n").length}:$C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const o=[],D=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.ai(),g=C.id(),I=C.ss(),k=C.se();let K;C.ip()&&(K=w(E.slice(-1===g?A-1:A,-1===g?Q+1:Q))),o.push({n:K,s:A,e:Q,ss:I,se:k,d:g,a:B});}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),k=I[0],K=B<0?void 0:E.slice(B,g),o=K?K[0]:"";D.push({s:A,e:Q,ls:B,le:g,n:'"'===k||"'"===k?w(I):I,ln:'"'===o||"'"===o?w(K):K});}function w(A){try{return (0,eval)(A)}catch(A){}}return [o,D,!!C.f(),!!C.ms()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const init=WebAssembly.compile((E="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","undefined"!=typeof Buffer?Buffer.from(E,"base64"):Uint8Array.from(atob(E),(A=>A.charCodeAt(0))))).then(WebAssembly.instantiate).then((({exports:A})=>{C=A;}));var E;
 395  
 396    async function _resolve (id, parentUrl) {
 397      const urlResolved = resolveIfNotPlainOrUrl(id, parentUrl) || asURL(id);
 398      return {
 399        r: resolveImportMap(importMap, urlResolved || id, parentUrl) || throwUnresolved(id, parentUrl),
 400        // b = bare specifier

 401        b: !urlResolved && !asURL(id)
 402      };
 403    }
 404  
 405    const resolve = resolveHook ? async (id, parentUrl) => {
 406      let result = resolveHook(id, parentUrl, defaultResolve);
 407      // will be deprecated in next major

 408      if (result && result.then)
 409        result = await result;
 410      return result ? { r: result, b: !resolveIfNotPlainOrUrl(id, parentUrl) && !asURL(id) } : _resolve(id, parentUrl);
 411    } : _resolve;
 412  
 413    // importShim('mod');

 414    // importShim('mod', { opts });

 415    // importShim('mod', { opts }, parentUrl);

 416    // importShim('mod', parentUrl);

 417    async function importShim (id, ...args) {
 418      // parentUrl if present will be the last argument

 419      let parentUrl = args[args.length - 1];
 420      if (typeof parentUrl !== 'string')
 421        parentUrl = baseUrl;
 422      // needed for shim check

 423      await initPromise;
 424      if (importHook) await importHook(id, typeof args[1] !== 'string' ? args[1] : {}, parentUrl);
 425      if (acceptingImportMaps || shimMode || !baselinePassthrough) {
 426        if (hasDocument)
 427          processScriptsAndPreloads(true);
 428        if (!shimMode)
 429          acceptingImportMaps = false;
 430      }
 431      await importMapPromise;
 432      return topLevelLoad((await resolve(id, parentUrl)).r, { credentials: 'same-origin' });
 433    }
 434  
 435    self.importShim = importShim;
 436  
 437    function defaultResolve (id, parentUrl) {
 438      return resolveImportMap(importMap, resolveIfNotPlainOrUrl(id, parentUrl) || id, parentUrl) || throwUnresolved(id, parentUrl);
 439    }
 440  
 441    function throwUnresolved (id, parentUrl) {
 442      throw Error(`Unable to resolve specifier '$id}'$fromParent(parentUrl)}`);
 443    }
 444  
 445    const resolveSync = (id, parentUrl = baseUrl) => {
 446      parentUrl = `$parentUrl}`;
 447      const result = resolveHook && resolveHook(id, parentUrl, defaultResolve);
 448      return result && !result.then ? result : defaultResolve(id, parentUrl);
 449    };
 450  
 451    function metaResolve (id, parentUrl = this.url) {
 452      return resolveSync(id, parentUrl);
 453    }
 454  
 455    importShim.resolve = resolveSync;
 456    importShim.getImportMap = () => JSON.parse(JSON.stringify(importMap));
 457    importShim.addImportMap = importMapIn => {
 458      if (!shimMode) throw new Error('Unsupported in polyfill mode.');
 459      importMap = resolveAndComposeImportMap(importMapIn, baseUrl, importMap);
 460    };
 461  
 462    const registry = importShim._r = {};
 463    importShim._w = {};
 464  
 465    async function loadAll (load, seen) {
 466      if (load.b || seen[load.u])
 467        return;
 468      seen[load.u] = 1;
 469      await load.L;
 470      await Promise.all(load.d.map(dep => loadAll(dep, seen)));
 471      if (!load.n)
 472        load.n = load.d.some(dep => dep.n);
 473    }
 474  
 475    let importMap = { imports: {}, scopes: {} };
 476    let baselinePassthrough;
 477  
 478    const initPromise = featureDetectionPromise.then(() => {
 479      baselinePassthrough = esmsInitOptions.polyfillEnable !== true && supportsDynamicImport && supportsImportMeta && supportsImportMaps && (!jsonModulesEnabled || supportsJsonAssertions) && (!cssModulesEnabled || supportsCssAssertions) && !importMapSrcOrLazy;
 480      if (hasDocument) {
 481        if (!supportsImportMaps) {
 482          const supports = HTMLScriptElement.supports || (type => type === 'classic' || type === 'module');
 483          HTMLScriptElement.supports = type => type === 'importmap' || supports(type);
 484        }
 485        if (shimMode || !baselinePassthrough) {
 486          new MutationObserver(mutations => {
 487            for (const mutation of mutations) {
 488              if (mutation.type !== 'childList') continue;
 489              for (const node of mutation.addedNodes) {
 490                if (node.tagName === 'SCRIPT') {
 491                  if (node.type === (shimMode ? 'module-shim' : 'module'))
 492                    processScript(node, true);
 493                  if (node.type === (shimMode ? 'importmap-shim' : 'importmap'))
 494                    processImportMap(node, true);
 495                }
 496                else if (node.tagName === 'LINK' && node.rel === (shimMode ? 'modulepreload-shim' : 'modulepreload')) {
 497                  processPreload(node);
 498                }
 499              }
 500            }
 501          }).observe(document, {childList: true, subtree: true});
 502          processScriptsAndPreloads();
 503          if (document.readyState === 'complete') {
 504            readyStateCompleteCheck();
 505          }
 506          else {
 507            async function readyListener() {
 508              await initPromise;
 509              processScriptsAndPreloads();
 510              if (document.readyState === 'complete') {
 511                readyStateCompleteCheck();
 512                document.removeEventListener('readystatechange', readyListener);
 513              }
 514            }
 515            document.addEventListener('readystatechange', readyListener);
 516          }
 517        }
 518      }
 519      return init;
 520    });
 521    let importMapPromise = initPromise;
 522    let firstPolyfillLoad = true;
 523    let acceptingImportMaps = true;
 524  
 525    async function topLevelLoad (url, fetchOpts, source, nativelyLoaded, lastStaticLoadPromise) {
 526      if (!shimMode)
 527        acceptingImportMaps = false;
 528      await initPromise;
 529      await importMapPromise;
 530      if (importHook) await importHook(url, typeof fetchOpts !== 'string' ? fetchOpts : {}, '');
 531      // early analysis opt-out - no need to even fetch if we have feature support

 532      if (!shimMode && baselinePassthrough) {
 533        // for polyfill case, only dynamic import needs a return value here, and dynamic import will never pass nativelyLoaded

 534        if (nativelyLoaded)
 535          return null;
 536        await lastStaticLoadPromise;
 537        return dynamicImport(source ? createBlob(source) : url, { errUrl: url || source });
 538      }
 539      const load = getOrCreateLoad(url, fetchOpts, null, source);
 540      const seen = {};
 541      await loadAll(load, seen);
 542      lastLoad = undefined;
 543      resolveDeps(load, seen);
 544      await lastStaticLoadPromise;
 545      if (source && !shimMode && !load.n) {
 546        if (nativelyLoaded) return;
 547        if (revokeBlobURLs) revokeObjectURLs(Object.keys(seen));
 548        return await dynamicImport(createBlob(source), { errUrl: source });
 549      }
 550      if (firstPolyfillLoad && !shimMode && load.n && nativelyLoaded) {
 551        onpolyfill();
 552        firstPolyfillLoad = false;
 553      }
 554      const module = await dynamicImport(!shimMode && !load.n && nativelyLoaded ? load.u : load.b, { errUrl: load.u });
 555      // if the top-level load is a shell, run its update function

 556      if (load.s)
 557        (await dynamicImport(load.s)).u$_(module);
 558      if (revokeBlobURLs) revokeObjectURLs(Object.keys(seen));
 559      // when tla is supported, this should return the tla promise as an actual handle

 560      // so readystate can still correspond to the sync subgraph exec completions

 561      return module;
 562    }
 563  
 564    function revokeObjectURLs(registryKeys) {
 565      let batch = 0;
 566      const keysLength = registryKeys.length;
 567      const schedule = self.requestIdleCallback ? self.requestIdleCallback : self.requestAnimationFrame;
 568      schedule(cleanup);
 569      function cleanup() {
 570        const batchStartIndex = batch * 100;
 571        if (batchStartIndex > keysLength) return
 572        for (const key of registryKeys.slice(batchStartIndex, batchStartIndex + 100)) {
 573          const load = registry[key];
 574          if (load) URL.revokeObjectURL(load.b);
 575        }
 576        batch++;
 577        schedule(cleanup);
 578      }
 579    }
 580  
 581    function urlJsString (url) {
 582      return `'$url.replace(/'/g, "\\'")}'`;
 583    }
 584  
 585    let lastLoad;
 586    function resolveDeps (load, seen) {
 587      if (load.b || !seen[load.u])
 588        return;
 589      seen[load.u] = 0;
 590  
 591      for (const dep of load.d)
 592        resolveDeps(dep, seen);
 593  
 594      const [imports, exports] = load.a;
 595  
 596      // "execution"

 597      const source = load.S;
 598  
 599      // edge doesnt execute sibling in order, so we fix this up by ensuring all previous executions are explicit dependencies

 600      let resolvedSource = edge && lastLoad ? `import '$lastLoad}';` : '';
 601  
 602      // once all deps have loaded we can inline the dependency resolution blobs

 603      // and define this blob

 604      let lastIndex = 0, depIndex = 0, dynamicImportEndStack = [];
 605      function pushStringTo (originalIndex) {
 606        while (dynamicImportEndStack[dynamicImportEndStack.length - 1] < originalIndex) {
 607          const dynamicImportEnd = dynamicImportEndStack.pop();
 608          resolvedSource += `$source.slice(lastIndex, dynamicImportEnd)}, $urlJsString(load.r)}`;
 609          lastIndex = dynamicImportEnd;
 610        }
 611        resolvedSource += source.slice(lastIndex, originalIndex);
 612        lastIndex = originalIndex;
 613      }
 614  
 615      for (const { s: start, ss: statementStart, se: statementEnd, d: dynamicImportIndex } of imports) {
 616        // dependency source replacements

 617        if (dynamicImportIndex === -1) {
 618          let depLoad = load.d[depIndex++], blobUrl = depLoad.b, cycleShell = !blobUrl;
 619          if (cycleShell) {
 620            // circular shell creation

 621            if (!(blobUrl = depLoad.s)) {
 622              blobUrl = depLoad.s = createBlob(`export function u$_(m){${
 623              depLoad.a[1].map(({ s, e }, i) => {
 624                const q = depLoad.S[s] === '"' || depLoad.S[s] === "'";
 625                return `e$_$i}=m$q ? `[` : '.'}$depLoad.S.slice(s, e)}$q ? `]` : ''}`;
 626              }).join(',')
 627            }}${
 628              depLoad.a[1].length ? `let $depLoad.a[1].map((_, i) => `e$_$i}`).join(',')};` : ''
 629            }export {${
 630              depLoad.a[1].map(({ s, e }, i) => `e$_$i} as $depLoad.S.slice(s, e)}`).join(',')
 631            }}\n//# sourceURL=$depLoad.r}?cycle`);
 632            }
 633          }
 634  
 635          pushStringTo(start - 1);
 636          resolvedSource += `/*${source.slice(start - 1, statementEnd)}*/$urlJsString(blobUrl)}`;
 637  
 638          // circular shell execution

 639          if (!cycleShell && depLoad.s) {
 640            resolvedSource += `;import*as m$_$depIndex} from'$depLoad.b}';import{u$_ as u$_$depIndex}}from'$depLoad.s}';u$_$depIndex}(m$_$depIndex})`;
 641            depLoad.s = undefined;
 642          }
 643          lastIndex = statementEnd;
 644        }
 645        // import.meta

 646        else if (dynamicImportIndex === -2) {
 647          load.m = { url: load.r, resolve: metaResolve };
 648          metaHook(load.m, load.u);
 649          pushStringTo(start);
 650          resolvedSource += `importShim._r[$urlJsString(load.u)}].m`;
 651          lastIndex = statementEnd;
 652        }
 653        // dynamic import

 654        else {
 655          pushStringTo(statementStart + 6);
 656          resolvedSource += `Shim(`;
 657          dynamicImportEndStack.push(statementEnd - 1);
 658          lastIndex = start;
 659        }
 660      }
 661  
 662      // support progressive cycle binding updates (try statement avoids tdz errors)

 663      if (load.s)
 664        resolvedSource += `\n;import{u$_}from'$load.s}';try{u$_({$exports.filter(e => e.ln).map(({ s, e, ln }) => `$source.slice(s, e)}:$ln}`).join(',')}})}catch(_){};\n`;
 665  
 666      function pushSourceURL (commentPrefix, commentStart) {
 667        const urlStart = commentStart + commentPrefix.length;
 668        const commentEnd = source.indexOf('\n', urlStart);
 669        const urlEnd = commentEnd !== -1 ? commentEnd : source.length;
 670        pushStringTo(urlStart);
 671        resolvedSource += new URL(source.slice(urlStart, urlEnd), load.r).href;
 672        lastIndex = urlEnd;
 673      }
 674  
 675      let sourceURLCommentStart = source.lastIndexOf(sourceURLCommentPrefix);
 676      let sourceMapURLCommentStart = source.lastIndexOf(sourceMapURLCommentPrefix);
 677  
 678      // ignore sourceMap comments before already spliced code

 679      if (sourceURLCommentStart < lastIndex) sourceURLCommentStart = -1;
 680      if (sourceMapURLCommentStart < lastIndex) sourceMapURLCommentStart = -1;
 681  
 682      // sourceURL first / only

 683      if (sourceURLCommentStart !== -1 && (sourceMapURLCommentStart === -1 || sourceMapURLCommentStart > sourceURLCommentStart)) {
 684        pushSourceURL(sourceURLCommentPrefix, sourceURLCommentStart);
 685      }
 686      // sourceMappingURL

 687      if (sourceMapURLCommentStart !== -1) {
 688        pushSourceURL(sourceMapURLCommentPrefix, sourceMapURLCommentStart);
 689        // sourceURL last

 690        if (sourceURLCommentStart !== -1 && (sourceURLCommentStart > sourceMapURLCommentStart))
 691          pushSourceURL(sourceURLCommentPrefix, sourceURLCommentStart);
 692      }
 693  
 694      pushStringTo(source.length);
 695  
 696      if (sourceURLCommentStart === -1)
 697        resolvedSource += sourceURLCommentPrefix + load.r;
 698  
 699      load.b = lastLoad = createBlob(resolvedSource);
 700      load.S = undefined;
 701    }
 702  
 703    const sourceURLCommentPrefix = '\n//# sourceURL=';
 704    const sourceMapURLCommentPrefix = '\n//# sourceMappingURL=';
 705  
 706    const jsContentType = /^(text|application)\/(x-)?javascript(;|$)/;
 707    const wasmContentType = /^(application)\/wasm(;|$)/;
 708    const jsonContentType = /^(text|application)\/json(;|$)/;
 709    const cssContentType = /^(text|application)\/css(;|$)/;
 710  
 711    const cssUrlRegEx = /url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g;
 712  
 713    // restrict in-flight fetches to a pool of 100

 714    let p = [];
 715    let c = 0;
 716    function pushFetchPool () {
 717      if (++c > 100)
 718        return new Promise(r => p.push(r));
 719    }
 720    function popFetchPool () {
 721      c--;
 722      if (p.length)
 723        p.shift()();
 724    }
 725  
 726    async function doFetch (url, fetchOpts, parent) {
 727      if (enforceIntegrity && !fetchOpts.integrity)
 728        throw Error(`No integrity for $url}$fromParent(parent)}.`);
 729      const poolQueue = pushFetchPool();
 730      if (poolQueue) await poolQueue;
 731      try {
 732        var res = await fetchHook(url, fetchOpts);
 733      }
 734      catch (e) {
 735        e.message = `Unable to fetch $url}$fromParent(parent)} - see network log for details.\n` + e.message;
 736        throw e;
 737      }
 738      finally {
 739        popFetchPool();
 740      }
 741  
 742      if (!res.ok) {
 743        const error = new TypeError(`$res.status} $res.statusText} $res.url}$fromParent(parent)}`);
 744        error.response = res;
 745        throw error;
 746      }
 747      return res;
 748    }
 749  
 750    async function fetchModule (url, fetchOpts, parent) {
 751      const res = await doFetch(url, fetchOpts, parent);
 752      const contentType = res.headers.get('content-type');
 753      if (jsContentType.test(contentType))
 754        return { r: res.url, s: await res.text(), t: 'js' };
 755      else if (wasmContentType.test(contentType)) {
 756        const module = importShim._w[url] = await WebAssembly.compileStreaming(res);
 757        let s = '', i = 0, importObj = '';
 758        for (const impt of WebAssembly.Module.imports(module)) {
 759          s += `import * as impt$i} from '$impt.module}';\n`;
 760          importObj += `'$impt.module}':impt$i++},`;
 761        }
 762        i = 0;
 763        s += `const instance = await WebAssembly.instantiate(importShim._w['$url}'], {$importObj}});\n`;
 764        for (const expt of WebAssembly.Module.exports(module)) {
 765          s += `const expt$i} = instance['$expt.name}'];\n`;
 766          s += `export { expt$i++} as "$expt.name}" };\n`;
 767        }
 768        return { r: res.url, s, t: 'wasm' };
 769      }
 770      else if (jsonContentType.test(contentType))
 771        return { r: res.url, s: `export default $await res.text()}`, t: 'json' };
 772      else if (cssContentType.test(contentType)) {
 773        return { r: res.url, s: `var s=new CSSStyleSheet();s.replaceSync(${
 774          JSON.stringify((await res.text()).replace(cssUrlRegEx, (_match, quotes = '', relUrl1, relUrl2) => `url($quotes}$resolveUrl(relUrl1 || relUrl2, url)}$quotes})`))
 775        });export default s;`, t: 'css' };
 776      }
 777      else
 778        throw Error(`Unsupported Content-Type "$contentType}" loading $url}$fromParent(parent)}. Modules must be served with a valid MIME type like application/javascript.`);
 779    }
 780  
 781    function getOrCreateLoad (url, fetchOpts, parent, source) {
 782      let load = registry[url];
 783      if (load && !source)
 784        return load;
 785  
 786      load = {
 787        // url

 788        u: url,
 789        // response url

 790        r: source ? url : undefined,
 791        // fetchPromise

 792        f: undefined,
 793        // source

 794        S: undefined,
 795        // linkPromise

 796        L: undefined,
 797        // analysis

 798        a: undefined,
 799        // deps

 800        d: undefined,
 801        // blobUrl

 802        b: undefined,
 803        // shellUrl

 804        s: undefined,
 805        // needsShim

 806        n: false,
 807        // type

 808        t: null,
 809        // meta

 810        m: null
 811      };
 812      if (registry[url]) {
 813        let i = 0;
 814        while (registry[load.u + ++i]);
 815        load.u += i;
 816      }
 817      registry[load.u] = load;
 818  
 819      load.f = (async () => {
 820        if (!source) {
 821          // preload fetch options override fetch options (race)

 822          let t;
 823          ({ r: load.r, s: source, t } = await (fetchCache[url] || fetchModule(url, fetchOpts, parent)));
 824          if (t && !shimMode) {
 825            if (t === 'css' && !cssModulesEnabled || t === 'json' && !jsonModulesEnabled)
 826              throw Error(`$t}-modules require <script type="esms-options">{ "polyfillEnable": ["$t}-modules"] }<${''}/script>`);
 827            if (t === 'css' && !supportsCssAssertions || t === 'json' && !supportsJsonAssertions)
 828              load.n = true;
 829          }
 830        }
 831        try {
 832          load.a = parse(source, load.u);
 833        }
 834        catch (e) {
 835          throwError(e);
 836          load.a = [[], [], false];
 837        }
 838        load.S = source;
 839        return load;
 840      })();
 841  
 842      load.L = load.f.then(async () => {
 843        let childFetchOpts = fetchOpts;
 844        load.d = (await Promise.all(load.a[0].map(async ({ n, d }) => {
 845          if (d >= 0 && !supportsDynamicImport || d === -2 && !supportsImportMeta)
 846            load.n = true;
 847          if (d !== -1 || !n) return;
 848          const { r, b } = await resolve(n, load.r || load.u);
 849          if (b && (!supportsImportMaps || importMapSrcOrLazy))
 850            load.n = true;
 851          if (d !== -1) return;
 852          if (skip && skip(r)) return { b: r };
 853          if (childFetchOpts.integrity)
 854            childFetchOpts = Object.assign({}, childFetchOpts, { integrity: undefined });
 855          return getOrCreateLoad(r, childFetchOpts, load.r).f;
 856        }))).filter(l => l);
 857      });
 858  
 859      return load;
 860    }
 861  
 862    function processScriptsAndPreloads (mapsOnly = false) {
 863      if (!mapsOnly)
 864        for (const link of document.querySelectorAll(shimMode ? 'link[rel=modulepreload-shim]' : 'link[rel=modulepreload]'))
 865          processPreload(link);
 866      for (const script of document.querySelectorAll(shimMode ? 'script[type=importmap-shim]' : 'script[type=importmap]'))
 867        processImportMap(script);
 868      if (!mapsOnly)
 869        for (const script of document.querySelectorAll(shimMode ? 'script[type=module-shim]' : 'script[type=module]'))
 870          processScript(script);
 871    }
 872  
 873    function getFetchOpts (script) {
 874      const fetchOpts = {};
 875      if (script.integrity)
 876        fetchOpts.integrity = script.integrity;
 877      if (script.referrerPolicy)
 878        fetchOpts.referrerPolicy = script.referrerPolicy;
 879      if (script.crossOrigin === 'use-credentials')
 880        fetchOpts.credentials = 'include';
 881      else if (script.crossOrigin === 'anonymous')
 882        fetchOpts.credentials = 'omit';
 883      else
 884        fetchOpts.credentials = 'same-origin';
 885      return fetchOpts;
 886    }
 887  
 888    let lastStaticLoadPromise = Promise.resolve();
 889  
 890    let domContentLoadedCnt = 1;
 891    function domContentLoadedCheck () {
 892      if (--domContentLoadedCnt === 0 && !noLoadEventRetriggers && (shimMode || !baselinePassthrough)) {
 893        document.dispatchEvent(new Event('DOMContentLoaded'));
 894      }
 895    }
 896    // this should always trigger because we assume es-module-shims is itself a domcontentloaded requirement

 897    if (hasDocument) {
 898      document.addEventListener('DOMContentLoaded', async () => {
 899        await initPromise;
 900        domContentLoadedCheck();
 901      });
 902    }
 903  
 904    let readyStateCompleteCnt = 1;
 905    function readyStateCompleteCheck () {
 906      if (--readyStateCompleteCnt === 0 && !noLoadEventRetriggers && (shimMode || !baselinePassthrough)) {
 907        document.dispatchEvent(new Event('readystatechange'));
 908      }
 909    }
 910  
 911    const hasNext = script => script.nextSibling || script.parentNode && hasNext(script.parentNode);
 912    const epCheck = (script, ready) => script.ep || !ready && (!script.src && !script.innerHTML || !hasNext(script)) || script.getAttribute('noshim') !== null || !(script.ep = true);
 913  
 914    function processImportMap (script, ready = readyStateCompleteCnt > 0) {
 915      if (epCheck(script, ready)) return;
 916      // we dont currently support multiple, external or dynamic imports maps in polyfill mode to match native

 917      if (script.src) {
 918        if (!shimMode)
 919          return;
 920        setImportMapSrcOrLazy();
 921      }
 922      if (acceptingImportMaps) {
 923        importMapPromise = importMapPromise
 924          .then(async () => {
 925            importMap = resolveAndComposeImportMap(script.src ? await (await doFetch(script.src, getFetchOpts(script))).json() : JSON.parse(script.innerHTML), script.src || baseUrl, importMap);
 926          })
 927          .catch(e => {
 928            console.log(e);
 929            if (e instanceof SyntaxError)
 930              e = new Error(`Unable to parse import map $e.message} in: $script.src || script.innerHTML}`);
 931            throwError(e);
 932          });
 933        if (!shimMode)
 934          acceptingImportMaps = false;
 935      }
 936    }
 937  
 938    function processScript (script, ready = readyStateCompleteCnt > 0) {
 939      if (epCheck(script, ready)) return;
 940      // does this load block readystate complete

 941      const isBlockingReadyScript = script.getAttribute('async') === null && readyStateCompleteCnt > 0;
 942      // does this load block DOMContentLoaded

 943      const isDomContentLoadedScript = domContentLoadedCnt > 0;
 944      if (isBlockingReadyScript) readyStateCompleteCnt++;
 945      if (isDomContentLoadedScript) domContentLoadedCnt++;
 946      const loadPromise = topLevelLoad(script.src || baseUrl, getFetchOpts(script), !script.src && script.innerHTML, !shimMode, isBlockingReadyScript && lastStaticLoadPromise)
 947        .then(() => {
 948          // if the type of the script tag "module-shim", browser does not dispatch a "load" event

 949          // see https://github.com/guybedford/es-module-shims/issues/346

 950          if (shimMode) {
 951            script.dispatchEvent(new Event('load'));
 952          }
 953        })
 954        .catch(throwError);
 955      if (isBlockingReadyScript)
 956        lastStaticLoadPromise = loadPromise.then(readyStateCompleteCheck);
 957      if (isDomContentLoadedScript)
 958        loadPromise.then(domContentLoadedCheck);
 959    }
 960  
 961    const fetchCache = {};
 962    function processPreload (link) {
 963      if (link.ep) return;
 964      link.ep = true;
 965      if (fetchCache[link.href])
 966        return;
 967      fetchCache[link.href] = fetchModule(link.href, getFetchOpts(link));
 968    }
 969  
 970  })();