react-icons-sprite 0.9.1 → 0.9.2-rc.1

package/dist/build-sprite-BFhBc3Ev.mjs

@@ -0,0 +1,73 @@
+import { r as resolveIconImport, t as computeIconId } from "./compute-icon-id-C96eIC66.mjs";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+//#region src/sprite/render-icon.ts
+const SVG_INNER_RE = /<svg\b[^>]*>([\s\S]*?)<\/svg>/i;
+const VIEWBOX_RE = /viewBox=["']([^"']+)["']/i;
+const SVG_OPEN_RE = /<svg\b([^>]*)>/i;
+const SVG_ATTR_RE = /([:\w-]+)=("[^"]*"|'[^']*')/g;
+const OMITTED_SVG_ATTRIBUTES = new Set([
+	"xmlns",
+	"viewBox",
+	"width",
+	"height"
+]);
+const extractSymbolAttributes = (svgMarkup) => {
+	const openingAttributes = SVG_OPEN_RE.exec(svgMarkup)?.[1];
+	if (!openingAttributes) return "";
+	const attributes = [];
+	for (const [, name, value] of openingAttributes.matchAll(SVG_ATTR_RE)) {
+		if (OMITTED_SVG_ATTRIBUTES.has(name)) continue;
+		attributes.push(`${name}=${value}`);
+	}
+	return attributes.join(" ");
+};
+const pickExport = (moduleExports, exportName) => {
+	if (exportName === "default") return moduleExports.default;
+	return moduleExports[exportName] ?? moduleExports.default;
+};
+const isRenderableComponent = (value) => {
+	if (typeof value === "function") return true;
+	if (!value || typeof value !== "object") return false;
+	return "$$typeof" in value;
+};
+const isFontAwesomeIconDefinition = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const icon = value.icon;
+	if (!Array.isArray(icon) || icon.length < 5) return false;
+	return typeof icon[0] === "number" && typeof icon[1] === "number";
+};
+const renderFontAwesomeIconDefinition = (iconDefinition) => {
+	const [width, height, , , svgPathData] = iconDefinition.icon;
+	return {
+		symbolBody: (Array.isArray(svgPathData) ? svgPathData : [svgPathData]).map((d) => `<path d="${d}"/>`).join(""),
+		viewBox: `0 0 ${width} ${height}`,
+		symbolAttributes: ""
+	};
+};
+const renderIcon = async (pack, exportName) => {
+	const iconComponent = pickExport(await import(resolveIconImport(pack, exportName)), exportName);
+	if (isFontAwesomeIconDefinition(iconComponent)) return renderFontAwesomeIconDefinition(iconComponent);
+	if (!isRenderableComponent(iconComponent)) throw new Error(`[react-icons-sprite] Unable to render icon "${exportName}" from "${pack}". Expected a React component export.`);
+	const svgMarkup = renderToStaticMarkup(createElement(iconComponent));
+	const svgInner = SVG_INNER_RE.exec(svgMarkup)?.[1];
+	if (!svgInner) throw new Error(`[react-icons-sprite] Unable to extract SVG content for "${exportName}" from "${pack}".`);
+	return {
+		symbolBody: svgInner,
+		viewBox: VIEWBOX_RE.exec(svgMarkup)?.[1] ?? "0 0 24 24",
+		symbolAttributes: extractSymbolAttributes(svgMarkup)
+	};
+};
+//#endregion
+//#region src/sprite/build-sprite.ts
+const buildSprite = async (icons) => {
+	if (!icons.length) return "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"display:none\"></svg>";
+	return `<svg xmlns="http://www.w3.org/2000/svg" style="display:none">${(await Promise.all(icons.map(async ({ pack, exportName }) => {
+		const rendered = await renderIcon(pack, exportName);
+		const id = computeIconId(pack, exportName);
+		const symbolAttributes = rendered.symbolAttributes ? ` ${rendered.symbolAttributes}` : "";
+		return `<symbol id="${id}" viewBox="${rendered.viewBox}"${symbolAttributes}>${rendered.symbolBody}</symbol>`;
+	}))).join("")}</svg>`;
+};
+//#endregion
+export { buildSprite as t };

package/dist/{collector-BvJbH8Da.mjs → collector-C6kn7NXC.mjs}

@@ -1,4 +1,4 @@
-import { r as createCollector } from "./core-B0kAb7AT.mjs";
+import { i as createCollector } from "./compute-icon-id-C96eIC66.mjs";
 //#region src/collector.ts
 const collector = createCollector();
 //#endregion

package/dist/compute-icon-id-C96eIC66.mjs

