@yak/react 0.0.0-stage → 10.0.0-rc.1

package/dist/loaders/webpack-loader.js

@@ -0,0 +1,710 @@
+import { relative } from "path";
+import { parse } from "@babel/parser";
+
+//#region ../yak-internals/loaders/lib/debugLogger.ts
+function createDebugLogger(debugOptions, rootPath) {
+	if (!debugOptions) return () => {};
+	const pattern = debugOptions === true ? void 0 : debugOptions.pattern;
+	const typesArray = debugOptions === true ? void 0 : debugOptions.types;
+	let compiledPattern = null;
+	if (pattern) try {
+		compiledPattern = new RegExp(pattern);
+	} catch (error) {
+		throw new Error(`Invalid debug pattern: "${pattern}" is not a valid regular expression. ${error instanceof Error ? error.message : ""}`);
+	}
+	const types = typesArray ? new Set(typesArray) : null;
+	return (messageType, message, filePath) => {
+		if (types && !types.has(messageType)) return;
+		const relativePath = relative(rootPath, filePath);
+		if (!compiledPattern || compiledPattern.test(relativePath)) console.log("🐮 Yak", `[${messageType}]`, relativePath, "\n\n", message);
+	};
+}
+
+//#endregion
+//#region ../yak-internals/loaders/lib/extractCss.ts
+function extractCss(code) {
+	let codeString;
+	if (typeof code === "string") codeString = code;
+	else if (code instanceof Buffer) codeString = code.toString("utf-8");
+	else if (code instanceof ArrayBuffer) codeString = new TextDecoder("utf-8").decode(code);
+	else throw new Error("Invalid input type: code must be string, Buffer, or ArrayBuffer");
+	const codeParts = codeString.split("/*YAK Extracted CSS:\n");
+	let result = "";
+	for (let i = 1; i < codeParts.length; i++) {
+		const codeUntilEnd = codeParts[i].split("*/")[0];
+		result += codeUntilEnd;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../yak-internals/cross-file-resolver/parseModule.ts
+async function parseModule(context, modulePath) {
+	try {
+		if ((modulePath.endsWith(".yak.ts") || modulePath.endsWith(".yak.tsx") || modulePath.endsWith(".yak.js") || modulePath.endsWith(".yak.jsx")) && context.evaluateYakModule) return {
+			type: "yak",
+			exports: {
+				importYak: false,
+				named: objectToModuleExport(await context.evaluateYakModule(modulePath)),
+				all: []
+			},
+			path: modulePath
+		};
+		if (context.cache?.parse === void 0) return await uncachedParseModule(context, modulePath);
+		const cached = context.cache.parse.get(modulePath);
+		if (cached === void 0) {
+			const parsedModule = await uncachedParseModule(context, modulePath);
+			context.cache.parse.set(modulePath, parsedModule);
+			if (context.cache.parse.addDependency) context.cache.parse.addDependency(modulePath, modulePath);
+			return parsedModule;
+		}
+		return cached;
+	} catch (error) {
+		const causeMessage = error instanceof Error ? error.message : String(error);
+		throw new Error(`Error parsing file "${modulePath}"\n  Caused by: ${causeMessage}`);
+	}
+}
+async function uncachedParseModule(context, modulePath) {
+	const exports = await context.extractExports(modulePath);
+	if (!exports.importYak) return {
+		type: "regular",
+		path: modulePath,
+		exports
+	};
+	const transformed = await context.getTransformed(modulePath);
+	const mixins = parseMixins(transformed.code);
+	return {
+		type: "regular",
+		path: modulePath,
+		js: transformed,
+		exports,
+		styledComponents: parseStyledComponents(transformed.code),
+		mixins
+	};
+}
+function parseMixins(sourceContents) {
+	const mixinParts = sourceContents.split("/*YAK EXPORTED MIXIN:");
+	let mixins = {};
+	for (let i = 1; i < mixinParts.length; i++) {
+		const [comment] = mixinParts[i].split("*/", 1);
+		const position = comment.indexOf("\n");
+		const name = comment.slice(0, position);
+		mixins[name] = {
+			type: "mixin",
+			value: comment.slice(position + 1),
+			nameParts: name.split(":").map((part) => decodeURIComponent(part))
+		};
+	}
+	return mixins;
+}
+function parseStyledComponents(sourceContents) {
+	const styledParts = sourceContents.split("/*YAK EXPORTED STYLED:");
+	let styledComponents = {};
+	for (let i = 1; i < styledParts.length; i++) {
+		const [comment] = styledParts[i].split("*/", 1);
+		const [componentName, className] = comment.split(":");
+		styledComponents[componentName] = {
+			type: "styled-component",
+			nameParts: componentName.split("."),
+			value: `.${className}`
+		};
+	}
+	return styledComponents;
+}
+function objectToModuleExport(object) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => {
+		if (typeof value === "string" || typeof value === "number") return [key, {
+			type: "constant",
+			value
+		}];
+		else if (value && (typeof value === "object" || Array.isArray(value))) return [key, {
+			type: "record",
+			value: objectToModuleExport(value)
+		}];
+		else return [key, {
+			type: "unsupported",
+			hint: String(value)
+		}];
+	}));
+}
+
+//#endregion
+//#region ../yak-internals/cross-file-resolver/Errors.ts
+var CauseError = class CauseError extends Error {
+	constructor(message, options) {
+		super(`${message}${options?.cause ? `\n  Caused by: ${typeof options.cause === "object" && options.cause !== null && "message" in options.cause ? options.cause.message : String(options.cause)}` : ""}`);
+		if (options?.cause instanceof CauseError && options.cause.circular) this.circular = true;
+	}
+};
+var ResolveError = class extends CauseError {};
+var UnsupportedExportError = class extends ResolveError {};
+var CircularDependencyError = class extends CauseError {
+	constructor(message, options) {
+		super(message, options);
+		this.circular = true;
+	}
+};
+
+//#endregion
+//#region ../yak-internals/cross-file-resolver/resolveCrossFileConstant.ts
+const yakCssImportRegex = /--yak-css-import:\s*url\("([^"]+)",?(|mixin|selector)\)(;?)/g;
+async function resolveCrossFileConstant$1(context, filePath, css) {
+	const resolveCrossFileConstant = context.cache?.resolveCrossFileConstant;
+	if (resolveCrossFileConstant === void 0) return uncachedResolveCrossFileConstant(context, filePath, css);
+	const cacheKey = await sha1(filePath + ":" + css);
+	const cached = resolveCrossFileConstant.get(cacheKey);
+	if (cached === void 0) {
+		const resolvedCrossFilConstantPromise = uncachedResolveCrossFileConstant(context, filePath, css);
+		resolveCrossFileConstant.set(cacheKey, resolvedCrossFilConstantPromise);
+		if (resolveCrossFileConstant.addDependency) {
+			resolveCrossFileConstant.addDependency(cacheKey, filePath);
+			resolvedCrossFilConstantPromise.then((value) => {
+				for (const dep of value.dependencies) resolveCrossFileConstant.addDependency(cacheKey, dep);
+			});
+		}
+		return resolvedCrossFilConstantPromise;
+	}
+	return cached;
+}
+async function uncachedResolveCrossFileConstant(context, filePath, css) {
+	const yakImports = await parseYakCssImport(context, filePath, css);
+	if (yakImports.length === 0) return {
+		resolved: css,
+		dependencies: []
+	};
+	try {
+		const dependencies = /* @__PURE__ */ new Set();
+		const resolvedValues = await Promise.all(yakImports.map(async ({ moduleSpecifier, specifier }) => {
+			const { resolved: resolvedModule } = await resolveModule$1(context, moduleSpecifier);
+			const resolvedValue = await resolveModuleSpecifierRecursively(context, resolvedModule, specifier);
+			for (const dependency of resolvedValue.from) dependencies.add(dependency);
+			return resolvedValue;
+		}));
+		let result = css;
+		for (let i = yakImports.length - 1; i >= 0; i--) {
+			const { position, size, importKind, specifier, semicolon } = yakImports[i];
+			const resolved = resolvedValues[i];
+			let replacement;
+			if (resolved.type === "unresolved-tag") replacement = importKind === "mixin" ? "" : "undefined";
+			else {
+				if (importKind === "selector") {
+					if (resolved.type !== "styled-component" && resolved.type !== "constant") throw new Error(`Found "${resolved.type}" but expected a selector - did you forget a semicolon after "${specifier.join(".")}"?`);
+				}
+				replacement = resolved.type === "styled-component" ? resolved.value : resolved.value + (["}", ";"].includes(String(resolved.value).trimEnd().slice(-1)) ? "" : semicolon);
+			}
+			result = result.slice(0, position) + String(replacement) + result.slice(position + size);
+		}
+		return {
+			resolved: result,
+			dependencies: Array.from(dependencies)
+		};
+	} catch (error) {
+		throw new CauseError(`Error while resolving cross-file selectors in file "${filePath}"`, { cause: error });
+	}
+}
+async function parseYakCssImport(context, filePath, css) {
+	const yakImports = [];
+	for (const match of css.matchAll(yakCssImportRegex)) {
+		const [fullMatch, encodedArguments, importKind, semicolon] = match;
+		const [moduleSpecifier, ...specifier] = encodedArguments.split(":").map((entry) => decodeURIComponent(entry));
+		yakImports.push({
+			encodedArguments,
+			moduleSpecifier: await context.resolve(moduleSpecifier, filePath),
+			specifier,
+			importKind,
+			semicolon,
+			position: match.index,
+			size: fullMatch.length
+		});
+	}
+	return yakImports;
+}
+async function resolveModule$1(context, filePath) {
+	if (context.cache?.resolve === void 0) return uncachedResolveModule(context, filePath);
+	const cached = context.cache.resolve.get(filePath);
+	if (cached === void 0) {
+		const resolvedPromise = uncachedResolveModule(context, filePath);
+		context.cache.resolve.set(filePath, resolvedPromise);
+		if (context.cache.resolve.addDependency) {
+			context.cache.resolve.addDependency(filePath, filePath);
+			resolvedPromise.then((value) => {
+				for (const dep of value.dependencies) context.cache.resolve.addDependency(filePath, dep);
+			});
+		}
+		return resolvedPromise;
+	}
+	return cached;
+}
+async function uncachedResolveModule(context, filePath) {
+	const parsedModule = await context.parse(filePath);
+	const exports = parsedModule.exports;
+	if (parsedModule.type !== "regular") return {
+		resolved: {
+			path: parsedModule.path,
+			exports
+		},
+		dependencies: []
+	};
+	const dependencies = /* @__PURE__ */ new Set();
+	if (parsedModule.styledComponents) Object.values(parsedModule.styledComponents).map((styledComponent) => {
+		if (styledComponent.nameParts.length === 1) exports.named[styledComponent.nameParts[0]] = {
+			type: "styled-component",
+			className: styledComponent.value
+		};
+		else {
+			let exportEntry = exports.named[styledComponent.nameParts[0]];
+			if (!exportEntry) {
+				exportEntry = {
+					type: "record",
+					value: {}
+				};
+				exports.named[styledComponent.nameParts[0]] = exportEntry;
+			} else if (exportEntry.type !== "record") throw new CauseError(`Error parsing file "${parsedModule.path}"`, { cause: `"${styledComponent.nameParts[0]}" is not a record` });
+			let current = exportEntry.value;
+			for (let i = 1; i < styledComponent.nameParts.length - 1; i++) {
+				let next = current[styledComponent.nameParts[i]];
+				if (!next) {
+					next = {
+						type: "record",
+						value: {}
+					};
+					current[styledComponent.nameParts[i]] = next;
+				} else if (next.type !== "record") throw new CauseError(`Error parsing file "${parsedModule.path}"`, { cause: `"${styledComponent.nameParts.slice(0, i + 1).join(".")}" is not a record` });
+				current = next.value;
+			}
+			current[styledComponent.nameParts[styledComponent.nameParts.length - 1]] = {
+				type: "styled-component",
+				className: styledComponent.value
+			};
+		}
+	});
+	if (parsedModule.mixins) await Promise.all(Object.values(parsedModule.mixins).map(async (mixin) => {
+		const { resolved, dependencies: deps } = await resolveCrossFileConstant$1(context, parsedModule.path, mixin.value);
+		for (const dep of deps) dependencies.add(dep);
+		if (mixin.nameParts.length === 1) exports.named[mixin.nameParts[0]] = {
+			type: "mixin",
+			value: resolved
+		};
+		else {
+			let exportEntry = exports.named[mixin.nameParts[0]];
+			if (!exportEntry) {
+				exportEntry = {
+					type: "record",
+					value: {}
+				};
+				exports.named[mixin.nameParts[0]] = exportEntry;
+			} else if (exportEntry.type !== "record") throw new CauseError(`Error parsing file "${parsedModule.path}"`, { cause: `"${mixin.nameParts[0]}" is not a record` });
+			let current = exportEntry.value;
+			for (let i = 1; i < mixin.nameParts.length - 1; i++) {
+				let next = current[mixin.nameParts[i]];
+				if (!next) {
+					next = {
+						type: "record",
+						value: {}
+					};
+					current[mixin.nameParts[i]] = next;
+				} else if (next.type !== "record") throw new CauseError(`Error parsing file "${parsedModule.path}"`, { cause: `"${mixin.nameParts.slice(0, i + 1).join(".")}" is not a record` });
+				current = next.value;
+			}
+			current[mixin.nameParts[mixin.nameParts.length - 1]] = {
+				type: "mixin",
+				value: resolved
+			};
+		}
+	}));
+	return {
+		resolved: {
+			path: parsedModule.path,
+			exports
+		},
+		dependencies: Array.from(dependencies)
+	};
+}
+async function resolveModuleSpecifierRecursively(context, resolvedModule, specifiers, seen = /* @__PURE__ */ new Set()) {
+	const exportName = specifiers[0];
+	const exportValue = resolvedModule.exports.named[exportName];
+	if (exportValue !== void 0) {
+		if (seen.has(resolvedModule.path + ":" + exportName)) throw new CircularDependencyError(`Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`, { cause: "Circular dependency detected" });
+		seen.add(resolvedModule.path + ":" + exportName);
+		return resolveModuleExport(context, resolvedModule.path, exportValue, specifiers, seen);
+	}
+	let i = 1;
+	for (const from of resolvedModule.exports.all) {
+		if (context.exportAllLimit && i++ > context.exportAllLimit) throw new ResolveError(`Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`, { cause: `More than ${context.exportAllLimit} star exports are not supported for performance reasons` });
+		try {
+			const resolved = await resolveModuleExport(context, resolvedModule.path, {
+				type: "re-export",
+				from,
+				name: exportName
+			}, specifiers, seen);
+			if (seen.has(resolvedModule.path + ":*")) throw new CircularDependencyError(`Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`, { cause: "Circular dependency detected" });
+			seen.add(resolvedModule.path + ":*");
+			return resolved;
+		} catch (error) {
+			if (!(error instanceof ResolveError)) throw error;
+			if (error.circular) throw error;
+		}
+	}
+	throw new ResolveError(`Unable to resolve "${specifiers.join(".")}"`, { cause: `no matching export found in module "${resolvedModule.path}"` });
+}
+async function resolveModuleExport(context, filePath, moduleExport, specifiers, seen) {
+	const failureMessage = `Unable to resolve "${specifiers.join(".")}" in module "${filePath}"`;
+	try {
+		switch (moduleExport.type) {
+			case "re-export": {
+				const { resolved: reExportedModule } = await resolveModule$1(context, await context.resolve(moduleExport.from, filePath));
+				const resolved = await resolveModuleSpecifierRecursively(context, reExportedModule, [moduleExport.name, ...specifiers.slice(1)], seen);
+				if (resolved) resolved.from.push(filePath);
+				return resolved;
+			}
+			case "namespace-re-export": {
+				const { resolved: reExportedModule } = await resolveModule$1(context, await context.resolve(moduleExport.from, filePath));
+				const resolved = await resolveModuleSpecifierRecursively(context, reExportedModule, specifiers.slice(1), seen);
+				if (resolved) resolved.from.push(filePath);
+				return resolved;
+			}
+			case "styled-component": return {
+				type: "styled-component",
+				from: [filePath],
+				source: filePath,
+				name: specifiers[specifiers.length - 1],
+				value: moduleExport.className
+			};
+			case "tag-template": return {
+				type: "unresolved-tag",
+				from: [filePath],
+				source: filePath,
+				name: specifiers[specifiers.length - 1]
+			};
+			case "constant": return {
+				type: "constant",
+				from: [filePath],
+				source: filePath,
+				value: moduleExport.value
+			};
+			case "record": return resolveModuleExport(context, filePath, resolveSpecifierInRecord(moduleExport, specifiers[0], specifiers.slice(1)), specifiers, seen);
+			case "mixin": return {
+				type: "mixin",
+				from: [filePath],
+				source: filePath,
+				value: moduleExport.value
+			};
+			case "unsupported": throw new UnsupportedExportError(failureMessage, { cause: explainUnsupported(filePath, specifiers.join("."), moduleExport.hint, moduleExport.source) });
+		}
+	} catch (error) {
+		if (error instanceof UnsupportedExportError) throw error;
+		throw new ResolveError(failureMessage, { cause: error });
+	}
+}
+function explainUnsupported(filePath, specifier, hint, source) {
+	const isYakFile = /\.yak\.(?:ts|tsx|js|jsx)$/.test(filePath);
+	const docs = "https://yak.js.org/docs/migration-from-styled-components#move-some-code-to-yak-files";
+	const snippet = source ? renderSourceSnippet(filePath, source, hint ?? "") : void 0;
+	const lines = [];
+	if (isYakFile) {
+		const got = hint ? ` (got \`${hint}\`)` : "";
+		lines.push(`\`${specifier}\` evaluated to a value that cannot be inlined into CSS${got}.`);
+		if (snippet) lines.push(snippet);
+		lines.push(`  help: replace it with a string, number, or plain object/array of those`, `  see:  ${docs}`);
+		return lines.join("\n");
+	}
+	const got = hint ? ` (got a ${hint})` : "";
+	lines.push(`\`${specifier}\` is not a string or number literal${got}.`);
+	if (snippet) lines.push(snippet);
+	lines.push(`  help: rename "${filePath}" to "${suggestYakFileName(filePath)}" so its exports run at build time`, `        (or replace \`${specifier}\` with a literal value)`, `  see:  ${docs}`);
+	return lines.join("\n");
+}
+function suggestYakFileName(filePath) {
+	const match = filePath.match(/^(.*)\.(ts|tsx|js|jsx)$/);
+	if (!match) return filePath;
+	return `${match[1]}.yak.${match[2]}`;
+}
+function renderSourceSnippet(filePath, source, label) {
+	const startLine = source.start.line;
+	const startCol = source.start.column;
+	const caretLen = source.end.line === startLine ? Math.max(1, source.end.column - startCol) : Math.max(1, source.lineText.length - startCol);
+	const lineNumStr = String(startLine);
+	const gutterPad = " ".repeat(lineNumStr.length);
+	return [
+		`   --> ${filePath}:${startLine}:${startCol + 1}`,
+		`    ${gutterPad} |`,
+		`    ${lineNumStr} | ${source.lineText}`,
+		`    ${gutterPad} | ${" ".repeat(startCol)}${"^".repeat(caretLen)} ${label}`
+	].join("\n");
+}
+function resolveSpecifierInRecord(record, name, specifiers) {
+	if (specifiers.length === 0) throw new ResolveError("did not expect an object");
+	let depth = 0;
+	let current = record;
+	while (current && current.type === "record" && depth < specifiers.length) {
+		current = current.value[specifiers[depth]];
+		depth += 1;
+	}
+	if (current === void 0 || depth !== specifiers.length) throw new ResolveError(`Unable to resolve "${specifiers.join(".")}" in object/array "${name}"`, { cause: "path not found" });
+	if (current.type === "constant" || current.type === "styled-component" || current.type === "mixin") return current;
+	if (current.type === "record" && "__yak" in current.value && current.value.__yak.type === "constant") return {
+		type: "mixin",
+		value: String(current.value.__yak.value)
+	};
+	throw new ResolveError(`Unable to resolve "${specifiers.join(".")}" in object/array "${name}"`, { cause: "only string and numbers are supported" });
+}
+async function sha1(message) {
+	const resultBuffer = await globalThis.crypto.subtle.digest("SHA-1", new TextEncoder().encode(message));
+	return Array.from(new Uint8Array(resultBuffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+//#region ../yak-internals/packageNames.ts
+const yakPackageNames = ["@yak/react", "@yak/solid"];
+
+//#endregion
+//#region ../yak-internals/loaders/lib/parseExports.ts
+async function parseExports(sourceContents) {
+	try {
+		const ast = parse(sourceContents, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		const moduleExports = {
+			importYak: ast.program.body.some((node) => node.type === "ImportDeclaration" && yakPackageNames.includes(node.source.value)),
+			named: {},
+			all: []
+		};
+		const variableDeclarations = {};
+		const importBindings = {};
+		const localExportSpecifiers = [];
+		let defaultIdentifier = null;
+		for (const node of ast.program.body) {
+			if (node.type === "ImportDeclaration") {
+				for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") importBindings[specifier.local.name] = {
+					type: "re-export",
+					from: node.source.value,
+					name: specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value
+				};
+				else if (specifier.type === "ImportDefaultSpecifier") importBindings[specifier.local.name] = {
+					type: "re-export",
+					from: node.source.value,
+					name: "default"
+				};
+				else if (specifier.type === "ImportNamespaceSpecifier") importBindings[specifier.local.name] = {
+					type: "namespace-re-export",
+					from: node.source.value
+				};
+			}
+			if (node.type === "VariableDeclaration") {
+				for (const decl of node.declarations) if (decl.id.type === "Identifier" && decl.init) variableDeclarations[decl.id.name] = decl.init;
+			}
+			if (node.type === "ExportNamedDeclaration") {
+				if (node.source) for (const specifier of node.specifiers) {
+					if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.local.type === "Identifier") moduleExports.named[specifier.exported.name] = {
+						type: "re-export",
+						from: node.source.value,
+						name: specifier.local.name
+					};
+					if (specifier.type === "ExportNamespaceSpecifier" && specifier.exported.type === "Identifier") moduleExports.named[specifier.exported.name] = {
+						type: "namespace-re-export",
+						from: node.source.value
+					};
+				}
+				else if (!node.declaration) {
+					for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.local.type === "Identifier") localExportSpecifiers.push({
+						local: specifier.local.name,
+						exported: specifier.exported.name
+					});
+				} else if (node.declaration.type === "VariableDeclaration") {
+					for (const declaration of node.declaration.declarations) if (declaration.id.type === "Identifier" && declaration.init) {
+						variableDeclarations[declaration.id.name] = declaration.init;
+						const parsed = parseExportValueExpression(declaration.init, sourceContents);
+						if (parsed) moduleExports.named[declaration.id.name] = parsed;
+					}
+				}
+			}
+			if (node.type === "ExportDefaultDeclaration") {
+				if (node.declaration.type === "Identifier") defaultIdentifier = node.declaration.name;
+				else if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") moduleExports.named["default"] = {
+					type: "unsupported",
+					hint: node.declaration.type,
+					source: extractUnsupportedSource(node.declaration.loc, sourceContents)
+				};
+				else moduleExports.named["default"] = parseExportValueExpression(node.declaration, sourceContents);
+			}
+			if (node.type === "ExportAllDeclaration") moduleExports.all.push(node.source.value);
+		}
+		const resolveIdentifier = (name) => {
+			if (variableDeclarations[name]) return parseExportValueExpression(variableDeclarations[name], sourceContents);
+			return importBindings[name];
+		};
+		for (const { local, exported } of localExportSpecifiers) {
+			const resolved = resolveIdentifier(local);
+			if (resolved) moduleExports.named[exported] = resolved;
+		}
+		if (defaultIdentifier) {
+			const resolved = resolveIdentifier(defaultIdentifier);
+			if (resolved) moduleExports.named["default"] = resolved;
+		}
+		return moduleExports;
+	} catch (error) {
+		throw new Error(`Error parsing exports: ${error.message}`);
+	}
+}
+function unpackTSAsExpression(node) {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") return unpackTSAsExpression(node.expression);
+	return node;
+}
+function parseExportValueExpression(node, code) {
+	const expression = unpackTSAsExpression(node);
+	if (expression.type === "CallExpression" || expression.type === "TaggedTemplateExpression") return { type: "tag-template" };
+	else if (expression.type === "StringLiteral" || expression.type === "NumericLiteral") return {
+		type: "constant",
+		value: expression.value
+	};
+	else if (expression.type === "UnaryExpression" && expression.operator === "-" && expression.argument.type === "NumericLiteral") return {
+		type: "constant",
+		value: -expression.argument.value
+	};
+	else if (expression.type === "TemplateLiteral" && expression.quasis.length === 1) return {
+		type: "constant",
+		value: expression.quasis[0].value.raw
+	};
+	else if (expression.type === "ObjectExpression") return {
+		type: "record",
+		value: parseObjectExpression(expression, code)
+	};
+	return {
+		type: "unsupported",
+		hint: expression.type,
+		source: extractUnsupportedSource(expression.loc, code)
+	};
+}
+function parseObjectExpression(node, code) {
+	let result = {};
+	for (const property of node.properties) if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+		const key = property.key.name;
+		const parsed = parseExportValueExpression(property.value, code);
+		if (parsed) result[key] = parsed;
+	}
+	return result;
+}
+function extractUnsupportedSource(loc, code) {
+	if (!loc || !code) return void 0;
+	const lineText = code.split(/\r?\n/)[loc.start.line - 1];
+	if (lineText === void 0) return void 0;
+	return {
+		start: {
+			line: loc.start.line,
+			column: loc.start.column
+		},
+		end: {
+			line: loc.end.line,
+			column: loc.end.column
+		},
+		lineText
+	};
+}
+
+//#endregion
+//#region loaders/lib/resolveCrossFileSelectors.ts
+const compilationCache = /* @__PURE__ */ new WeakMap();
+async function resolveCrossFileConstant(loader, pathContext, css) {
+	const { resolved } = await resolveCrossFileConstant$1(getResolveContext(loader), loader.resourcePath, css);
+	return resolved;
+}
+function getCompilationCache(loader) {
+	const compilation = loader._compilation;
+	if (!compilation) throw new Error("Webpack compilation object not available");
+	let cache = compilationCache.get(compilation);
+	if (!cache) {
+		cache = { parsedFiles: /* @__PURE__ */ new Map() };
+		compilationCache.set(compilation, cache);
+	}
+	return cache;
+}
+function getParseContext(loader) {
+	return {
+		cache: { parse: getCompilationCache(loader).parsedFiles },
+		async extractExports(modulePath) {
+			const sourceContents = new Promise((resolve, reject) => loader.fs.readFile(modulePath, "utf-8", (err, result) => {
+				if (err) return reject(err);
+				resolve(result || "");
+			}));
+			return parseExports(await sourceContents);
+		},
+		async getTransformed(modulePath) {
+			return { code: await new Promise((resolve, reject) => {
+				loader.loadModule(modulePath, (err, source) => {
+					if (err) {
+						const compilation = loader._compilation;
+						if (compilation) try {
+							for (const mod of compilation.modules) if ("resource" in mod && mod.resource === modulePath) {
+								const errors = mod.getErrors();
+								if (errors) {
+									const messages = Array.from(errors).map((e) => e.message).filter(Boolean);
+									if (messages.length > 0) return reject(new Error(messages.join("\n")));
+								}
+							}
+						} catch {}
+						return reject(err);
+					}
+					let sourceString;
+					if (typeof source === "string") sourceString = source;
+					else if (source instanceof Buffer) sourceString = source.toString("utf-8");
+					else if (source instanceof ArrayBuffer) sourceString = new TextDecoder("utf-8").decode(source);
+					else throw new Error("Invalid input type: code must be string, Buffer, or ArrayBuffer");
+					resolve(sourceString || "");
+				});
+			}) };
+		},
+		async evaluateYakModule(modulePath) {
+			return loader.importModule(modulePath);
+		}
+	};
+}
+function getResolveContext(loader) {
+	const parseContext = getParseContext(loader);
+	return {
+		parse: (modulePath) => parseModule(parseContext, modulePath),
+		resolve: async (specifier, importer) => {
+			return resolveModule(loader, specifier, dirname(importer));
+		}
+	};
+}
+async function resolveModule(loader, moduleSpecifier, context) {
+	return new Promise((resolve, reject) => {
+		loader.resolve(context, moduleSpecifier, (err, result) => {
+			if (err) return reject(err);
+			if (!result) return reject(/* @__PURE__ */ new Error(`Could not resolve ${moduleSpecifier}`));
+			resolve(result);
+		});
+	});
+}
+const DIRNAME_POSIX_REGEX = /^((?:\.(?![^/]))|(?:(?:\/?|)(?:[\s\S]*?)))(?:\/+?|)(?:(?:\.{1,2}|[^/]+?|)(?:\.[^./]*|))(?:[/]*)$/;
+const DIRNAME_WIN32_REGEX = /^((?:\.(?![^\\]))|(?:(?:\\?|)(?:[\s\S]*?)))(?:\\+?|)(?:(?:\.{1,2}|[^\\]+?|)(?:\.[^.\\]*|))(?:[\\]*)$/;
+function dirname(path) {
+	let dirname = DIRNAME_POSIX_REGEX.exec(path)?.[1];
+	if (!dirname) dirname = DIRNAME_WIN32_REGEX.exec(path)?.[1];
+	if (!dirname) throw new Error(`Can't extract dirname from ${path}`);
+	return dirname;
+}
+
+//#endregion
+//#region loaders/webpack-loader.ts
+async function cssExtractLoader(_code, sourceMap) {
+	const callback = this.async();
+	return this.loadModule(this.resourcePath, (err, source) => {
+		if (err) return callback(err);
+		if (!source) return callback(/* @__PURE__ */ new Error(`Source code for ${this.resourcePath} is empty`));
+		const { debug } = this.getOptions();
+		const debugLog = createDebugLogger(debug, this._compiler?.context ?? process.cwd());
+		debugLog("ts", source, this.resourcePath);
+		const css = extractCss(source);
+		debugLog("css", css, this.resourcePath);
+		return resolveCrossFileConstant(this, this.context, css).then((result) => {
+			debugLog("css-resolved", result, this.resourcePath);
+			return callback(null, result, sourceMap);
+		}, callback);
+	});
+}
+
+//#endregion
+export { cssExtractLoader as default };
+//# sourceMappingURL=webpack-loader.js.map