/** ES Module Shims @version 2.8.1 */ (function () { const self_ = typeof globalThis !== 'undefined' ? globalThis : self; let invalidate; const hotReload$1 = url => invalidate(new URL(url, baseUrl).href); const initHotReload = (topLevelLoad, importShim) => { let _importHook = importHook, _resolveHook = resolveHook, _metaHook = metaHook; let defaultResolve; let hotResolveHook = (id, parent, _defaultResolve) => { if (!defaultResolve) defaultResolve = _defaultResolve; const originalParent = stripVersion(parent); const url = stripVersion(defaultResolve(id, originalParent)); const hotState = getHotState(url); const parents = hotState.p; if (!parents.includes(originalParent)) parents.push(originalParent); return toVersioned(url, hotState); }; const hotImportHook = (url, _, __, source, sourceType) => { const hotState = getHotState(url); hotState.e = typeof source === 'string' ? source : true; hotState.t = sourceType; }; const hotMetaHook = (metaObj, url) => (metaObj.hot = new Hot(url)); const Hot = class Hot { constructor(url) { this.data = getHotState((this.url = stripVersion(url))).d; } accept(deps, cb) { if (typeof deps === 'function') { cb = deps; deps = null; } const hotState = getHotState(this.url); if (!hotState.A) return; (hotState.a = hotState.a || []).push([ typeof deps === 'string' ? defaultResolve(deps, this.url) : deps ? deps.map(d => defaultResolve(d, this.url)) : null, cb ]); } dispose(cb) { getHotState(this.url).u = cb; } invalidate() { const hotState = getHotState(this.url); hotState.a = hotState.A = null; const seen = [this.url]; hotState.p.forEach(p => invalidate(p, this.url, seen)); } }; const versionedRegEx = /\?v=\d+$/; const stripVersion = url => { const versionMatch = url.match(versionedRegEx); return versionMatch ? url.slice(0, -versionMatch[0].length) : url; }; const toVersioned = (url, hotState) => { const { v } = hotState; return url + (v ? '?v=' + v : ''); }; let hotRegistry = {}, curInvalidationRoots = new Set(), curInvalidationInterval; const getHotState = url => hotRegistry[url] || (hotRegistry[url] = { // version v: 0, // accept list ([deps, cb] pairs) a: null, // accepting acceptors A: true, // unload callback u: null, // entry point or inline script source e: false, // hot data d: {}, // parents p: [], // source type t: undefined }); invalidate = (url, fromUrl, seen = []) => { const hotState = hotRegistry[url]; if (!hotState || seen.includes(url)) return false; seen.push(url); hotState.A = false; if ( fromUrl && hotState.a && hotState.a.some(([d]) => d && (typeof d === 'string' ? d === fromUrl : d.includes(fromUrl))) ) { curInvalidationRoots.add(fromUrl); } else { if (hotState.e || hotState.a) curInvalidationRoots.add(url); hotState.v++; if (!hotState.a) hotState.p.forEach(p => invalidate(p, url, seen)); } if (!curInvalidationInterval) curInvalidationInterval = setTimeout(handleInvalidations, hotReloadInterval); return true; }; const handleInvalidations = () => { curInvalidationInterval = null; const earlyRoots = new Set(); for (const root of curInvalidationRoots) { const hotState = hotRegistry[root]; topLevelLoad( toVersioned(root, hotState), baseUrl, defaultFetchOpts, typeof hotState.e === 'string' ? hotState.e : undefined, false, undefined, hotState.t ).then(m => { if (hotState.a) { hotState.a.forEach(([d, c]) => d === null && !earlyRoots.has(c) && c(m)); // unload should be the latest unload handler from the just loaded module if (hotState.u) { hotState.u(hotState.d); hotState.u = null; } } hotState.p.forEach(p => { const hotState = hotRegistry[p]; if (hotState && hotState.a) hotState.a.forEach( async ([d, c]) => d && !earlyRoots.has(c) && (typeof d === 'string' ? d === root && c(m) : c(await Promise.all(d.map(d => (earlyRoots.push(c), importShim(toVersioned(d, getHotState(d)))))))) ); }); }, throwError); } curInvalidationRoots = new Set(); }; setHooks( _importHook ? chain(_importHook, hotImportHook) : hotImportHook, _resolveHook ? (id, parent, defaultResolve) => hotResolveHook(id, parent, (id, parent) => _resolveHook(id, parent, defaultResolve)) : hotResolveHook, _metaHook ? chain(_metaHook, hotMetaHook) : hotMetaHook ); }; const hasDocument = typeof document !== 'undefined'; const noop = () => {}; const chain = (a, b) => function () { a.apply(this, arguments); b.apply(this, arguments); }; const dynamicImport = (u, _errUrl) => import(u); const defineValue = (obj, prop, value) => Object.defineProperty(obj, prop, { writable: false, configurable: false, value }); const optionsScript = hasDocument ? document.querySelector('script[type=esms-options]') : undefined; const esmsInitOptions = optionsScript ? JSON.parse(optionsScript.innerHTML) : {}; Object.assign(esmsInitOptions, self_.esmsInitOptions || {}); const version = "2.8.1"; const r$1 = esmsInitOptions.version; if (self_.importShim || (r$1 && r$1 !== version)) { return; } // shim mode is determined on initialization, no late shim mode const shimMode = esmsInitOptions.shimMode || (hasDocument ? document.querySelectorAll('script[type=module-shim],script[type=importmap-shim],link[rel=modulepreload-shim]') .length > 0 // Without a document, shim mode is always true as we cannot polyfill : true); let importHook, resolveHook, fetchHook = fetch, sourceHook, metaHook, tsTransform = esmsInitOptions.tsTransform || (hasDocument && document.currentScript && document.currentScript.src.replace(/(\.\w+)?\.js$/, '-typescript.js')) || './es-module-shims-typescript.js'; const defaultFetchOpts = { credentials: 'same-origin' }; const globalHook = name => (typeof name === 'string' ? self_[name] : name); if (esmsInitOptions.onimport) importHook = globalHook(esmsInitOptions.onimport); if (esmsInitOptions.resolve) resolveHook = globalHook(esmsInitOptions.resolve); if (esmsInitOptions.fetch) fetchHook = globalHook(esmsInitOptions.fetch); if (esmsInitOptions.source) sourceHook = globalHook(esmsInitOptions.source); if (esmsInitOptions.meta) metaHook = globalHook(esmsInitOptions.meta); const hasCustomizationHooks = importHook || resolveHook || fetchHook !== fetch || sourceHook || metaHook; const { noLoadEventRetriggers, enforceIntegrity, hotReload, hotReloadInterval = 100, nativePassthrough = !hasCustomizationHooks && !hotReload } = esmsInitOptions; const setHooks = (importHook_, resolveHook_, metaHook_) => ( (importHook = importHook_), (resolveHook = resolveHook_), (metaHook = metaHook_) ); const mapOverrides = esmsInitOptions.mapOverrides; let nonce = esmsInitOptions.nonce; if (!nonce && hasDocument) { const nonceElement = document.querySelector('script[nonce]'); if (nonceElement) nonce = nonceElement.nonce || nonceElement.getAttribute('nonce'); } const onerror = globalHook(esmsInitOptions.onerror || console.error.bind(console)); const enable = Array.isArray(esmsInitOptions.polyfillEnable) ? esmsInitOptions.polyfillEnable : []; const disable = Array.isArray(esmsInitOptions.polyfillDisable) ? esmsInitOptions.polyfillDisable : []; const enableAll = esmsInitOptions.polyfillEnable === 'all' || enable.includes('all'); const wasmInstancePhaseEnabled = enable.includes('wasm-modules') || enable.includes('wasm-module-instances') || enableAll; const wasmSourcePhaseEnabled = enable.includes('wasm-modules') || enable.includes('wasm-module-sources') || enableAll; const deferPhaseEnabled = enable.includes('import-defer') || enableAll; const cssModulesEnabled = !disable.includes('css-modules'); const jsonModulesEnabled = !disable.includes('json-modules'); const onpolyfill = esmsInitOptions.onpolyfill ? globalHook(esmsInitOptions.onpolyfill) : () => { console.log(`%c^^ Module error above is polyfilled and can be ignored ^^`, 'font-weight:900;color:#391'); }; const baseUrl = hasDocument ? document.baseURI : typeof location !== 'undefined' ? `${location.protocol}//${location.host}${ location.pathname.includes('/') ? location.pathname.slice(0, location.pathname.lastIndexOf('/') + 1) : location.pathname }` : 'about:blank'; const createBlob = (source, type = 'text/javascript') => URL.createObjectURL(new Blob([source], { type })); let { skip } = esmsInitOptions; if (Array.isArray(skip)) { const l = skip.map(s => new URL(s, baseUrl).href); skip = s => l.some(i => (i[i.length - 1] === '/' && s.startsWith(i)) || s === i); } else if (typeof skip === 'string') { const r = new RegExp(skip); skip = s => r.test(s); } else if (skip instanceof RegExp) { skip = s => skip.test(s); } const dispatchError = error => self_.dispatchEvent(Object.assign(new Event('error'), { error })); const throwError = err => { (self_.reportError || dispatchError)(err); onerror(err); }; const fromParent = parent => (parent ? ` imported from ${parent}` : ''); const backslashRegEx = /\\/g; const asURL = url => { try { if (url.indexOf(':') !== -1) return new URL(url).href; } catch (_) {} }; const resolveUrl = (relUrl, parentUrl) => resolveIfNotPlainOrUrl(relUrl, parentUrl) || asURL(relUrl) || resolveIfNotPlainOrUrl('./' + relUrl, parentUrl); const resolveIfNotPlainOrUrl = (relUrl, parentUrl) => { const hIdx = parentUrl.indexOf('#'), qIdx = parentUrl.indexOf('?'); if (hIdx + qIdx > -2) parentUrl = parentUrl.slice( 0, hIdx === -1 ? qIdx : qIdx === -1 || qIdx > hIdx ? hIdx : qIdx ); if (relUrl.indexOf('\\') !== -1) relUrl = relUrl.replace(backslashRegEx, '/'); // protocol-relative if (relUrl[0] === '/' && relUrl[1] === '/') { return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl; } // relative-url else if ( (relUrl[0] === '.' && (relUrl[1] === '/' || (relUrl[1] === '.' && (relUrl[2] === '/' || (relUrl.length === 2 && (relUrl += '/')))) || (relUrl.length === 1 && (relUrl += '/')))) || relUrl[0] === '/' ) { const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); if (parentProtocol === 'blob:') { throw new TypeError( `Failed to resolve module specifier "${relUrl}". Invalid relative url or base scheme isn't hierarchical.` ); } // Disabled, but these cases will give inconsistent results for deep backtracking //if (parentUrl[parentProtocol.length] !== '/') // throw new Error('Cannot resolve'); // read pathname from parent URL // pathname taken to be part after leading "/" let pathname; if (parentUrl[parentProtocol.length + 1] === '/') { // resolving to a :// so we need to read out the auth and host if (parentProtocol !== 'file:') { pathname = parentUrl.slice(parentProtocol.length + 2); pathname = pathname.slice(pathname.indexOf('/') + 1); } else { pathname = parentUrl.slice(8); } } else { // resolving to :/ so pathname is the /... part pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/')); } if (relUrl[0] === '/') return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl; // join together and split for removal of .. and . segments // looping the string instead of anything fancy for perf reasons // '../../../../../z' resolved to 'x/y' is just 'z' const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl; const output = []; let segmentIndex = -1; for (let i = 0; i < segmented.length; i++) { // busy reading a segment - only terminate on '/' if (segmentIndex !== -1) { if (segmented[i] === '/') { output.push(segmented.slice(segmentIndex, i + 1)); segmentIndex = -1; } continue; } // new segment - check if it is relative else if (segmented[i] === '.') { // ../ segment if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) { output.pop(); i += 2; continue; } // ./ segment else if (segmented[i + 1] === '/' || i + 1 === segmented.length) { i += 1; continue; } } // it is the start of a new segment while (segmented[i] === '/') i++; segmentIndex = i; } // finish reading out the last segment if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex)); return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join(''); } }; const resolveAndComposeImportMap = (json, baseUrl, parentMap) => { const outMap = { imports: { ...parentMap.imports }, scopes: { ...parentMap.scopes }, integrity: { ...parentMap.integrity } }; if (json.imports) resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap); if (json.scopes) for (let s in json.scopes) { const resolvedScope = resolveUrl(s, baseUrl); resolveAndComposePackages( json.scopes[s], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, parentMap ); } if (json.integrity) resolveAndComposeIntegrity(json.integrity, outMap.integrity, baseUrl); return outMap; }; const getMatch = (path, matchObj) => { if (matchObj[path]) return path; let sepIndex = path.length; do { const segment = path.slice(0, sepIndex + 1); if (segment in matchObj) return segment; } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1); }; const applyPackages = (id, packages) => { const pkgName = getMatch(id, packages); if (pkgName) { const pkg = packages[pkgName]; if (pkg === null) return; return pkg + id.slice(pkgName.length); } }; const resolveImportMap = (importMap, resolvedOrPlain, parentUrl) => { let scopeUrl = parentUrl && getMatch(parentUrl, importMap.scopes); while (scopeUrl) { const packageResolution = applyPackages(resolvedOrPlain, importMap.scopes[scopeUrl]); if (packageResolution) return packageResolution; scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), importMap.scopes); } return applyPackages(resolvedOrPlain, importMap.imports) || (resolvedOrPlain.indexOf(':') !== -1 && resolvedOrPlain); }; const resolveAndComposePackages = (packages, outPackages, baseUrl, parentMap) => { for (let p in packages) { const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p; if ( (!shimMode || !mapOverrides) && outPackages[resolvedLhs] && outPackages[resolvedLhs] !== packages[resolvedLhs] ) { console.warn( `es-module-shims: Rejected map override "${resolvedLhs}" from ${outPackages[resolvedLhs]} to ${packages[resolvedLhs]}.` ); continue; } let target = packages[p]; if (typeof target !== 'string') continue; const mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(target, baseUrl) || target, baseUrl); if (mapped) { outPackages[resolvedLhs] = mapped; continue; } console.warn(`es-module-shims: Mapping "${p}" -> "${packages[p]}" does not resolve`); } }; const resolveAndComposeIntegrity = (integrity, outIntegrity, baseUrl) => { for (let p in integrity) { const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p; if ( (!shimMode || !mapOverrides) && outIntegrity[resolvedLhs] && outIntegrity[resolvedLhs] !== integrity[resolvedLhs] ) { console.warn( `es-module-shims: Rejected map integrity override "${resolvedLhs}" from ${outIntegrity[resolvedLhs]} to ${integrity[resolvedLhs]}.` ); } outIntegrity[resolvedLhs] = integrity[p]; } }; let policy; if ( typeof self !== 'undefined' && (typeof self.trustedTypes !== 'undefined' || typeof self.TrustedTypes !== 'undefined') ) { try { policy = (self.trustedTypes || self.TrustedTypes).createPolicy('es-module-shims', { createHTML: html => html, createScript: script => script }); } catch {} } function maybeTrustedInnerHTML(html) { return policy ? policy.createHTML(html) : html; } function maybeTrustedScript(script) { return policy ? policy.createScript(script) : script; } // support browsers without dynamic import support (eg Firefox 6x) let supportsJsonType = false; let supportsCssType = false; const supports = hasDocument && HTMLScriptElement.supports; let supportsImportMaps = supports && supports.name === 'supports' && supports('importmap'); let supportsWasmInstancePhase = false; let supportsWasmSourcePhase = false; let supportsMultipleImportMaps = false; const wasmBytes = [0, 97, 115, 109, 1, 0, 0, 0]; let featureDetectionPromise = (async function () { if (!hasDocument) return Promise.all([ import(createBlob(`import"${createBlob('{}', 'text/json')}"with{type:"json"}`)).then( () => ( (supportsJsonType = true), import(createBlob(`import"${createBlob('', 'text/css')}"with{type:"css"}`)).then( () => (supportsCssType = true), noop ) ), noop ), wasmInstancePhaseEnabled && import(createBlob(`import"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then( () => (supportsWasmInstancePhase = true), noop ), wasmSourcePhaseEnabled && import(createBlob(`import source x from"${createBlob(new Uint8Array(wasmBytes), 'application/wasm')}"`)).then( () => (supportsWasmSourcePhase = true), noop ) ]); const msgTag = `s${version}`; return new Promise(resolve => { const iframe = document.createElement('iframe'); iframe.style.display = 'none'; iframe.setAttribute('nonce', nonce); function cb({ data }) { const isFeatureDetectionMessage = Array.isArray(data) && data[0] === msgTag; if (!isFeatureDetectionMessage) return; [ , supportsImportMaps, supportsMultipleImportMaps, supportsJsonType, supportsCssType, supportsWasmSourcePhase, supportsWasmInstancePhase ] = data; resolve(); document.head.removeChild(iframe); window.removeEventListener('message', cb, false); } window.addEventListener('message', cb, false); // Feature checking with careful avoidance of unnecessary work - all gated on initial import map supports check. CSS gates on JSON feature check, Wasm instance phase gates on wasm source phase check. const importMapTest = `

Your order is confirmed…and so is your genius