@@ -0,0 +1,62 @@
+//#region src/collector/create-collector.ts
+const createCollector = () => {
+	const collected = /* @__PURE__ */ new Set();
+	return {
+		add(pack, exportName) {
+			collected.add(`${pack}:${exportName}`);
+		},
+		toList() {
+			return [...collected].map((key) => {
+				const [pack, exportName] = key.split(":");
+				return {
+					pack,
+					exportName
+				};
+			});
+		},
+		clear() {
+			collected.clear();
+		}
+	};
+};
+//#endregion
+//#region src/utils/kebab-case.ts
+const kebabCase = (value) => {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-z0-9]+/gi, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").toLowerCase();
+};
+//#endregion
+//#region src/packs/icon-resolvers.ts
+const DEFAULT_ICON_SOURCES = [
+	/^react-icons\/[\w-]+$/,
+	/^@fortawesome\/[\w-]+-svg-icons$/,
+	/^lucide-react$/,
+	/^@heroicons\/react(?:\/.*)?$/,
+	/^@tabler\/icons-react$/,
+	/^@radix-ui\/react-icons$/,
+	/^phosphor-react$/,
+	/^@phosphor-icons\/react$/,
+	/^react-feather$/,
+	/^react-bootstrap-icons$/,
+	/^grommet-icons$/,
+	/^@remixicon\/react$/,
+	/^devicons-react$/,
+	/^@mui\/icons-material(?:\/.*)?$/,
+	/^@carbon\/icons-react$/
+];
+const resolvers = {
+	"lucide-react": (_pack, name) => `lucide-react/dist/esm/icons/${kebabCase(name)}.js`,
+	"@tabler/icons-react": (_pack, name) => `@tabler/icons-react/dist/esm/icons/${name}.mjs`
+};
+const resolveIconImport = (pack, exportName) => {
+	return resolvers[pack]?.(pack, exportName) ?? pack;
+};
+//#endregion
+//#region src/utils/compute-icon-id.ts
+const normalizePackAlias = (pack) => {
+	return kebabCase(pack.replace(/^@/, ""));
+};
+const computeIconId = (pack, iconName) => {
+	return `ri-${normalizePackAlias(pack)}-${iconName}`;
+};
+//#endregion
+export { createCollector as i, DEFAULT_ICON_SOURCES as n, resolveIconImport as r, computeIconId as t };

package/dist/transform-module-DzmqobWK.mjs

