@remix-run/multiple-import-maps-polyfill 0.0.0 → 0.1.0

package/dist/lib/env.js

@@ -0,0 +1,33 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { self } from './self.js';
+export const hasDocument = typeof document !== 'undefined';
+export const dynamicImport = (u) => import(__rewriteRelativeImportExtension(u));
+export const defaultFetchOpts = { credentials: 'same-origin' };
+export const version = `remix/multiple-import-maps-polyfill:${Date.now()}:${Math.random()}`;
+export let nonce = '';
+if (hasDocument) {
+    let nonceElement = document.querySelector('script[nonce]');
+    if (nonceElement)
+        nonce = nonceElement.nonce || nonceElement.getAttribute('nonce') || '';
+}
+export 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';
+export const createBlob = (source) => URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+const dispatchError = (error) => self.dispatchEvent(Object.assign(new Event('error'), { error }));
+export const throwError = (err) => {
+    ;
+    (self.reportError || dispatchError)(err);
+};
+export const fromParent = (parent) => (parent ? ` imported from ${parent}` : '');

package/dist/lib/features.d.ts

@@ -0,0 +1,4 @@
+export declare const supportsImportMaps: boolean;
+export declare let supportsMultipleImportMaps: boolean;
+export declare const featureDetectionPromise: Promise<void>;
+//# sourceMappingURL=features.d.ts.map

package/dist/lib/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/lib/features.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,SAE9B,CAAA;AACD,eAAO,IAAI,0BAA0B,SAAQ,CAAA;AAE7C,eAAO,MAAM,uBAAuB,EAAE,OAAO,CAAC,IAAI,CAqE9B,CAAA"}

package/dist/lib/features.js

@@ -0,0 +1,70 @@
+import { hasDocument, nonce, version } from './env.js';
+import { maybeTrustedInnerHTML, maybeTrustedScript, policy } from './trusted-types.js';
+const supports = hasDocument ? HTMLScriptElement.supports : undefined;
+export const supportsImportMaps = Boolean(supports && supports.name === 'supports' && supports('importmap'));
+export let supportsMultipleImportMaps = false;
+export const featureDetectionPromise = (async function () {
+    if (!hasDocument || !supportsImportMaps)
+        return;
+    let msgTag = `s${version}`;
+    return new Promise((resolve) => {
+        let iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        iframe.setAttribute('nonce', nonce);
+        let settled = false;
+        let timeout = setTimeout(done, 1000);
+        function done() {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (iframe.parentNode === document.head)
+                document.head.removeChild(iframe);
+            window.removeEventListener('message', cb, false);
+            resolve();
+        }
+        function cb({ data }) {
+            if (!Array.isArray(data) || data[0] !== msgTag)
+                return;
+            supportsMultipleImportMaps = data[2] === true;
+            done();
+        }
+        window.addEventListener('message', cb, false);
+        let importMapTest = `<script nonce=${nonce || ''}>${policy
+            ? 't=(window.trustedTypes||window.TrustedTypes).createPolicy("remix/multiple-import-maps-polyfill",{createScript:s=>s});'
+            : ''}b=s=>URL.createObjectURL(new Blob([s],{type:'text/javascript'}));c=u=>import(u).then(()=>true,()=>false);i=innerText=>document.head.appendChild(Object.assign(document.createElement('script'),{type:'importmap',nonce:"${nonce}",text:${policy ? 't.createScript(innerText)' : 'innerText'}}));i(\`{"imports":{"x":"\${b('')}"}}\`);i(\`{"imports":{"y":"\${b('')}"}}\`);Promise.all([true,c('y')]).then(a=>parent.postMessage(['${msgTag}'].concat(a),'*'))<${''}/script>`;
+        // Safari will call onload eagerly on head injection, but we don't want the Wechat
+        // path to trigger before setting srcdoc, therefore we track the timing
+        let readyForOnload = false, onloadCalledWhileNotReady = false;
+        function doOnload() {
+            if (!readyForOnload) {
+                onloadCalledWhileNotReady = true;
+                return;
+            }
+            // WeChat browser doesn't support setting srcdoc scripts
+            // But iframe sandboxes don't support contentDocument so we do this as a fallback
+            let doc = iframe.contentDocument;
+            if (doc && doc.head.childNodes.length === 0) {
+                let script = doc.createElement('script');
+                if (nonce)
+                    script.setAttribute('nonce', nonce);
+                script.innerText = maybeTrustedScript(importMapTest.slice(15 + (nonce ? nonce.length : 0), -9));
+                doc.head.appendChild(script);
+            }
+        }
+        iframe.onload = doOnload;
+        // WeChat browser requires append before setting srcdoc
+        document.head.appendChild(iframe);
+        // setting srcdoc is not supported in React native webviews on iOS
+        // setting src to a blob URL results in a navigation event in webviews
+        // document.write gives usability warnings
+        readyForOnload = true;
+        if ('srcdoc' in iframe)
+            iframe.srcdoc = maybeTrustedInnerHTML(importMapTest);
+        else
+            iframe.contentDocument.write(importMapTest);
+        // retrigger onload for Safari only if necessary
+        if (onloadCalledWhileNotReady)
+            doOnload();
+    });
+})().catch(() => { });

