module-tsx 0.0.3 → 0.1.0

package/README.md

@@ -96,6 +96,9 @@ npx skills add yieldray/module-tsx
 <!-- ESM -->
 <script type="module" src="https://esm.sh/module-tsx"></script>
 
+<!-- ESM (DEV mode) -->
+<script type="module" src="https://esm.sh/module-tsx/dev"></script>
+
 <!-- ESM (self-contained, no external dependencies) -->
 <script
   type="module"

package/dist/index.cdn.mjs

@@ -0,0 +1,688 @@
+import ts from "https://esm.sh/typescript@5.9.3";
+//#region src/error.ts
+/** Custom error class for module-tsx */
+var ModuleTSXError = class ModuleTSXError extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ModuleTSXError";
+		if ("captureStackTrace" in Error) Error.captureStackTrace(this, ModuleTSXError);
+	}
+};
+/** Log warnings with consistent formatting */
+function warn(message, ...args) {
+	console.warn(`[module-tsx] ${message}`, ...args);
+}
+//#endregion
+//#region src/import-map.ts
+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;
+		}
+		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);
+	}
+	return result;
+}
+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;
+		}
+	}
+	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) => {
+	return `\
+const style = document.createElement("style");
+style.dataset.href = ${JSON.stringify(sourceUrl)}; // for debugging purposes
+style.textContent = ${JSON.stringify(sourceCode)};
+document.head.appendChild(style);
+`;
+};
+const cssModuleLoader = (sourceUrl, sourceCode) => {
+	const pathname = new URL(sourceUrl).pathname;
+	const filename = pathname.substring(pathname.lastIndexOf("/") + 1) || "index.css";
+	const { map, css } = cssToModule(sourceCode, filename.slice(0, filename.indexOf(".")).replace(/[^a-zA-Z0-9]/g, "_"));
+	return `\
+const style = document.createElement("style");
+style.dataset.href = ${JSON.stringify(sourceUrl)}; // for debugging purposes
+style.textContent = ${JSON.stringify(css)};
+document.head.appendChild(style);
+export default ${JSON.stringify(map)};
+`;
+};
+function cssToModule(cssString, prefix) {
+	const sheet = new CSSStyleSheet();
+	sheet.replaceSync(cssString);
+	const jsonMap = {};
+	const getHash = (name) => {
+		const p = prefix ? `${prefix}_` : "";
+		if (!jsonMap[name]) jsonMap[name] = `${p}${name}_${Math.random().toString(36).slice(2, 7)}`;
+		return jsonMap[name];
+	};
+	const processRules = (ruleList) => {
+		for (const rule of ruleList) if (rule instanceof CSSStyleRule) rule.selectorText = rule.selectorText.replace(/\.([a-zA-Z_][\w-]*)/g, (_match, className) => {
+			return `.${getHash(className)}`;
+		});
+		else if (rule instanceof CSSGroupingRule) processRules(rule.cssRules);
+	};
+	processRules(sheet.cssRules);
+	return {
+		css: Array.from(sheet.cssRules).map((rule) => rule.cssText).join("\n"),
+		map: jsonMap
+	};
+}
+//#endregion
+//#region src/network.ts
+async function fetchResponse(input, init) {
+	const url = input instanceof Request ? input.url : String(input);
+	let res;
+	try {
+		res = await fetch(input, init);
+	} catch (cause) {
+		throw new ModuleTSXError(`Failed to fetch module ${url}: Network error`, { cause });
+	}
+	if (!res.ok) throw new ModuleTSXError(`Failed to fetch module ${url}: ${res.status} ${res.statusText}`);
+	return res;
+}
+//#endregion
+//#region src/specifier.ts
+function isBareSpecifier(specifier) {
+	if (isRelativeSpecifier(specifier)) return false;
+	try {
+		new URL(specifier);
+		return false;
+	} catch {
+		return true;
+	}
+}
+function isRelativeSpecifier(specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+}
+function collectSpecifiers(sourceFile) {
+	const set = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		const addSpecifier = (literal) => {
+			if (literal) set.add(literal.text);
+		};
+		if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) addSpecifier(node.moduleSpecifier);
+		if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+			const arg = node.arguments[0];
+			if (arg && ts.isStringLiteral(arg)) addSpecifier(arg);
+		}
+		if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) addSpecifier(node.moduleSpecifier);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return set;
+}
+function createRewriteImportTransformer(specifierMap) {
+	const rewriteSpecifier = (specifier) => {
+		return specifierMap.get(specifier) ?? specifier;
+	};
+	const transformer = (context) => {
+		const visitNode = (node) => {
+			if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+				const next = rewriteSpecifier(node.moduleSpecifier.text);
+				if (next !== node.moduleSpecifier.text) return ts.factory.updateImportDeclaration(node, node.modifiers, node.importClause, ts.factory.createStringLiteral(next), node.assertClause);
+			}
+			if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+				const arg = node.arguments[0];
+				if (arg && ts.isStringLiteral(arg)) {
+					const next = rewriteSpecifier(arg.text);
+					if (next !== arg.text) return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ts.factory.createStringLiteral(next), ...node.arguments.slice(1)]);
+				}
+			}
+			if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+				const next = rewriteSpecifier(node.moduleSpecifier.text);
+				if (next !== node.moduleSpecifier.text) return ts.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, ts.factory.createStringLiteral(next), node.assertClause);
+			}
+			return ts.visitEachChild(node, visitNode, context);
+		};
+		return (sf) => ts.visitNode(sf, visitNode);
+	};
+	return transformer;
+}
+//#endregion
+//#region src/react.ts
+/** Check if code uses JSX without React import */
+function needsReactImport(sourceFile) {
+	let hasJSX = false;
+	let hasReactVariable = false;
+	function visitNode(node) {
+		if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) hasJSX = true;
+		if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+			if (node.importClause) {
+				if (node.importClause.name?.text === "React") hasReactVariable = true;
+				if (node.importClause.namedBindings && ts.isNamespaceImport(node.importClause.namedBindings)) {
+					if (node.importClause.namedBindings.name.text === "React") hasReactVariable = true;
+				}
+			}
+		}
+		if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
+			if (node.name.text === "React") hasReactVariable = true;
+		}
+		ts.forEachChild(node, visitNode);
+	}
+	visitNode(sourceFile);
+	return hasJSX && !hasReactVariable;
+}
+/** Add React import statement to the top */
+function addReactImport(sourceFile) {
+	let reactSpecifier = "react";
+	function findReactSpecifier(node) {
+		if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+			const specifier = node.moduleSpecifier.text;
+			if (specifier === "react" || /^react@/.test(specifier) || specifier.endsWith("/react") || /\/react@/.test(specifier)) {
+				reactSpecifier = specifier;
+				return;
+			}
+		}
+		ts.forEachChild(node, findReactSpecifier);
+	}
+	findReactSpecifier(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 {
+	sourceMap = /* @__PURE__ */ new Map();
+	inFlightSourceMap = /* @__PURE__ */ new Map();
+	blobMap = /* @__PURE__ */ new Map();
+	originalSourceMap = /* @__PURE__ */ new Map();
+	get(sourceType, sourceUrl) {
+		return this.sourceMap.get(this.getSourceKey(sourceType, sourceUrl));
+	}
+	set(sourceType, sourceUrl, blobUrl, originalSource) {
+		this.sourceMap.set(this.getSourceKey(sourceType, sourceUrl), blobUrl);
+		this.blobMap.set(blobUrl, sourceUrl);
+		if (originalSource != null) this.originalSourceMap.set(blobUrl, originalSource);
+	}
+	getOriginalSource(blobUrl) {
+		return this.originalSourceMap.get(blobUrl);
+	}
+	isInFlight(sourceType, sourceUrl) {
+		return this.inFlightSourceMap.has(this.getSourceKey(sourceType, sourceUrl));
+	}
+	getSourceUrlByBlob(blobUrl) {
+		return this.blobMap.get(blobUrl);
+	}
+	/** Deduplicates concurrent transforms for the same URL. */
+	runWithDedup(sourceType, sourceUrl, run) {
+		const sourceKey = this.getSourceKey(sourceType, sourceUrl);
+		const inFlight = this.inFlightSourceMap.get(sourceKey);
+		if (inFlight) return inFlight;
+		const task = run();
+		this.inFlightSourceMap.set(sourceKey, task);
+		task.finally(() => {
+			this.inFlightSourceMap.delete(sourceKey);
+		});
+		return task;
+	}
+	getSourceKey(sourceType, sourceUrl) {
+		return `${sourceType}:${sourceUrl}`;
+	}
+};
+//#endregion
+//#region src/ts.ts
+function createSourceFile(code, fileName) {
+	try {
+		return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	} catch (cause) {
+		throw new ModuleTSXError(`Failed to create typescript source file ${fileName}`, { cause });
+	}
+}
+function printSourceFile(sourceFile) {
+	try {
+		const code = ts.createPrinter({
+			newLine: ts.NewLineKind.LineFeed,
+			removeComments: false
+		}).printFile(sourceFile);
+		return ts.transpile(code, {
+			target: ts.ScriptTarget.Latest,
+			module: ts.ModuleKind.ESNext,
+			noCheck: true,
+			declaration: false,
+			jsx: ts.JsxEmit.React
+		});
+	} catch (cause) {
+		throw new ModuleTSXError(`Failed to print typescript source file ${sourceFile.fileName}`, { cause });
+	}
+}
+function transform(sourceFile, transformers) {
+	try {
+		const result = ts.transform(sourceFile, transformers);
+		const transformedFile = result.transformed[0];
+		result.dispose();
+		return transformedFile;
+	} catch (cause) {
+		throw new ModuleTSXError(`Failed to transform typescript source file ${sourceFile.fileName}`, { cause });
+	}
+}
+//#endregion
+//#region src/module-tsx.ts
+var ModuleTSX = class extends EventTarget {
+	baseUrl;
+	importMap;
+	fetch;
+	resolveBareSpecifier;
+	resolvedModuleSet = [];
+	sourceTracker = new SourceTransformTracker();
+	fetchText = async (url) => {
+		return this.fetch(url).then((res) => res.text());
+	};
+	constructor(config) {
+		super();
+		this.baseUrl = config?.baseUrl ?? location.href;
+		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);
+	}
+	/** Resolve a blob URL back to its original source URL. Returns undefined if not found. */
+	getSourceUrlByBlob(blobUrl) {
+		return this.sourceTracker.getSourceUrlByBlob(blobUrl);
+	}
+	/** Get the original source code that was compiled into a given blob URL. */
+	getOriginalSource(blobUrl) {
+		return this.sourceTracker.getOriginalSource(blobUrl);
+	}
+	emit(type, detail) {
+		this.dispatchEvent(new CustomEvent(type, { detail }));
+		this.dispatchEvent(new CustomEvent("*", { detail: {
+			type,
+			payload: detail
+		} }));
+	}
+	async import(id, options) {
+		this.emit("import", { id });
+		try {
+			if (isBareSpecifier(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);
+			return this.importCode(url, code, options);
+		} catch (error) {
+			this.emit("import:error", {
+				id,
+				error
+			});
+			throw error;
+		}
+	}
+	async importCode(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) {
+		const cachedBlobUrl = this.sourceTracker.get(sourceType, sourceUrl);
+		if (cachedBlobUrl) return cachedBlobUrl;
+		return this.sourceTracker.runWithDedup(sourceType, sourceUrl, async () => {
+			const loader = this.getLoaderByResourceType(sourceType);
+			const code = `import.meta.url=${JSON.stringify(sourceUrl)};\n` + await loader(sourceUrl, sourceCode);
+			const blob = new Blob([code], { type: "text/javascript" });
+			const blobUrl = URL.createObjectURL(blob);
+			this.sourceTracker.set(sourceType, sourceUrl, blobUrl, sourceCode);
+			return blobUrl;
+		});
+	}
+	getLoaderByResourceType(type) {
+		switch (type) {
+			case "css": return cssLoader;
+			case "css-module": return cssModuleLoader;
+			case "esm": return this.tsxLoader.bind(this);
+			default: throw new ModuleTSXError(`Unsupported resource type: ${type}`);
+		}
+	}
+	async tsxLoader(sourceUrl, sourceCode) {
+		this.emit("transform", { sourceUrl });
+		try {
+			const sourceFile = createSourceFile(sourceCode, getFileName(sourceUrl));
+			const specifiers = collectSpecifiers(sourceFile);
+			const rewrittenSpecifiers = await this.resolveSpecifiers(specifiers, sourceUrl);
+			let workingSourceFile = sourceFile;
+			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) {
+			this.emit("transform:error", {
+				sourceUrl,
+				error
+			});
+			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 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;
+		}
+		return specifier;
+	}
+	async resolveSpecifiers(specifiers, sourceUrl) {
+		const resolved = /* @__PURE__ */ new Map();
+		const tasks = Array.from(specifiers).map(async (specifier) => {
+			const specifier2 = await this.resolveSpecifier(specifier, sourceUrl);
+			if (specifier !== specifier2) resolved.set(specifier, specifier2);
+		});
+		await Promise.all(tasks);
+		return resolved;
+	}
+};
+function getFileName(sourceUrl) {
+	try {
+		return new URL(sourceUrl).pathname;
+	} catch {
+		return "temp.tsx";
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* The singleton global instance of ModuleTSX.
+*/
+const instance = new ModuleTSX({ importMap: ImportMap.fromDOM() });
+const TYPE_ATTRIBUTE_VALUE = "module-tsx";
+async function sideEffect() {
+	const importScript = async (script) => {
+		const src = script.src;
+		if (src) return instance.import(src);
+		else {
+			const code = script.innerHTML || "";
+			return instance.importCode(document.location.href, code);
+		}
+	};
+	for (const s of Array.from(document.querySelectorAll(`script[type="${TYPE_ATTRIBUTE_VALUE}"]`))) {
+		const script = s;
+		if (!script.async && script.defer) warn(`script with type="${TYPE_ATTRIBUTE_VALUE}" does not support defer attribute. Use async or no attribute instead.`);
+		for (const key of ["integrity", "crossorigin"]) if (script[key]) warn(`script with type="${TYPE_ATTRIBUTE_VALUE}" does not support ${key} attribute.`);
+		if (script.async) importScript(script);
+		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 { ImportMap, ModuleTSX, ModuleTSXError, instance };