@@ -0,0 +1,290 @@
+import { n as DEFAULT_ICON_SOURCES, t as computeIconId } from "./compute-icon-id-C96eIC66.mjs";
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
+//#region src/transform/edit-applier.ts
+const applyEdits = (code, edits) => {
+	const magicString = new MagicString(code);
+	for (const edit of edits) {
+		if (edit.type === "replace") magicString.overwrite(edit.from, edit.to, edit.value);
+		if (edit.type === "insert") magicString.appendLeft(edit.pos, edit.value);
+		if (edit.type === "remove") magicString.remove(edit.from, edit.to);
+	}
+	return magicString;
+};
+//#endregion
+//#region src/transform/edit-builder.ts
+const buildEdits = (usages, componentName, usedSymbols, register) => {
+	const edits = [];
+	for (const usage of usages) {
+		edits.push({
+			type: "replace",
+			from: usage.range[0],
+			to: usage.range[1],
+			value: componentName
+		});
+		if (usage.kind === "opening") {
+			edits.push({
+				type: "insert",
+				pos: usage.range[1],
+				value: ` iconId="${computeIconId(usage.pack, usage.exportName)}"`
+			});
+			usedSymbols.add(usage.local);
+			register(usage.pack, usage.exportName);
+		}
+	}
+	return edits;
+};
+//#endregion
+//#region src/transform/fast-filter.ts
+const fastFilter = (code) => {
+	if (!code.includes("<")) return false;
+	if (!code.includes("import")) return false;
+	return true;
+};
+//#endregion
+//#region src/transform/import-scanner.ts
+const IMPORT_RE = /import\s+([^;]+?)\s+from\s+['"]([^'"]+)['"]/g;
+const scanIconImports = (code, sources) => {
+	const imports = [];
+	for (const match of code.matchAll(IMPORT_RE)) {
+		const [, specifier, pack] = match;
+		if (!sources.some((source) => source.test(pack))) continue;
+		const names = specifier.replace(/[{}]/g, "").split(",").map((segment) => segment.trim()).filter(Boolean).map((segment) => segment.split(" as ")[1] ?? segment);
+		imports.push({
+			pack,
+			names
+		});
+	}
+	return imports;
+};
+//#endregion
+//#region src/transform/usage-scanner.ts
+const detectUsage = (code, names) => {
+	if (!names.length) return false;
+	const escaped = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+	return new RegExp(`<(${escaped.join("|")})\\b`).test(code);
+};
+//#endregion
+//#region src/transform/transform-module.ts
+const ICON_SOURCE = "react-icons-sprite";
+const ICON_COMPONENT_NAME = "ReactIconsSpriteIcon";
+const FONTAWESOME_REACT_PACK = "@fortawesome/react-fontawesome";
+const isFontAwesomeIconPack = (pack) => {
+	return /^@fortawesome\/[\w-]+-svg-icons$/.test(pack);
+};
+const isObject = (value) => {
+	return Boolean(value) && typeof value === "object";
+};
+const walkAst = (node, visit) => {
+	if (!isObject(node)) return;
+	visit(node);
+	for (const value of Object.values(node)) {
+		if (Array.isArray(value)) {
+			for (const child of value) walkAst(child, visit);
+			continue;
+		}
+		walkAst(value, visit);
+	}
+};
+const buildSymbolTable = (program, sources) => {
+	const table = /* @__PURE__ */ new Map();
+	const body = program.body ?? [];
+	for (const node of body) {
+		if (!isObject(node) || node.type !== "ImportDeclaration") continue;
+		const source = isObject(node.source) ? node.source : void 0;
+		const pack = typeof source?.value === "string" ? source.value : void 0;
+		if (!pack || !sources.some((sourceMatcher) => sourceMatcher.test(pack))) continue;
+		const specifiers = node.specifiers ?? [];
+		for (const specifier of specifiers) {
+			if (!isObject(specifier) || !isObject(specifier.local)) continue;
+			const localName = specifier.local.name;
+			if (typeof localName !== "string") continue;
+			if (specifier.type === "ImportSpecifier") {
+				const imported = isObject(specifier.imported) ? specifier.imported : void 0;
+				const importedName = typeof imported?.name === "string" ? imported.name : typeof imported?.value === "string" ? imported.value : void 0;
+				if (importedName) table.set(localName, {
+					pack,
+					exportName: importedName
+				});
+				continue;
+			}
+			if (specifier.type === "ImportDefaultSpecifier") table.set(localName, {
+				pack,
+				exportName: "default"
+			});
+		}
+	}
+	return table;
+};
+const detectIconUsage = (program, symbols) => {
+	const usages = [];
+	walkAst(program, (node) => {
+		if (node.type !== "JSXOpeningElement" && node.type !== "JSXClosingElement") return;
+		const name = isObject(node.name) ? node.name : void 0;
+		if (!name || name.type !== "JSXIdentifier" || typeof name.name !== "string") return;
+		const symbol = symbols.get(name.name);
+		if (!symbol) return;
+		const range = name.range;
+		if (!range || range.length !== 2) return;
+		usages.push({
+			local: name.name,
+			range,
+			pack: symbol.pack,
+			exportName: symbol.exportName,
+			kind: node.type === "JSXOpeningElement" ? "opening" : "closing"
+		});
+	});
+	return usages;
+};
+const detectFontAwesomeComponents = (program) => {
+	const componentLocals = /* @__PURE__ */ new Set();
+	const body = program.body ?? [];
+	for (const node of body) {
+		if (!isObject(node) || node.type !== "ImportDeclaration") continue;
+		if ((isObject(node.source) ? node.source : void 0)?.value !== FONTAWESOME_REACT_PACK) continue;
+		const specifiers = node.specifiers ?? [];
+		for (const specifier of specifiers) {
+			if (!isObject(specifier) || specifier.type !== "ImportSpecifier" || !isObject(specifier.local) || !isObject(specifier.imported)) continue;
+			const importedName = typeof specifier.imported.name === "string" ? specifier.imported.name : void 0;
+			const localName = typeof specifier.local.name === "string" ? specifier.local.name : void 0;
+			if (importedName === "FontAwesomeIcon" && localName) componentLocals.add(localName);
+		}
+	}
+	return componentLocals;
+};
+const detectFontAwesomeIconUsages = (program, symbols, fontAwesomeComponentLocals) => {
+	if (!fontAwesomeComponentLocals.size) return [];
+	const usages = [];
+	walkAst(program, (node) => {
+		if (node.type !== "JSXOpeningElement") return;
+		const name = isObject(node.name) ? node.name : void 0;
+		if (!name || name.type !== "JSXIdentifier" || typeof name.name !== "string" || !fontAwesomeComponentLocals.has(name.name)) return;
+		const componentRange = name.range;
+		if (!componentRange || componentRange.length !== 2) return;
+		const attributes = node.attributes ?? [];
+		for (const attribute of attributes) {
+			if (!isObject(attribute) || attribute.type !== "JSXAttribute") continue;
+			const attributeName = isObject(attribute.name) ? attribute.name : void 0;
+			if (!attributeName || attributeName.type !== "JSXIdentifier" || attributeName.name !== "icon") continue;
+			const value = isObject(attribute.value) ? attribute.value : void 0;
+			if (!value || value.type !== "JSXExpressionContainer") continue;
+			const expression = isObject(value.expression) ? value.expression : void 0;
+			if (!expression || expression.type !== "Identifier" || typeof expression.name !== "string") continue;
+			const symbol = symbols.get(expression.name);
+			if (!symbol || !isFontAwesomeIconPack(symbol.pack)) continue;
+			const iconAttributeRange = attribute.range;
+			if (!iconAttributeRange || iconAttributeRange.length !== 2) continue;
+			usages.push({
+				componentRange,
+				iconAttributeRange,
+				iconLocal: expression.name,
+				pack: symbol.pack,
+				exportName: symbol.exportName
+			});
+			break;
+		}
+	});
+	return usages;
+};
+const cleanupImports = (program, symbols, usedLocals) => {
+	const edits = [];
+	const body = program.body ?? [];
+	for (const node of body) {
+		if (!isObject(node) || node.type !== "ImportDeclaration") continue;
+		const specifiers = node.specifiers ?? [];
+		const declarationRange = node.range;
+		let hasUsedIconSpecifier = false;
+		for (const specifier of specifiers) {
+			if (!isObject(specifier) || !isObject(specifier.local)) continue;
+			const localName = specifier.local.name;
+			if (typeof localName === "string" && symbols.has(localName) && usedLocals.has(localName)) {
+				hasUsedIconSpecifier = true;
+				break;
+			}
+		}
+		if (hasUsedIconSpecifier && declarationRange) edits.push({
+			type: "remove",
+			from: declarationRange[0],
+			to: declarationRange[1]
+		});
+	}
+	return edits;
+};
+const transformModule = (code, id, register, sources = DEFAULT_ICON_SOURCES) => {
+	if (!fastFilter(code)) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const scanned = scanIconImports(code, sources);
+	if (!scanned.length) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const hasJsxComponentUsage = detectUsage(code, scanned.flatMap((item) => item.names));
+	const hasPotentialFontAwesomeUsage = code.includes(FONTAWESOME_REACT_PACK) && scanned.some((item) => isFontAwesomeIconPack(item.pack));
+	if (!hasJsxComponentUsage && !hasPotentialFontAwesomeUsage) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const program = parseSync(id, code, {
+		lang: "tsx",
+		sourceType: "module",
+		range: true
+	}).program;
+	const table = buildSymbolTable(program, sources);
+	if (!table.size) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const usages = detectIconUsage(program, table);
+	const fontAwesomeUsages = detectFontAwesomeIconUsages(program, table, detectFontAwesomeComponents(program));
+	if (!usages.length && !fontAwesomeUsages.length) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const used = /* @__PURE__ */ new Set();
+	const edits = buildEdits(usages, ICON_COMPONENT_NAME, used, register);
+	const registeredFontAwesomeIcons = /* @__PURE__ */ new Set();
+	for (const usage of fontAwesomeUsages) {
+		edits.push({
+			type: "replace",
+			from: usage.componentRange[0],
+			to: usage.componentRange[1],
+			value: ICON_COMPONENT_NAME
+		});
+		edits.push({
+			type: "insert",
+			pos: usage.componentRange[1],
+			value: ` iconId="${computeIconId(usage.pack, usage.exportName)}"`
+		});
+		edits.push({
+			type: "remove",
+			from: usage.iconAttributeRange[0],
+			to: usage.iconAttributeRange[1]
+		});
+		used.add(usage.iconLocal);
+		const key = `${usage.pack}:${usage.exportName}`;
+		if (!registeredFontAwesomeIcons.has(key)) {
+			registeredFontAwesomeIcons.add(key);
+			register(usage.pack, usage.exportName);
+		}
+	}
+	const cleanupEdits = cleanupImports(program, table, used);
+	const magicString = applyEdits(code, [...edits, ...cleanupEdits]);
+	if (!code.includes("react-icons-sprite")) magicString.prepend(`import { ${ICON_COMPONENT_NAME} } from "${ICON_SOURCE}";\n`);
+	return {
+		code: magicString.toString(),
+		map: magicString.generateMap({
+			source: id,
+			hires: true
+		}),
+		anyReplacements: true
+	};
+};
+//#endregion
+export { transformModule as t };