package/dist/lib/native-resolve.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveModuleUrl(specifier: string, parentUrl: string): string;
+//# sourceMappingURL=native-resolve.d.ts.map

package/dist/lib/native-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-resolve.d.ts","sourceRoot":"","sources":["../../src/lib/native-resolve.ts"],"names":[],"mappings":"AAoBA,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAO7E"}

package/dist/lib/native-resolve.js

@@ -0,0 +1,59 @@
+import { asURL, resolveAndComposeImportMap, resolveIfNotPlainOrUrl, resolveImportMap, } from './resolve.js';
+let importMap = { imports: {}, scopes: {}, integrity: {} };
+const processedScripts = new WeakSet();
+const selector = 'script[type="importmap"]';
+const observer = typeof document === 'undefined' ? undefined : new MutationObserver(processMutations);
+if (observer) {
+    observer.observe(document, { childList: true });
+    observer.observe(document.head, { childList: true });
+    processImportMaps();
+}
+export function resolveModuleUrl(specifier, parentUrl) {
+    if (observer)
+        processMutations(observer.takeRecords());
+    processImportMaps();
+    let normalized = resolveIfNotPlainOrUrl(specifier, parentUrl) || asURL(specifier) || specifier;
+    let resolved = resolveImportMap(importMap, normalized, parentUrl);
+    if (!resolved)
+        throw new TypeError(`Unable to resolve specifier '${specifier}' from ${parentUrl}`);
+    return resolved;
+}
+function processImportMaps() {
+    for (let script of document.querySelectorAll(selector))
+        processImportMap(script);
+}
+function processMutations(mutations) {
+    for (let mutation of mutations) {
+        for (let node of mutation.addedNodes) {
+            if (node instanceof HTMLScriptElement && node.matches(selector))
+                processImportMap(node);
+        }
+    }
+}
+function processImportMap(script) {
+    if (processedScripts.has(script))
+        return;
+    processedScripts.add(script);
+    if (script.src)
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(script.textContent ?? '');
+    }
+    catch {
+        return;
+    }
+    if (!isRecord(parsed))
+        return;
+    let scopes = {};
+    if (isRecord(parsed.scopes)) {
+        for (let [scope, entries] of Object.entries(parsed.scopes)) {
+            if (isRecord(entries))
+                scopes[scope] = entries;
+        }
+    }
+    importMap = resolveAndComposeImportMap({ imports: isRecord(parsed.imports) ? parsed.imports : undefined, scopes }, script.baseURI, importMap);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/lib/polyfill.d.ts

