module-tsx 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,5 +1,4 @@
 import ts from "typescript";
-
 //#region src/error.ts
 /** Custom error class for module-tsx */
 var ModuleTSXError = class ModuleTSXError extends Error {
@@ -13,53 +12,255 @@ var ModuleTSXError = class ModuleTSXError extends Error {
 function warn(message, ...args) {
 	console.warn(`[module-tsx] ${message}`, ...args);
 }
-
 //#endregion
 //#region src/importmap.ts
-function parseImportMaps() {
-	const result = {
-		imports: {},
-		scopes: {}
-	};
-	const mappedSpecifiers = /* @__PURE__ */ new Set();
-	const scripts = document.querySelectorAll("script[type=\"importmap\"]");
-	for (const script of scripts) try {
-		const data = JSON.parse(script.textContent || "{}");
-		if (data.imports) {
-			for (const [specifier, url] of Object.entries(data.imports)) if (!mappedSpecifiers.has(specifier)) {
-				result.imports[specifier] = url;
-				mappedSpecifiers.add(specifier);
-			}
+var ImportMap = class {
+	imports;
+	scopes;
+	integrity;
+	constructor(imports = /* @__PURE__ */ new Map(), scopes = /* @__PURE__ */ new Map(), integrity = /* @__PURE__ */ new Map()) {
+		this.imports = imports;
+		this.scopes = scopes;
+		this.integrity = integrity;
+	}
+	/** Parse a JSON import map string against a base URL. */
+	static parse(input, baseURL) {
+		return parseImportMapString(input, typeof baseURL === "string" ? new URL(baseURL) : baseURL);
+	}
+	/** Build an ImportMap from a plain object (same shape as the JSON format). */
+	static of(json, baseURL) {
+		return parseImportMapString(JSON.stringify(json), typeof baseURL === "string" ? new URL(baseURL) : baseURL);
+	}
+	/** Merge newImportMap into oldImportMap in place (spec § "merge existing and new import maps"). */
+	static merge(oldImportMap, newImportMap, resolvedModuleSet = []) {
+		mergeExistingAndNewImportMaps(oldImportMap, newImportMap, resolvedModuleSet);
+	}
+	/** Resolve a specifier against an import map (spec § "resolve a module specifier"). */
+	static resolve(specifier, importMap, baseURL) {
+		return resolveFromImportMap(specifier, importMap, baseURL);
+	}
+	/** Parse all <script type="importmap"> elements from the DOM. */
+	static fromDOM() {
+		return parseImportMaps();
+	}
+};
+function resolveURLLikeModuleSpecifier(specifier, baseURL) {
+	if (specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../")) try {
+		return new URL(specifier, baseURL);
+	} catch {
+		return null;
+	}
+	try {
+		return new URL(specifier);
+	} catch {
+		return null;
+	}
+}
+function normalizeSpecifierKey(specifierKey, baseURL) {
+	if (specifierKey === "") {
+		warn("Specifier keys may not be the empty string.");
+		return null;
+	}
+	const url = resolveURLLikeModuleSpecifier(specifierKey, baseURL);
+	if (url !== null) return url.href;
+	return specifierKey;
+}
+function sortAndNormalizeSpecifierMap(originalMap, baseURL) {
+	const normalized = /* @__PURE__ */ new Map();
+	for (const [specifierKey, value] of Object.entries(originalMap)) {
+		const normalizedKey = normalizeSpecifierKey(specifierKey, baseURL);
+		if (normalizedKey === null) continue;
+		if (typeof value !== "string") {
+			warn(`Import map addresses must be strings; ignoring key "${specifierKey}".`);
+			normalized.set(normalizedKey, null);
+			continue;
 		}
-		if (data.scopes) for (const [scope, imports] of Object.entries(data.scopes)) {
-			if (!result.scopes[scope]) result.scopes[scope] = {};
-			for (const [specifier, url] of Object.entries(imports)) {
-				const scopedKey = `${scope}::${specifier}`;
-				if (!mappedSpecifiers.has(scopedKey)) {
-					result.scopes[scope][specifier] = url;
-					mappedSpecifiers.add(scopedKey);
-				}
+		const addressURL = resolveURLLikeModuleSpecifier(value, baseURL);
+		if (addressURL === null) {
+			warn(`Invalid address "${value}" for key "${specifierKey}".`);
+			normalized.set(normalizedKey, null);
+			continue;
+		}
+		if (specifierKey.endsWith("/") && !addressURL.href.endsWith("/")) {
+			warn(`Invalid address "${value}" for specifier key "${specifierKey}": since the specifier key ends with "/", the address must as well.`);
+			normalized.set(normalizedKey, null);
+			continue;
+		}
+		normalized.set(normalizedKey, addressURL);
+	}
+	return sortedDescending(normalized);
+}
+function sortAndNormalizeScopes(originalMap, baseURL) {
+	const normalized = /* @__PURE__ */ new Map();
+	for (const [scopePrefix, potentialSpecifierMap] of Object.entries(originalMap)) {
+		if (typeof potentialSpecifierMap !== "object" || potentialSpecifierMap === null || Array.isArray(potentialSpecifierMap)) throw new TypeError(`The value of the scope with prefix "${scopePrefix}" must be a JSON object.`);
+		let scopePrefixURL;
+		try {
+			scopePrefixURL = new URL(scopePrefix, baseURL);
+		} catch {
+			warn(`Scope prefix URL "${scopePrefix}" is not parseable.`);
+			continue;
+		}
+		normalized.set(scopePrefixURL.href, sortAndNormalizeSpecifierMap(potentialSpecifierMap, baseURL));
+	}
+	return sortedDescending(normalized);
+}
+function normalizeModuleIntegrityMap(originalMap, baseURL) {
+	const normalized = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(originalMap)) {
+		const url = resolveURLLikeModuleSpecifier(key, baseURL);
+		if (url === null) {
+			warn(`Invalid URL key "${key}" in integrity map.`);
+			continue;
+		}
+		if (typeof value !== "string") {
+			warn(`Integrity values must be strings; ignoring key "${key}".`);
+			continue;
+		}
+		normalized.set(url.href, value);
+	}
+	return normalized;
+}
+function sortedDescending(map) {
+	return new Map([...map.entries()].sort((a, b) => a[0] < b[0] ? 1 : a[0] > b[0] ? -1 : 0));
+}
+function parseImportMapString(input, baseURL) {
+	let parsed;
+	try {
+		parsed = JSON.parse(input);
+	} catch {
+		throw new TypeError("Failed to parse import map: not valid JSON.");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("Import map: top-level value must be a JSON object.");
+	const obj = parsed;
+	let imports = /* @__PURE__ */ new Map();
+	if ("imports" in obj) {
+		if (typeof obj.imports !== "object" || obj.imports === null || Array.isArray(obj.imports)) throw new TypeError("Import map: \"imports\" must be a JSON object.");
+		imports = sortAndNormalizeSpecifierMap(obj.imports, baseURL);
+	}
+	let scopes = /* @__PURE__ */ new Map();
+	if ("scopes" in obj) {
+		if (typeof obj.scopes !== "object" || obj.scopes === null || Array.isArray(obj.scopes)) throw new TypeError("Import map: \"scopes\" must be a JSON object.");
+		scopes = sortAndNormalizeScopes(obj.scopes, baseURL);
+	}
+	let integrity = /* @__PURE__ */ new Map();
+	if ("integrity" in obj) {
+		if (typeof obj.integrity !== "object" || obj.integrity === null || Array.isArray(obj.integrity)) throw new TypeError("Import map: \"integrity\" must be a JSON object.");
+		integrity = normalizeModuleIntegrityMap(obj.integrity, baseURL);
+	}
+	for (const key of Object.keys(obj)) if (key !== "imports" && key !== "scopes" && key !== "integrity") warn(`Invalid top-level key "${key}" in import map.`);
+	return new ImportMap(imports, scopes, integrity);
+}
+function mergeSpecifierMaps(newMap, oldMap) {
+	const merged = new Map(oldMap);
+	for (const [specifier, url] of newMap) {
+		if (merged.has(specifier)) {
+			warn(`Import map merge: ignoring duplicate specifier key "${specifier}".`);
+			continue;
+		}
+		merged.set(specifier, url);
+	}
+	return sortedDescending(merged);
+}
+function mergeExistingAndNewImportMaps(oldImportMap, newImportMap, resolvedModuleSet) {
+	const newImportMapScopes = new Map([...newImportMap.scopes.entries()].map(([k, v]) => [k, new Map(v)]));
+	const newImportMapImports = new Map(newImportMap.imports);
+	for (const [scopePrefix, scopeImports] of newImportMapScopes) {
+		for (const record of resolvedModuleSet) {
+			if (!(scopePrefix === record.serializedBaseURL || scopePrefix.endsWith("/") && record.serializedBaseURL.startsWith(scopePrefix))) continue;
+			for (const specifierKey of [...scopeImports.keys()]) if (specifierKey === record.specifier || specifierKey.endsWith("/") && record.specifier.startsWith(specifierKey) && (record.specifierAsURL === null || isSpecialURL(record.specifierAsURL))) {
+				warn(`Import map merge: ignoring scope rule "${specifierKey}" under "${scopePrefix}" — already resolved.`);
+				scopeImports.delete(specifierKey);
 			}
 		}
+		if (oldImportMap.scopes.has(scopePrefix)) oldImportMap.scopes.set(scopePrefix, mergeSpecifierMaps(scopeImports, oldImportMap.scopes.get(scopePrefix)));
+		else oldImportMap.scopes.set(scopePrefix, scopeImports);
+	}
+	const resortedScopes = sortedDescending(oldImportMap.scopes);
+	oldImportMap.scopes.clear();
+	for (const [k, v] of resortedScopes) oldImportMap.scopes.set(k, v);
+	for (const [url, integrity] of newImportMap.integrity) {
+		if (oldImportMap.integrity.has(url)) {
+			warn(`Import map merge: ignoring duplicate integrity entry for "${url}".`);
+			continue;
+		}
+		oldImportMap.integrity.set(url, integrity);
+	}
+	for (const record of resolvedModuleSet) for (const specifierKey of [...newImportMapImports.keys()]) if (specifierKey.startsWith(record.specifier)) {
+		warn(`Import map merge: ignoring global rule "${specifierKey}" — already resolved.`);
+		newImportMapImports.delete(specifierKey);
+	}
+	const merged = mergeSpecifierMaps(newImportMapImports, oldImportMap.imports);
+	oldImportMap.imports.clear();
+	for (const [k, v] of merged) oldImportMap.imports.set(k, v);
+}
+function parseImportMaps() {
+	const base = new URL(document.baseURI || location.href);
+	const result = new ImportMap();
+	for (const script of document.querySelectorAll("script[type=\"importmap\"]")) try {
+		mergeExistingAndNewImportMaps(result, parseImportMapString(script.textContent || "{}", base), []);
 	} catch (error) {
-		warn(`Failed to parse importmap script:`, error);
+		warn("Failed to parse importmap script:", error);
 	}
 	return result;
 }
-/**
-* Resolve specifier from import maps, checking scopes by specificity then global imports
-*/
-function resolveFromImportMap(specifier, importMaps, sourceUrl) {
-	if (sourceUrl && importMaps.scopes) {
-		const matchingScopes = Object.keys(importMaps.scopes).filter((scope) => sourceUrl.startsWith(scope)).sort((a, b) => b.length - a.length);
-		for (const scope of matchingScopes) {
-			const scopedImports = importMaps.scopes[scope];
-			if (scopedImports && scopedImports[specifier]) return scopedImports[specifier];
+function resolveImportsMatch(normalizedSpecifier, asURL, specifierMap) {
+	for (const [specifierKey, resolutionResult] of specifierMap) {
+		if (specifierKey === normalizedSpecifier) {
+			if (resolutionResult === null) throw new TypeError(`Resolution of "${specifierKey}" was blocked by a null entry in the import map.`);
+			return resolutionResult;
+		}
+		if (specifierKey.endsWith("/") && normalizedSpecifier.startsWith(specifierKey) && (asURL === null || isSpecialURL(asURL))) {
+			if (resolutionResult === null) throw new TypeError(`Resolution of "${specifierKey}" was blocked by a null entry in the import map.`);
+			const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
+			let url;
+			try {
+				url = new URL(afterPrefix, resolutionResult);
+			} catch {
+				throw new TypeError(`Resolution of "${normalizedSpecifier}" was blocked: "${afterPrefix}" could not be URL-parsed relative to "${resolutionResult.href}".`);
+			}
+			if (!url.href.startsWith(resolutionResult.href)) throw new TypeError(`Resolution of "${normalizedSpecifier}" was blocked due to backtracking above its prefix "${specifierKey}".`);
+			return url;
 		}
 	}
-	if (importMaps.imports && importMaps.imports[specifier]) return importMaps.imports[specifier];
+	return null;
+}
+function isSpecialURL(url) {
+	return [
+		"ftp:",
+		"file:",
+		"http:",
+		"https:",
+		"ws:",
+		"wss:"
+	].includes(url.protocol);
+}
+function resolveFromImportMap(specifier, importMap, baseURL) {
+	const base = typeof baseURL === "string" ? new URL(baseURL) : baseURL;
+	const asURL = resolveURLLikeModuleSpecifier(specifier, base);
+	const normalizedSpecifier = asURL !== null ? asURL.href : specifier;
+	const serializedBaseURL = base.href;
+	for (const [scopePrefix, scopeImports] of importMap.scopes) if (scopePrefix === serializedBaseURL || scopePrefix.endsWith("/") && serializedBaseURL.startsWith(scopePrefix)) {
+		const match = resolveImportsMatch(normalizedSpecifier, asURL, scopeImports);
+		if (match !== null) return {
+			url: match.href,
+			record: {
+				serializedBaseURL,
+				specifier: normalizedSpecifier,
+				specifierAsURL: asURL
+			}
+		};
+	}
+	const match = resolveImportsMatch(normalizedSpecifier, asURL, importMap.imports);
+	if (match !== null) return {
+		url: match.href,
+		record: {
+			serializedBaseURL,
+			specifier: normalizedSpecifier,
+			specifierAsURL: asURL
+		}
+	};
 }
-
 //#endregion
 //#region src/loader.ts
 const cssLoader = (sourceUrl, sourceCode) => {
@@ -103,7 +304,6 @@ function cssToModule(cssString, prefix) {
 		map: jsonMap
 	};
 }
-
 //#endregion
 //#region src/network.ts
 async function fetchResponse(input, init) {
@@ -111,7 +311,6 @@ async function fetchResponse(input, init) {
 	if (!res.ok) throw new ModuleTSXError(`Failed to fetch resource ${res.url}: ${res.status}`);
 	return res;
 }
-
 //#endregion
 //#region src/specifier.ts
 function isBareSpecifier(specifier) {
@@ -170,7 +369,6 @@ function createRewriteImportTransformer(specifierMap) {
 	};
 	return transformer;
 }
-
 //#endregion
 //#region src/react.ts
 /** Check if code uses JSX without React import */
@@ -212,7 +410,6 @@ function addReactImport(sourceFile) {
 	const statements = [ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("React"), void 0), ts.factory.createStringLiteral(reactSpecifier), void 0), ...sourceFile.statements];
 	return ts.factory.updateSourceFile(sourceFile, statements, sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
 }
-
 //#endregion
 //#region src/source-tracker.ts
 var SourceTransformTracker = class {
@@ -248,7 +445,6 @@ var SourceTransformTracker = class {
 		return `${sourceType}:${sourceUrl}`;
 	}
 };
-
 //#endregion
 //#region src/ts.ts
 function createSourceFile(code, fileName) {
@@ -285,7 +481,6 @@ function transform(sourceFile, transformers) {
 		throw new ModuleTSXError(`Failed to transform typescript source file ${sourceFile.fileName}`, { cause });
 	}
 }
-
 //#endregion
 //#region src/module-tsx.ts
 var ModuleTSX = class extends EventTarget {
@@ -293,6 +488,7 @@ var ModuleTSX = class extends EventTarget {
 	importMap;
 	fetch;
 	resolveBareSpecifier;
+	resolvedModuleSet = [];
 	sourceTracker = new SourceTransformTracker();
 	fetchText = async (url) => {
 		return this.fetch(url).then((res) => res.text());
@@ -300,10 +496,15 @@ var ModuleTSX = class extends EventTarget {
 	constructor(config) {
 		super();
 		this.baseUrl = config?.baseUrl ?? location.href;
-		this.importMap = config?.importMap ?? parseImportMaps();
+		this.importMap = config?.importMap ?? new ImportMap();
 		this.fetch = config?.fetch ?? fetchResponse;
 		this.resolveBareSpecifier = typeof config?.resolveBareSpecifier === "function" ? config?.resolveBareSpecifier : (specifier) => (config?.resolveBareSpecifier ?? "https://esm.sh/") + specifier;
 	}
+	/** Add a new import map, merging it into the existing one per the spec.
+	*  Rules that conflict with already-resolved modules are silently dropped. */
+	addImportMap(newImportMap) {
+		ImportMap.merge(this.importMap, newImportMap, this.resolvedModuleSet);
+	}
 	emit(type, detail) {
 		this.dispatchEvent(new CustomEvent(type, { detail }));
 		this.dispatchEvent(new CustomEvent("*", { detail: {
@@ -315,9 +516,11 @@ var ModuleTSX = class extends EventTarget {
 		this.emit("import", { id });
 		try {
 			if (isBareSpecifier(id)) {
-				const mappedSpecifier = resolveFromImportMap(id, this.importMap, this.baseUrl);
-				if (mappedSpecifier) id = mappedSpecifier;
-				else id = this.resolveBareSpecifier(id);
+				const resolved = ImportMap.resolve(id, this.importMap, this.baseUrl);
+				if (resolved) {
+					this.resolvedModuleSet.push(resolved.record);
+					id = resolved.url;
+				} else id = this.resolveBareSpecifier(id);
 			}
 			const url = isRelativeSpecifier(id) ? new URL(id, this.baseUrl).href : id;
 			const code = await this.fetchText(url);
@@ -331,7 +534,15 @@ var ModuleTSX = class extends EventTarget {
 		}
 	}
 	async importCode(sourceUrl, code, options) {
-		return await import(await this.transformSourceModule("esm", sourceUrl, code), options);
+		try {
+			return await import(await this.transformSourceModule("esm", sourceUrl, code), options);
+		} catch (error) {
+			this.emit("import:error", {
+				id: sourceUrl,
+				error
+			});
+			throw error;
+		}
 	}
 	/** Transform module source code and return a blob URL with the transformed content */
 	async transformSourceModule(sourceType, sourceUrl, sourceCode) {
@@ -361,7 +572,13 @@ var ModuleTSX = class extends EventTarget {
 			const specifiers = collectSpecifiers(sourceFile);
 			const rewrittenSpecifiers = await this.resolveSpecifiers(specifiers, sourceUrl);
 			let workingSourceFile = sourceFile;
-			if (needsReactImport(workingSourceFile)) workingSourceFile = addReactImport(workingSourceFile);
+			if (needsReactImport(workingSourceFile)) {
+				workingSourceFile = addReactImport(workingSourceFile);
+				if (!rewrittenSpecifiers.has("react")) {
+					const reactUrl = await this.resolveSpecifier("react", sourceUrl);
+					if (reactUrl !== "react") rewrittenSpecifiers.set("react", reactUrl);
+				}
+			}
 			const transformers = [createRewriteImportTransformer(rewrittenSpecifiers)];
 			return printSourceFile(transform(workingSourceFile, transformers));
 		} catch (error) {
@@ -372,32 +589,34 @@ var ModuleTSX = class extends EventTarget {
 			throw error;
 		}
 	}
+	async resolveLocalUrl(fullUrl) {
+		const { pathname } = new URL(fullUrl);
+		if (pathname.endsWith(".module.css")) return this.transformSourceModule("css-module", fullUrl, await this.fetchText(fullUrl));
+		if (pathname.endsWith(".css")) return this.transformSourceModule("css", fullUrl, await this.fetchText(fullUrl));
+		if (pathname.endsWith(".wasm")) return fullUrl;
+		if (this.sourceTracker.isInFlight("esm", fullUrl)) return fullUrl;
+		//! ^ transformSourceModule is recursive ^
+		return this.transformSourceModule("esm", fullUrl, await this.fetchText(fullUrl));
+	}
 	async resolveSpecifier(specifier, sourceUrl) {
-		const mappedSpecifier = resolveFromImportMap(specifier, this.importMap, sourceUrl);
-		if (mappedSpecifier) return mappedSpecifier;
-		const getCssUrl = async (fullURL) => {
-			return await this.transformSourceModule("css", fullURL, await this.fetchText(fullURL));
-		};
-		const toCDNUrl = (specifier) => {
-			const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
-			const url = this.resolveBareSpecifier(specifier);
-			if (subpath.endsWith(".css")) return getCssUrl(url);
+		const resolved = ImportMap.resolve(specifier, this.importMap, sourceUrl);
+		if (resolved) {
+			this.resolvedModuleSet.push(resolved.record);
+			const { pathname } = new URL(resolved.url);
+			if (pathname.endsWith(".module.css")) return this.transformSourceModule("css-module", resolved.url, await this.fetchText(resolved.url));
+			if (pathname.endsWith(".css")) return this.transformSourceModule("css", resolved.url, await this.fetchText(resolved.url));
+			return resolved.url;
+		}
+		if (isRelativeSpecifier(specifier)) return this.resolveLocalUrl(new URL(specifier, sourceUrl).href);
+		if (specifier.startsWith("node:")) return `https://raw.esm.sh/@jspm/core/nodelibs/browser/${specifier.slice(5)}.js`;
+		const bareSpecifier = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
+		if (specifier.startsWith("npm:") || isBareSpecifier(specifier)) {
+			const subpath = bareSpecifier.startsWith("@") ? bareSpecifier.split("/").slice(2).join("/") : bareSpecifier.split("/").slice(1).join("/");
+			const url = this.resolveBareSpecifier(bareSpecifier);
+			if (subpath.endsWith(".css")) return this.transformSourceModule("css", url, await this.fetchText(url));
 			return url;
-		};
-		if (isRelativeSpecifier(specifier)) {
-			const targetUrl = new URL(specifier, sourceUrl);
-			if (targetUrl.pathname.endsWith(".module.css")) return await this.transformSourceModule("css-module", targetUrl.href, await this.fetchText(targetUrl.href));
-			else if (targetUrl.pathname.endsWith(".css")) return getCssUrl(targetUrl.href);
-			else if (targetUrl.pathname.endsWith(".wasm")) return targetUrl.href;
-			else {
-				if (this.sourceTracker.isInFlight("esm", targetUrl.href)) return targetUrl.href;
-				//! ^ transformSourceModule is recursive ^
-				return await this.transformSourceModule("esm", targetUrl.href, await this.fetchText(targetUrl.href));
-			}
-		} else if (specifier.startsWith("node:")) return `https://raw.esm.sh/@jspm/core/nodelibs/browser/${specifier.slice(5)}.js`;
-		else if (specifier.startsWith("npm:")) return toCDNUrl(specifier.slice(4));
-		else if (isBareSpecifier(specifier)) return toCDNUrl(specifier);
-		else return specifier;
+		}
+		return specifier;
 	}
 	async resolveSpecifiers(specifiers, sourceUrl) {
 		const resolved = /* @__PURE__ */ new Map();
@@ -416,13 +635,12 @@ function getFileName(sourceUrl) {
 		return "temp.tsx";
 	}
 }
-
 //#endregion
 //#region src/index.ts
 /**
 * The singleton global instance of ModuleTSX.
 */
-const instance = new ModuleTSX();
+const instance = new ModuleTSX({ importMap: ImportMap.fromDOM() });
 const TYPE_ATTRIBUTE_VALUE = "module-tsx";
 async function sideEffect() {
 	const importScript = async (script) => {
@@ -441,7 +659,11 @@ async function sideEffect() {
 		else await importScript(script);
 	}
 }
+/**
+* Since this module can be loaded as both ESM and UMD, we listen for DOMContentLoaded to ensure all type="module-tsx" tags are present.
+* ESM scripts are always deferred, so the document is already fully parsed when this module executes and the listener fires immediately.
+* Classic scripts run inline as the parser encounters them, so they must wait for DOMContentLoaded.
+*/
 document.addEventListener("DOMContentLoaded", sideEffect);
-
 //#endregion
-export { ModuleTSX, ModuleTSXError, instance };
+export { ImportMap, ModuleTSX, ModuleTSXError, instance };