package/dist/vite/plugin.mjs

@@ -1,5 +1,7 @@
 import { REACT_ICONS_SPRITE_URL_PLACEHOLDER } from "../index.mjs";
-import { i as transformModule, n as buildSprite, r as createCollector, t as DEFAULT_ICON_SOURCES } from "../core-B0kAb7AT.mjs";
+import { i as createCollector, n as DEFAULT_ICON_SOURCES } from "../compute-icon-id-C96eIC66.mjs";
+import { t as buildSprite } from "../build-sprite-BFhBc3Ev.mjs";
+import { t as transformModule } from "../transform-module-DzmqobWK.mjs";
 import { createHash } from "node:crypto";
 //#region src/vite/plugin.ts
 const reactIconsSprite = (options = {}) => {
@@ -18,7 +20,7 @@ const reactIconsSprite = (options = {}) => {
 			try {
 				const { code: next, map, anyReplacements } = transformModule(code, id, (pack, exportName) => {
 					collector.add(pack, exportName);
-				}, DEFAULT_ICON_SOURCES, { sourceMap: true });
+				}, DEFAULT_ICON_SOURCES);
 				if (!anyReplacements) return null;
 				return {
 					code: next,

package/dist/webpack/loader.mjs

@@ -1,5 +1,5 @@
-import { i as transformModule } from "../core-B0kAb7AT.mjs";
-import { t as collector } from "../collector-BvJbH8Da.mjs";
+import { t as transformModule } from "../transform-module-DzmqobWK.mjs";
+import { t as collector } from "../collector-C6kn7NXC.mjs";
 //#region src/webpack/loader.ts
 const reactIconsSpriteLoader = async function(source) {
 	if (this.mode === "development") return source;

package/dist/webpack/plugin.mjs

@@ -1,6 +1,6 @@
 import { REACT_ICONS_SPRITE_URL_PLACEHOLDER } from "../index.mjs";
-import { n as buildSprite } from "../core-B0kAb7AT.mjs";
-import { t as collector } from "../collector-BvJbH8Da.mjs";
+import { t as buildSprite } from "../build-sprite-BFhBc3Ev.mjs";
+import { t as collector } from "../collector-C6kn7NXC.mjs";
 import { createHash } from "node:crypto";
 //#region src/webpack/plugin.ts
 var ReactIconsSpriteWebpackPlugin = class {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "react-icons-sprite",
-  "version": "0.9.1",
+  "version": "0.9.2-rc.1",
   "type": "module",
   "description": "A lightweight Vite, Rsbuild and Webpack plugin for react-icons that builds a single SVG sprite and rewrites icons to <use>, reducing bundle size and runtime overhead.",
   "author": "Jure Rotar <hello@jurerotar.com>",

package/dist/core-B0kAb7AT.mjs

@@ -1,404 +0,0 @@
-import { createElement } from "react";
-import { renderToStaticMarkup } from "react-dom/server";
-import MagicString from "magic-string";
-import { Visitor, parseSync } from "oxc-parser";
-//#region src/core.ts
-const ICON_SOURCE = "react-icons-sprite";
-const ICON_COMPONENT_NAME = "ReactIconsSpriteIcon";
-const DEFAULT_ICON_SOURCES = [
-	/^react-icons\/[\w-]+$/,
-	/^lucide-react$/,
-	/^@radix-ui\/react-icons$/,
-	/^@heroicons\/react(?:\/.*)?$/,
-	/^@tabler\/icons-react$/,
-	/^phosphor-react$/,
-	/^@phosphor-icons\/react$/,
-	/^react-feather$/,
-	/^react-bootstrap-icons$/,
-	/^grommet-icons$/,
-	/^@remixicon\/react$/,
-	/^devicons-react$/,
-	/^@fortawesome\/react-fontawesome$/,
-	/^@fortawesome\/[\w-]+-svg-icons$/,
-	/^@mui\/icons-material(?:\/.*)?$/,
-	/^@carbon\/icons-react$/
-];
-const sourceMatchesSupported = (source, sources = DEFAULT_ICON_SOURCES) => sources.some((re) => re.test(source));
-const normalizeAlias = (pack) => {
-	return pack.replace(/^@/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-};
-const computeIconId = (pack, exportName) => {
-	return `ri-${normalizeAlias(pack)}-${exportName}`;
-};
-const getRange = (node) => {
-	if (Array.isArray(node.range) && node.range.length === 2) return [node.range[0], node.range[1]];
-	if (typeof node.start === "number" && typeof node.end === "number") return [node.start, node.end];
-	return null;
-};
-const getParseLangCandidates = (filename) => {
-	const lower = (filename.split("?", 1)[0] ?? filename).toLowerCase();
-	if (lower.endsWith(".tsx")) return [
-		"tsx",
-		"ts",
-		"jsx",
-		"js"
-	];
-	if (lower.endsWith(".ts")) return [
-		"ts",
-		"tsx",
-		"js",
-		"jsx"
-	];
-	if (lower.endsWith(".jsx")) return [
-		"jsx",
-		"js",
-		"tsx",
-		"ts"
-	];
-	return [
-		"js",
-		"jsx",
-		"ts",
-		"tsx"
-	];
-};
-const parseAst = (code, filename) => {
-	const languages = getParseLangCandidates(filename);
-	let firstResult;
-	for (const lang of languages) {
-		const result = parseSync(filename, code, {
-			lang,
-			sourceType: "module",
-			range: true
-		});
-		firstResult ??= result;
-		if (result.errors.length === 0) return result;
-	}
-	return firstResult ?? parseSync(filename, code, {
-		lang: "tsx",
-		sourceType: "module",
-		range: true
-	});
-};
-const collectIconImports = (program, sources = DEFAULT_ICON_SOURCES) => {
-	const map = /* @__PURE__ */ new Map();
-	const body = program.body ?? [];
-	for (const node of body) {
-		if (node.type !== "ImportDeclaration") continue;
-		const pack = node.source?.value;
-		if (typeof pack !== "string" || !sourceMatchesSupported(pack, sources) || node.importKind === "type") continue;
-		const specifiers = node.specifiers ?? [];
-		for (const spec of specifiers) if (spec.type === "ImportSpecifier") {
-			if (spec.importKind === "type") continue;
-			const imported = spec.imported;
-			const local = spec.local;
-			if (imported?.type === "Identifier" && local?.type === "Identifier" && imported.name && local.name) map.set(local.name, {
-				pack,
-				exportName: imported.name,
-				decl: node,
-				spec
-			});
-		} else if (spec.type === "ImportDefaultSpecifier") {
-			const local = spec.local;
-			if (local?.type === "Identifier" && local.name) map.set(local.name, {
-				pack,
-				exportName: "default",
-				decl: node,
-				spec
-			});
-		}
-	}
-	return map;
-};
-const findExistingIconImport = (program) => {
-	let iconLocalName = ICON_COMPONENT_NAME;
-	let hasIconImport = false;
-	const body = program.body ?? [];
-	for (const node of body) {
-		if (node.type !== "ImportDeclaration") continue;
-		if (node.source?.value !== "react-icons-sprite") continue;
-		const specifiers = node.specifiers ?? [];
-		for (const spec of specifiers) {
-			if (spec.type !== "ImportSpecifier") continue;
-			const imported = spec.imported;
-			if (imported?.type === "Identifier" && imported.name === "ReactIconsSpriteIcon") {
-				hasIconImport = true;
-				const local = spec.local;
-				iconLocalName = local?.type === "Identifier" && local.name ? local.name : ICON_COMPONENT_NAME;
-				break;
-			}
-		}
-		if (hasIconImport) break;
-	}
-	return {
-		hasIconImport,
-		iconLocalName
-	};
-};
-const removeImportSpecifier = (ms, code, spec) => {
-	const range = getRange(spec);
-	if (!range) return;
-	const [start, end] = range;
-	let from = start;
-	let to = end;
-	let i = start - 1;
-	while (i >= 0 && /\s/.test(code[i])) i -= 1;
-	if (i >= 0 && code[i] === ",") from = i;
-	else {
-		let j = end;
-		while (j < code.length && /\s/.test(code[j])) j += 1;
-		if (j < code.length && code[j] === ",") to = j + 1;
-	}
-	ms.remove(from, to);
-};
-const removeEntireImport = (ms, code, decl) => {
-	const range = getRange(decl);
-	if (!range) return;
-	let [from, to] = range;
-	while (to < code.length && /[ \t]/.test(code[to])) to += 1;
-	if (code[to] === "\r" && code[to + 1] === "\n") to += 2;
-	else if (code[to] === "\n") to += 1;
-	ms.remove(from, to);
-};
-const fixIconSelfClosingSpacing = (outputCode, iconLocalName) => {
-	const re = new RegExp(`<${iconLocalName}([^>]*?)/>`, "g");
-	return outputCode.replace(re, (_match, attrs) => {
-		return `<${iconLocalName}${attrs.replace(/\s+$/g, "")} />`;
-	});
-};
-const transformModule = (code, id, register, sources = DEFAULT_ICON_SOURCES, options = {}) => {
-	const { sourceMap = false } = options;
-	const parsed = parseAst(code, id);
-	if (parsed.errors.length > 0) throw new Error(parsed.errors[0]?.message ?? `Failed to parse: ${id}`);
-	const { program } = parsed;
-	const localNameToImport = collectIconImports(program, sources);
-	if (localNameToImport.size === 0) return {
-		code,
-		map: null,
-		anyReplacements: false
-	};
-	const { hasIconImport, iconLocalName } = findExistingIconImport(program);
-	const ms = new MagicString(code);
-	const usedLocalNames = /* @__PURE__ */ new Set();
-	let anyReplacements = false;
-	new Visitor({
-		JSXOpeningElement(node) {
-			const name = node.name;
-			if (name?.type !== "JSXIdentifier") return;
-			const local = name.name;
-			if (!local || local === iconLocalName) return;
-			const meta = localNameToImport.get(local);
-			if (!meta) return;
-			let iconPack = meta.pack;
-			let iconExport = meta.exportName;
-			let usedLocal = local;
-			const attrs = node.attributes ?? [];
-			let hasIconId = false;
-			let iconAttr;
-			for (const a of attrs) {
-				if (a.type !== "JSXAttribute") continue;
-				const attrName = a.name;
-				if (attrName?.type === "JSXIdentifier" && attrName.name === "iconId") hasIconId = true;
-				if (attrName?.type === "JSXIdentifier" && attrName.name === "icon") iconAttr = a;
-			}
-			if (meta.pack === "@fortawesome/react-fontawesome" && meta.exportName === "FontAwesomeIcon" && iconAttr) {
-				const value = iconAttr.value;
-				if (value?.type === "JSXExpressionContainer") {
-					const expr = value.expression;
-					if (expr?.type === "Identifier") {
-						const iconLocal = expr.name;
-						if (iconLocal) {
-							const iconMeta = localNameToImport.get(iconLocal);
-							if (iconMeta) {
-								iconPack = iconMeta.pack;
-								iconExport = iconMeta.exportName;
-								usedLocal = iconLocal;
-								const iconAttrRange = getRange(iconAttr);
-								if (iconAttrRange) {
-									let [from, to] = iconAttrRange;
-									while (to < code.length && /\s/.test(code[to])) to += 1;
-									ms.remove(from, to);
-								}
-							}
-						}
-					}
-				}
-			}
-			const nameRange = getRange(name);
-			if (nameRange) ms.overwrite(nameRange[0], nameRange[1], iconLocalName);
-			if (!hasIconId) {
-				const idValue = computeIconId(iconPack, iconExport);
-				const insertPos = nameRange?.[1];
-				if (typeof insertPos === "number") ms.appendLeft(insertPos, ` iconId="${idValue}"`);
-			}
-			usedLocalNames.add(local);
-			if (usedLocal !== local) usedLocalNames.add(usedLocal);
-			anyReplacements = true;
-			register(iconPack, iconExport);
-		},
-		JSXClosingElement(node) {
-			const name = node.name;
-			if (name?.type !== "JSXIdentifier") return;
-			const local = name.name;
-			if (!local || local === iconLocalName) return;
-			if (!localNameToImport.get(local)) return;
-			const nameRange = getRange(name);
-			if (nameRange) ms.overwrite(nameRange[0], nameRange[1], iconLocalName);
-		}
-	}).visit(program);
-	if (!anyReplacements) return {
-		code,
-		map: null,
-		anyReplacements: false
-	};
-	const declToAllSpecs = /* @__PURE__ */ new Map();
-	const declToUsedSpecs = /* @__PURE__ */ new Map();
-	for (const { decl, spec } of localNameToImport.values()) {
-		const declNode = decl;
-		const specNode = spec;
-		const all = declToAllSpecs.get(declNode) ?? [];
-		if (all.length === 0) {
-			const specifiers = declNode.specifiers ?? [];
-			for (const oneSpec of specifiers) if (oneSpec.type === "ImportSpecifier" || oneSpec.type === "ImportDefaultSpecifier") all.push(oneSpec);
-			declToAllSpecs.set(declNode, all);
-		}
-		const localName = specNode.local;
-		if (!localName?.name || !usedLocalNames.has(localName.name)) continue;
-		const used = declToUsedSpecs.get(declNode) ?? [];
-		used.push(specNode);
-		declToUsedSpecs.set(declNode, used);
-	}
-	for (const [declNode, usedSpecs] of declToUsedSpecs.entries()) {
-		const allSpecs = declToAllSpecs.get(declNode) ?? [];
-		if (allSpecs.length > 0 && usedSpecs.length >= allSpecs.length) {
-			removeEntireImport(ms, code, declNode);
-			continue;
-		}
-		const byStartDesc = [...usedSpecs].sort((a, b) => {
-			const aRange = getRange(a);
-			const bRange = getRange(b);
-			if (!aRange || !bRange) return 0;
-			return bRange[0] - aRange[0];
-		});
-		for (const usedSpec of byStartDesc) removeImportSpecifier(ms, code, usedSpec);
-	}
-	if (!hasIconImport) ms.prepend(`import { ${iconLocalName} } from "${ICON_SOURCE}";\n`);
-	const transformedCode = ms.toString();
-	return {
-		code: transformedCode.includes(`<${iconLocalName}`) ? fixIconSelfClosingSpacing(transformedCode, iconLocalName) : transformedCode,
-		map: sourceMap ? (() => {
-			const rawMap = ms.generateMap({
-				source: id,
-				includeContent: true,
-				hires: true
-			});
-			return {
-				...rawMap,
-				sourcesContent: rawMap.sourcesContent?.map((sourceContent) => sourceContent ?? "")
-			};
-		})() : null,
-		anyReplacements
-	};
-};
-const PRESENTATION_ATTRS = new Set([
-	"fill",
-	"stroke",
-	"stroke-width",
-	"stroke-linecap",
-	"stroke-linejoin",
-	"stroke-miterlimit",
-	"stroke-dasharray",
-	"stroke-dashoffset",
-	"stroke-opacity",
-	"fill-rule",
-	"fill-opacity",
-	"color",
-	"opacity",
-	"shape-rendering",
-	"vector-effect"
-]);
-const ATTR_RE = /([a-zA-Z_:.-]+)\s*=\s*"([^"]*)"/g;
-const toKebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
-const resolveSpecificImportPath = (pack, exportName) => {
-	if (/^@mui\/icons-material(?:\/.*)?$/.test(pack)) {
-		if (pack.split("/").length > 2) return pack;
-		return `${pack}/${exportName}`;
-	}
-	if (/^@radix-ui\/react-icons$/.test(pack)) return `${pack}/${exportName}`;
-	if (/^@heroicons\/react\/(?:\d{2})\/(?:outline|solid)$/.test(pack)) return `${pack}/${exportName}`;
-	if (/^@fortawesome\/[\w-]+-svg-icons$/.test(pack)) return `${pack}/${exportName}`;
-	if (/^lucide-react$/.test(pack)) return `${pack}/icons/${toKebab(exportName)}`;
-	if (/^@phosphor-icons\/react$/.test(pack)) return `${pack}/dist/ssr/${exportName}.es.js`;
-	if (/^phosphor-react$/.test(pack)) return `${pack}/dist/icons/${exportName}.esm.js`;
-	if (/^@tabler\/icons-react$/.test(pack)) return `${pack}/dist/esm/icons/${exportName}.mjs`;
-	if (/^react-feather$/.test(pack)) return `${pack}/dist/icons/${toKebab(exportName)}`;
-	if (/^react-bootstrap-icons$/.test(pack)) return `${pack}/dist/icons/${toKebab(exportName)}`;
-	if (/^@carbon\/icons-react$/.test(pack)) return `${pack}/lib/${exportName}.js`;
-	return null;
-};
-const renderOneIcon = async (pack, exportName) => {
-	let mod;
-	const specificPath = resolveSpecificImportPath(pack, exportName);
-	if (specificPath) try {
-		mod = await import(
-			/* @vite-ignore */
-			specificPath
-);
-		if (mod && "default" in mod && Object.keys(mod).length === 1) mod[exportName] = mod.default;
-	} catch {
-		mod = await import(
-			/* @vite-ignore */
-			pack
-);
-	}
-	else mod = await import(
-		/* @vite-ignore */
-		pack
-);
-	const modRecord = mod;
-	const Comp = modRecord[exportName] ?? modRecord.default;
-	if (!Comp) throw new Error(`Icon export not found: ${pack} -> ${exportName}`);
-	const id = computeIconId(pack, exportName);
-	if (pack.includes("fortawesome")) {
-		const [width, height, , , pathData] = Comp.icon;
-		return {
-			id,
-			symbol: `<symbol id="${id}" viewBox="${`0 0 ${width} ${height}`}">${(Array.isArray(pathData) ? pathData : [pathData]).map((d) => `<path d="${d}" />`).join("")}</symbol>`
-		};
-	}
-	const html = renderToStaticMarkup(createElement(Comp, {}));
-	const viewBox = html.match(/viewBox="([^"]+)"/i)?.[1] ?? "0 0 24 24";
-	const svgAttrsRaw = html.match(/^<svg\b([^>]*)>/i)?.[1] ?? "";
-	const attrs = [];
-	for (const [, k, v] of svgAttrsRaw.matchAll(ATTR_RE)) {
-		const key = k.toLowerCase();
-		if (PRESENTATION_ATTRS.has(key)) attrs.push(`${key}="${v}"`);
-	}
-	const inner = html.replace(/^<svg[^>]*>/i, "").replace(/<\/svg>\s*$/i, "").replace(/<svg[^>]*>/gi, "").replace(/<\/svg>/gi, "");
-	return {
-		id,
-		symbol: `<symbol id="${id}" viewBox="${viewBox}"${attrs.length ? ` ${attrs.join(" ")}` : ""}>${inner}</symbol>`
-	};
-};
-const buildSprite = async (icons) => {
-	return `<svg xmlns="http://www.w3.org/2000/svg"><defs>${(await Promise.all(Array.from(icons).map(({ pack, exportName }) => renderOneIcon(pack, exportName)))).map((r) => r.symbol).join("")}</defs></svg>`;
-};
-const createCollector = () => {
-	const set = /* @__PURE__ */ new Map();
-	return {
-		add(pack, exportName) {
-			set.set(`${pack}:${exportName}`, {
-				pack,
-				exportName
-			});
-		},
-		toList() {
-			return Array.from(set.values());
-		},
-		clear() {
-			set.clear();
-		}
-	};
-};
-//#endregion
-export { transformModule as i, buildSprite as n, createCollector as r, DEFAULT_ICON_SOURCES as t };