@@ -0,0 +1,41 @@
+type ModuleNamespace = Record<string, unknown>;
+/**
+ * Detects whether the current document can install multiple import maps.
+ *
+ * Returns `true` only when an isolated feature test verifies support. If the test cannot run or
+ * complete under the document's Content Security Policy, this returns `false`. When the polyfill
+ * is required, its runtime begins loading in the background.
+ *
+ * @returns Whether multiple import map support was verified.
+ */
+export declare function detectMultipleImportMapSupport(): Promise<boolean>;
+/**
+ * Loads a JavaScript module, using the multiple import map polyfill when required.
+ *
+ * @param specifier Module specifier to load.
+ * @param parentUrl URL to resolve the specifier from. (default: `document.baseURI`)
+ * @returns The loaded module namespace.
+ */
+export declare function importModule(specifier: string, parentUrl?: string): Promise<ModuleNamespace>;
+/**
+ * Loads a JavaScript module through the polyfill using every import map currently installed in the
+ * document. This function does not detect native multiple import map support.
+ *
+ * @param specifier Module specifier to load.
+ * @param parentUrl URL to resolve the specifier from. (default: `document.baseURI`)
+ * @returns The loaded module namespace.
+ */
+export declare function importShim(specifier: string, parentUrl?: string): Promise<ModuleNamespace>;
+/**
+ * Fetches one or more JavaScript modules through the polyfill for a later polyfilled import. This
+ * function does not use native module preloads.
+ *
+ * Preload failures are ignored. A later import reports the failure if the module is required.
+ *
+ * @param specifiers Module specifier or specifiers to preload.
+ * @param parentUrl URL to resolve the specifiers from. (default: `document.baseURI`)
+ * @returns A promise that settles after all module fetches have completed.
+ */
+export declare function preloadShim(specifiers: string | readonly string[], parentUrl?: string): Promise<void>;
+export {};
+//# sourceMappingURL=polyfill.d.ts.map

package/dist/lib/polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../src/lib/polyfill.ts"],"names":[],"mappings":"AAGA,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAgB9C;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAAC,OAAO,CAAC,CAEjE;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,MAAyB,GACnC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,MAAyB,GACnC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACtC,SAAS,GAAE,MAAyB,GACnC,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/lib/polyfill.js

@@ -0,0 +1,77 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { featureDetectionPromise, supportsMultipleImportMaps } from './features.js';
+import { resolveModuleUrl } from './native-resolve.js';
+let runtimePromise;
+const multipleImportMapSupportPromise = featureDetectionPromise.then(() => {
+    let supported = supportsMultipleImportMaps;
+    // A later import observes the cached rejection; the background warm-up must not be unhandled.
+    if (!supported && typeof document !== 'undefined')
+        void getRuntime().catch(() => { });
+    return supported;
+});
+/**
+ * Detects whether the current document can install multiple import maps.
+ *
+ * Returns `true` only when an isolated feature test verifies support. If the test cannot run or
+ * complete under the document's Content Security Policy, this returns `false`. When the polyfill
+ * is required, its runtime begins loading in the background.
+ *
+ * @returns Whether multiple import map support was verified.
+ */
+export function detectMultipleImportMapSupport() {
+    return multipleImportMapSupportPromise;
+}
+/**
+ * Loads a JavaScript module, using the multiple import map polyfill when required.
+ *
+ * @param specifier Module specifier to load.
+ * @param parentUrl URL to resolve the specifier from. (default: `document.baseURI`)
+ * @returns The loaded module namespace.
+ */
+export async function importModule(specifier, parentUrl = document.baseURI) {
+    if (await detectMultipleImportMapSupport())
+        return import(__rewriteRelativeImportExtension(resolveModuleUrl(specifier, parentUrl)));
+    return importShim(specifier, parentUrl);
+}
+/**
+ * Loads a JavaScript module through the polyfill using every import map currently installed in the
+ * document. This function does not detect native multiple import map support.
+ *
+ * @param specifier Module specifier to load.
+ * @param parentUrl URL to resolve the specifier from. (default: `document.baseURI`)
+ * @returns The loaded module namespace.
+ */
+export async function importShim(specifier, parentUrl = document.baseURI) {
+    let runtime = await getRuntime();
+    return runtime.importShim(specifier, parentUrl);
+}
+/**
+ * Fetches one or more JavaScript modules through the polyfill for a later polyfilled import. This
+ * function does not use native module preloads.
+ *
+ * Preload failures are ignored. A later import reports the failure if the module is required.
+ *
+ * @param specifiers Module specifier or specifiers to preload.
+ * @param parentUrl URL to resolve the specifiers from. (default: `document.baseURI`)
+ * @returns A promise that settles after all module fetches have completed.
+ */
+export async function preloadShim(specifiers, parentUrl = document.baseURI) {
+    try {
+        let runtime = await getRuntime();
+        await runtime.preloadShim(specifiers, parentUrl);
+    }
+    catch { }
+}
+async function getRuntime() {
+    runtimePromise ??= import('./core.js');
+    let runtime = await runtimePromise;
+    runtime.registerNativeModule(import.meta.url);
+    return runtime;
+}

package/dist/lib/resolve.d.ts

@@ -0,0 +1,16 @@
+export interface ImportMap {
+    imports: Record<string, string | null>;
+    scopes: Record<string, Record<string, string | null>>;
+    integrity: Record<string, string>;
+}
+export interface ImportMapJson {
+    imports?: Record<string, unknown>;
+    scopes?: Record<string, Record<string, unknown>>;
+    integrity?: Record<string, string>;
+}
+export declare const asURL: (url: string) => string | undefined;
+export declare const resolveUrl: (relUrl: string, parentUrl: string) => string;
+export declare const resolveIfNotPlainOrUrl: (relUrl: string, parentUrl: string) => string | undefined;
+export declare const resolveAndComposeImportMap: (json: ImportMapJson, baseUrl: string, parentMap: ImportMap) => ImportMap;
+export declare const resolveImportMap: (importMap: ImportMap, resolvedOrPlain: string, parentUrl: string) => string | false | undefined;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/lib/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/lib/resolve.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;IACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;IACrD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC;AAED,eAAO,MAAM,KAAK,QAAS,MAAM,KAAG,MAAM,GAAG,SAI5C,CAAA;AAED,eAAO,MAAM,UAAU,WAAY,MAAM,aAAa,MAAM,KAAG,MAGT,CAAA;AAEtD,eAAO,MAAM,sBAAsB,WAAY,MAAM,aAAa,MAAM,KAAG,MAAM,GAAG,SAsFnF,CAAA;AAED,eAAO,MAAM,0BAA0B,SAC/B,aAAa,WACV,MAAM,aACJ,SAAS,KACnB,SAyBF,CAAA;AAoBD,eAAO,MAAM,gBAAgB,cAChB,SAAS,mBACH,MAAM,aACZ,MAAM,KAChB,MAAM,GAAG,KAAK,GAAG,SAWnB,CAAA"}

package/dist/lib/resolve.js

@@ -0,0 +1,167 @@
+const backslashRegEx = /\\/g;
+export const asURL = (url) => {
+    try {
+        if (url.indexOf(':') !== -1)
+            return new URL(url).href;
+    }
+    catch (_) { }
+};
+export const resolveUrl = (relUrl, parentUrl) => (resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
+    asURL(relUrl) ||
+    resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+export const resolveIfNotPlainOrUrl = (relUrl, parentUrl) => {
+    let 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] === '/') {
+        let 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 + Number(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'
+        let segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
+        let 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('');
+    }
+};
+export const resolveAndComposeImportMap = (json, baseUrl, parentMap) => {
+    let outMap = {
+        imports: { ...parentMap.imports },
+        scopes: Object.fromEntries(Object.entries(parentMap.scopes).map(([scope, imports]) => [scope, { ...imports }])),
+        integrity: { ...parentMap.integrity },
+    };
+    if (json.imports)
+        resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap);
+    if (json.scopes)
+        for (let s in json.scopes) {
+            let 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 {
+        let segment = path.slice(0, sepIndex + 1);
+        if (segment in matchObj)
+            return segment;
+    } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1);
+};
+const applyPackages = (id, packages) => {
+    let pkgName = getMatch(id, packages);
+    if (pkgName) {
+        let pkg = packages[pkgName];
+        if (pkg === null)
+            return;
+        return pkg + id.slice(pkgName.length);
+    }
+};
+export const resolveImportMap = (importMap, resolvedOrPlain, parentUrl) => {
+    let scopeUrl = parentUrl && getMatch(parentUrl, importMap.scopes);
+    while (scopeUrl) {
+        let 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) {
+        let resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+        if (outPackages[resolvedLhs] && outPackages[resolvedLhs] !== packages[resolvedLhs]) {
+            console.warn(`remix/multiple-import-maps-polyfill: Rejected map override "${resolvedLhs}" from ${outPackages[resolvedLhs]} to ${packages[resolvedLhs]}.`);
+            continue;
+        }
+        let target = packages[p];
+        if (typeof target !== 'string')
+            continue;
+        let mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(target, baseUrl) || target, baseUrl);
+        if (mapped) {
+            outPackages[resolvedLhs] = mapped;
+            continue;
+        }
+        console.warn(`remix/multiple-import-maps-polyfill: Mapping "${p}" -> "${packages[p]}" does not resolve`);
+    }
+};
+const resolveAndComposeIntegrity = (integrity, outIntegrity, baseUrl) => {
+    for (let p in integrity) {
+        let resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+        if (outIntegrity[resolvedLhs] && outIntegrity[resolvedLhs] !== integrity[resolvedLhs]) {
+            console.warn(`remix/multiple-import-maps-polyfill: Rejected map integrity override "${resolvedLhs}" from ${outIntegrity[resolvedLhs]} to ${integrity[resolvedLhs]}.`);
+        }
+        outIntegrity[resolvedLhs] = integrity[p];
+    }
+};

package/dist/lib/self.d.ts

@@ -0,0 +1,3 @@
+declare const self_: typeof globalThis;
+export { self_ as self };
+//# sourceMappingURL=self.d.ts.map

package/dist/lib/self.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.d.ts","sourceRoot":"","sources":["../../src/lib/self.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,KAAK,EAAE,OAAO,UAAkE,CAAA;AACtF,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,CAAA"}

package/dist/lib/self.js

@@ -0,0 +1,2 @@
+const self_ = typeof globalThis !== 'undefined' ? globalThis : self;
+export { self_ as self };

package/dist/lib/trusted-types.d.ts

@@ -0,0 +1,15 @@
+type TrustedHTML = string & {
+    readonly __trustedHTML: unique symbol;
+};
+type TrustedScript = string & {
+    readonly __trustedScript: unique symbol;
+};
+interface TrustedTypePolicy {
+    createHTML(html: string): TrustedHTML;
+    createScript(script: string): TrustedScript;
+}
+export declare let policy: TrustedTypePolicy | undefined;
+export declare function maybeTrustedInnerHTML(html: string): string | TrustedHTML;
+export declare function maybeTrustedScript(script: string): string | TrustedScript;
+export {};
+//# sourceMappingURL=trusted-types.d.ts.map

package/dist/lib/trusted-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted-types.d.ts","sourceRoot":"","sources":["../../src/lib/trusted-types.ts"],"names":[],"mappings":"AAEA,KAAK,WAAW,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,aAAa,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AACrE,KAAK,aAAa,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,eAAe,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AAEzE,UAAU,iBAAiB;IACzB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IACrC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAAA;CAC5C;AAmBD,eAAO,IAAI,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;AAehD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,CAExE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,CAEzE"}

package/dist/lib/trusted-types.js

@@ -0,0 +1,21 @@
+import { self } from './self.js';
+const trustedTypesGlobal = self;
+export let policy;
+if (typeof trustedTypesGlobal !== 'undefined' &&
+    (typeof trustedTypesGlobal.trustedTypes !== 'undefined' ||
+        typeof trustedTypesGlobal.TrustedTypes !== 'undefined')) {
+    try {
+        let trustedTypes = (trustedTypesGlobal.trustedTypes || trustedTypesGlobal.TrustedTypes);
+        policy = trustedTypes.createPolicy('remix/multiple-import-maps-polyfill', {
+            createHTML: (html) => html,
+            createScript: (script) => script,
+        });
+    }
+    catch { }
+}
+export function maybeTrustedInnerHTML(html) {
+    return policy ? policy.createHTML(html) : html;
+}
+export function maybeTrustedScript(script) {
+    return policy ? policy.createScript(script) : script;
+}

package/package.json

@@ -1,14 +1,53 @@
 {
   "name": "@remix-run/multiple-import-maps-polyfill",
-  "version": "0.0.0",
-  "description": "Placeholder package for Remix CI/OIDC setup",
+  "version": "0.1.0",
+  "description": "Polyfill for dynamic JavaScript imports that depend on import maps added at runtime",
+  "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/remix-run/remix.git",
     "directory": "packages/multiple-import-maps-polyfill"
   },
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/remix-run/remix/tree/main/packages/multiple-import-maps-polyfill#readme",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "es-module-lexer": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "playwright": "^1.60.0",
+    "@remix-run/assert": "^0.3.0",
+    "@remix-run/node-fetch-server": "^0.14.1",
+    "@remix-run/test": "^0.6.0"
+  },
+  "keywords": [
+    "remix",
+    "browser",
+    "import-maps",
+    "modules",
+    "polyfill"
+  ],
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "clean": "git clean -fdX",
+    "test": "pnpm run build && remix test",
+    "test:bun": "bun x --bun remix test --type server",
+    "typecheck": "tsgo --noEmit"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  detectMultipleImportMapSupport,
+  importModule,
+  importShim,
+  preloadShim,
+} from './lib/polyfill.ts'