react-icons-sprite 0.9.2-rc.1 → 1.0.0-rc.2

package/dist/build-sprite-j9zt_17z.mjs

@@ -0,0 +1,147 @@
+import { r as resolveIconImport, t as computeIconId } from "./compute-icon-id-B590yK7l.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+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 parsePackageSpecifier = (specifier) => {
+	if (specifier.startsWith(".") || path.isAbsolute(specifier)) return null;
+	const parts = specifier.split("/");
+	const packageName = specifier.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+	const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+	return {
+		packageName,
+		subpath: rest ? `./${rest}` : "."
+	};
+};
+const findPackageRoot = (packageName, baseDir) => {
+	let current = path.resolve(baseDir);
+	while (true) {
+		const candidate = path.join(current, "node_modules", packageName);
+		if (existsSync(path.join(candidate, "package.json"))) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+};
+const pickExportTarget = (value) => {
+	if (typeof value === "string") return value;
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	return pickExportTarget(record.import) ?? pickExportTarget(record.default) ?? pickExportTarget(record.module) ?? pickExportTarget(record.require);
+};
+const resolveExportTarget = (exportsField, subpath) => {
+	if (typeof exportsField === "string" || Array.isArray(exportsField)) return subpath === "." ? pickExportTarget(exportsField) : null;
+	if (!exportsField || typeof exportsField !== "object") return null;
+	const exportsRecord = exportsField;
+	const exact = pickExportTarget(exportsRecord[subpath]);
+	if (exact) return exact;
+	for (const [key, value] of Object.entries(exportsRecord)) {
+		if (!key.includes("*")) continue;
+		const [prefix, suffix] = key.split("*");
+		if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) continue;
+		const matched = subpath.slice(prefix.length, subpath.length - suffix.length);
+		const target = pickExportTarget(value);
+		if (target) return target.replaceAll("*", matched);
+	}
+	return null;
+};
+const fileExists = (filePath) => existsSync(filePath);
+const resolveFileCandidate = (filePath) => {
+	return [
+		filePath,
+		`${filePath}.mjs`,
+		`${filePath}.js`,
+		path.join(filePath, "index.mjs"),
+		path.join(filePath, "index.js")
+	].find(fileExists) ?? null;
+};
+const resolveFromBaseDir = (specifier, baseDir) => {
+	const parsed = parsePackageSpecifier(specifier);
+	if (!parsed) return null;
+	const packageRoot = findPackageRoot(parsed.packageName, baseDir);
+	if (!packageRoot) return null;
+	const packageJson = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+	const exportTarget = resolveExportTarget(packageJson.exports, parsed.subpath);
+	if (exportTarget) return resolveFileCandidate(path.join(packageRoot, exportTarget)) ?? null;
+	if (parsed.subpath === ".") {
+		const entry = packageJson.module ?? packageJson.main;
+		if (entry) return resolveFileCandidate(path.join(packageRoot, entry));
+	}
+	return resolveFileCandidate(path.join(packageRoot, parsed.subpath));
+};
+const resolveImportSpecifier = (specifier, options) => {
+	if (!options.baseDir) return specifier;
+	const resolved = resolveFromBaseDir(specifier, options.baseDir);
+	return resolved ? pathToFileURL(resolved).href : specifier;
+};
+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, options = {}) => {
+	const iconComponent = pickExport(await import(resolveImportSpecifier(resolveIconImport(pack, exportName), options)), 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, options = {}) => {
+	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, { baseDir: options.baseDir });
+		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-C6kn7NXC.mjs → collector-YV25X1xI.mjs}

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

package/dist/{compute-icon-id-C96eIC66.mjs → compute-icon-id-B590yK7l.mjs}

@@ -43,12 +43,26 @@ const DEFAULT_ICON_SOURCES = [
 	/^@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 phosphorIconPathName = (name) => name.endsWith("Icon") ? name.slice(0, -4) : name;
+const exactResolvers = {
+	"lucide-react": (pack, name) => `${pack}/dist/esm/icons/${kebabCase(name)}.mjs`,
+	"@radix-ui/react-icons": (pack) => `${pack}/dist/react-icons.esm.js`,
+	"@tabler/icons-react": (pack, name) => `${pack}/dist/esm/icons/${name}.mjs`,
+	"@phosphor-icons/react": (pack, name) => `${pack}/dist/ssr/${phosphorIconPathName(name)}`,
+	"phosphor-react": (pack, name) => `${pack}/dist/icons/${name}.esm.js`,
+	"react-bootstrap-icons": (pack, name) => `${pack}/dist/icons/${kebabCase(name)}.js`,
+	"react-feather": (pack, name) => `${pack}/dist/icons/${kebabCase(name)}.js`,
+	"grommet-icons": (pack, name) => `${pack}/icons/${name}.js`,
+	"devicons-react": (pack, name) => `${pack}/icons/${name}`,
+	"@carbon/icons-react": (pack, name) => `${pack}/es/${name}.js`
 };
 const resolveIconImport = (pack, exportName) => {
-	return resolvers[pack]?.(pack, exportName) ?? pack;
+	const exactResolver = exactResolvers[pack];
+	if (exactResolver) return exactResolver(pack, exportName);
+	if (/^@mui\/icons-material(?:\/.*)?$/.test(pack)) return pack.split("/").length > 2 ? pack : `${pack}/${exportName}`;
+	if (/^@heroicons\/react\/(?:\d{2})\/(?:outline|solid)$/.test(pack)) return `${pack}/${exportName}`;
+	if (/^@fortawesome\/[\w-]+-svg-icons$/.test(pack)) return `${pack}/${exportName}`;
+	return pack;
 };
 //#endregion
 //#region src/utils/compute-icon-id.ts

package/dist/transform-module-zJo6_2rz.mjs

@@ -0,0 +1,477 @@
+import { n as DEFAULT_ICON_SOURCES, t as computeIconId } from "./compute-icon-id-B590yK7l.mjs";
+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;
+};
+const editStart = (edit) => {
+	return edit.type === "insert" ? edit.pos : edit.from;
+};
+const applyEditsToString = (code, edits) => {
+	if (!edits.length) return code;
+	const orderedEdits = [...edits].sort((left, right) => {
+		const startDelta = editStart(left) - editStart(right);
+		if (startDelta !== 0) return startDelta;
+		if (left.type === "insert" && right.type !== "insert") return 1;
+		if (left.type !== "insert" && right.type === "insert") return -1;
+		return 0;
+	});
+	let result = "";
+	let cursor = 0;
+	for (const edit of orderedEdits) {
+		if (edit.type === "insert") {
+			if (edit.pos <= cursor) {
+				result += edit.value;
+				continue;
+			}
+			result += code.slice(cursor, edit.pos) + edit.value;
+			cursor = edit.pos;
+			continue;
+		}
+		result += code.slice(cursor, edit.from);
+		if (edit.type === "replace") result += edit.value;
+		cursor = edit.to;
+	}
+	return result + code.slice(cursor);
+};
+//#endregion
+//#region src/transform/edit-builder.ts
+const buildEdits = (usages, componentName, usedSymbols, register) => {
+	const edits = [];
+	const iconIdCache = /* @__PURE__ */ new Map();
+	for (const usage of usages) {
+		edits.push({
+			type: "replace",
+			from: usage.range[0],
+			to: usage.range[1],
+			value: componentName
+		});
+		if (usage.kind === "opening") {
+			if (!usage.hasIconId) {
+				const key = `${usage.pack}:${usage.exportName}`;
+				let iconId = iconIdCache.get(key);
+				if (!iconId) {
+					iconId = computeIconId(usage.pack, usage.exportName);
+					iconIdCache.set(key, iconId);
+				}
+				edits.push({
+					type: "insert",
+					pos: usage.range[1],
+					value: ` iconId="${iconId}"`
+				});
+			}
+			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/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 sourceMatches = (source, pack) => {
+	source.lastIndex = 0;
+	return source.test(pack);
+};
+const IMPORT_RE = /import\s+([^;]+?)\s+from\s+(['"])([^'"]+)\2\s*;?/g;
+const trimRange = (value, offset) => {
+	let start = 0;
+	let end = value.length;
+	while (start < end && /\s/.test(value[start])) start += 1;
+	while (end > start && /\s/.test(value[end - 1])) end -= 1;
+	return start === end ? null : [offset + start, offset + end];
+};
+const parseNamedSpecifiers = (specifier, specifierOffset, imports) => {
+	const start = specifier.indexOf("{");
+	const end = specifier.lastIndexOf("}");
+	if (start === -1 || end === -1 || end <= start) return;
+	let segmentStart = start + 1;
+	for (let index = start + 1; index <= end; index += 1) {
+		if (index !== end && specifier[index] !== ",") continue;
+		const range = trimRange(specifier.slice(segmentStart, index), specifierOffset + segmentStart);
+		segmentStart = index + 1;
+		if (!range) continue;
+		const text = specifier.slice(range[0] - specifierOffset, range[1] - specifierOffset);
+		if (text.startsWith("type ")) continue;
+		const aliasMatch = /^(.*?)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(text);
+		const exportName = aliasMatch ? aliasMatch[1].trim() : text.trim();
+		const local = aliasMatch ? aliasMatch[2] : exportName;
+		if (exportName && local) imports.push({
+			local,
+			exportName,
+			range
+		});
+	}
+};
+const countImportSpecifiers = (specifier) => {
+	let count = 0;
+	const braceStart = specifier.indexOf("{");
+	if ((braceStart === -1 ? specifier : specifier.slice(0, braceStart)).replace(/,$/, "").trim()) count += 1;
+	const braceEnd = specifier.lastIndexOf("}");
+	if (braceStart !== -1 && braceEnd > braceStart) {
+		const named = specifier.slice(braceStart + 1, braceEnd);
+		for (const segment of named.split(",")) if (segment.trim()) count += 1;
+	}
+	return count;
+};
+const scanImportsDetailed = (code, sources) => {
+	const imports = [];
+	IMPORT_RE.lastIndex = 0;
+	for (const match of code.matchAll(IMPORT_RE)) {
+		const [statement, specifier, , pack] = match;
+		if (!sources.some((source) => sourceMatches(source, pack))) continue;
+		if (specifier.trim().startsWith("type ")) continue;
+		const matchStart = match.index;
+		const specifierOffset = matchStart + statement.indexOf(specifier);
+		const specifiers = [];
+		const braceStart = specifier.indexOf("{");
+		const defaultRange = trimRange((braceStart === -1 ? specifier : specifier.slice(0, braceStart)).replace(/,$/, ""), specifierOffset);
+		if (defaultRange && !specifier.slice(defaultRange[0] - specifierOffset, defaultRange[1] - specifierOffset).startsWith("type ")) {
+			const local = specifier.slice(defaultRange[0] - specifierOffset, defaultRange[1] - specifierOffset);
+			if (local && /^[A-Za-z_$][\w$]*$/.test(local)) specifiers.push({
+				local,
+				exportName: "default",
+				range: defaultRange
+			});
+		}
+		parseNamedSpecifiers(specifier, specifierOffset, specifiers);
+		if (specifiers.length) imports.push({
+			pack,
+			declarationRange: [matchStart, matchStart + statement.length],
+			specifiers,
+			specifierCount: countImportSpecifiers(specifier)
+		});
+	}
+	return imports;
+};
+const buildScannedSymbolTable = (imports) => {
+	const table = /* @__PURE__ */ new Map();
+	for (const item of imports) for (const specifier of item.specifiers) table.set(specifier.local, {
+		pack: item.pack,
+		exportName: specifier.exportName
+	});
+	return table;
+};
+const scanSpriteIconImport = (code) => {
+	IMPORT_RE.lastIndex = 0;
+	for (const match of code.matchAll(IMPORT_RE)) {
+		const [, specifier, , source] = match;
+		if (source !== "react-icons-sprite") continue;
+		const specifiers = [];
+		parseNamedSpecifiers(specifier, match.index + match[0].indexOf(specifier), specifiers);
+		for (const item of specifiers) if (item.exportName === "ReactIconsSpriteIcon") return {
+			hasImport: true,
+			localName: item.local
+		};
+	}
+	return {
+		hasImport: false,
+		localName: ICON_COMPONENT_NAME
+	};
+};
+const escapeRegExp = (value) => {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+const isIdentifierStart = (char) => {
+	return char !== void 0 && (char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "_" || char === "$");
+};
+const isIdentifierPart = (char) => {
+	return char !== void 0 && (isIdentifierStart(char) || char >= "0" && char <= "9");
+};
+const isWhitespace = (char) => {
+	return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+};
+const scanJsxIconUsages = (code, symbols) => {
+	if (!symbols.size) return [];
+	const usages = [];
+	for (let index = 0; index < code.length; index += 1) {
+		if (code.charCodeAt(index) !== 60) continue;
+		let cursor = index + 1;
+		while (isWhitespace(code[cursor])) cursor += 1;
+		const closing = code[cursor] === "/";
+		if (closing) {
+			cursor += 1;
+			while (isWhitespace(code[cursor])) cursor += 1;
+		}
+		if (!isIdentifierStart(code[cursor])) continue;
+		const localStart = cursor;
+		cursor += 1;
+		while (isIdentifierPart(code[cursor])) cursor += 1;
+		const local = code.slice(localStart, cursor);
+		const symbol = symbols.get(local);
+		if (!symbol) continue;
+		const kind = closing ? "closing" : "opening";
+		let hasIconId = false;
+		if (!closing) {
+			const tagEnd = findJsxOpeningTagEnd(code, cursor);
+			hasIconId = tagEnd !== -1 && hasIconIdAttribute(code, cursor, tagEnd);
+		}
+		usages.push({
+			local,
+			range: [localStart, cursor],
+			pack: symbol.pack,
+			exportName: symbol.exportName,
+			kind,
+			hasIconId
+		});
+	}
+	return usages;
+};
+const hasIconIdAttribute = (code, start, end) => {
+	for (let index = start; index < end; index += 1) {
+		if (code.charCodeAt(index) !== 105 || code.charCodeAt(index + 1) !== 99 || code.charCodeAt(index + 2) !== 111 || code.charCodeAt(index + 3) !== 110 || code.charCodeAt(index + 4) !== 73 || code.charCodeAt(index + 5) !== 100) continue;
+		if (isIdentifierPart(code[index - 1]) || isIdentifierPart(code[index + 6])) continue;
+		let cursor = index + 6;
+		while (isWhitespace(code[cursor])) cursor += 1;
+		if (code[cursor] === "=") return true;
+	}
+	return false;
+};
+const findJsxOpeningTagEnd = (code, start) => {
+	let quote = null;
+	let braceDepth = 0;
+	for (let index = start; index < code.length; index += 1) {
+		const char = code[index];
+		if (quote) {
+			if (char === quote && code[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") {
+			braceDepth += 1;
+			continue;
+		}
+		if (char === "}") {
+			braceDepth -= 1;
+			continue;
+		}
+		if (char === ">" && braceDepth === 0) return index;
+	}
+	return -1;
+};
+const scanFontAwesomeComponents = (code) => {
+	const locals = /* @__PURE__ */ new Set();
+	IMPORT_RE.lastIndex = 0;
+	for (const match of code.matchAll(IMPORT_RE)) {
+		const [, specifier, , source] = match;
+		if (source !== FONTAWESOME_REACT_PACK) continue;
+		const specifiers = [];
+		parseNamedSpecifiers(specifier, match.index + match[0].indexOf(specifier), specifiers);
+		for (const item of specifiers) if (item.exportName === "FontAwesomeIcon") locals.add(item.local);
+	}
+	return locals;
+};
+const scanFontAwesomeUsages = (code, symbols, componentLocals) => {
+	if (!componentLocals.size) return [];
+	const names = [...componentLocals].map(escapeRegExp).join("|");
+	const tagRe = new RegExp(`<\\s*(${names})\\b`, "g");
+	const usages = [];
+	for (const match of code.matchAll(tagRe)) {
+		const componentLocal = match[1];
+		const componentStart = match.index + match[0].lastIndexOf(componentLocal);
+		const tagEnd = findJsxOpeningTagEnd(code, componentStart + componentLocal.length);
+		if (tagEnd === -1) continue;
+		const attributes = code.slice(componentStart + componentLocal.length, tagEnd);
+		const iconMatch = /\sicon\s*=\s*\{\s*([A-Za-z_$][\w$]*)\s*\}/.exec(attributes);
+		if (!iconMatch || iconMatch.index === void 0) continue;
+		const symbol = symbols.get(iconMatch[1]);
+		if (!symbol || !isFontAwesomeIconPack(symbol.pack)) continue;
+		const attributeStart = componentStart + componentLocal.length + iconMatch.index;
+		usages.push({
+			componentLocal,
+			componentRange: [componentStart, componentStart + componentLocal.length],
+			iconAttributeRange: [attributeStart, attributeStart + iconMatch[0].length],
+			hasIconId: /\biconId\s*=/.test(attributes),
+			iconLocal: iconMatch[1],
+			pack: symbol.pack,
+			exportName: symbol.exportName
+		});
+	}
+	return usages;
+};
+const cleanupScannedImports = (code, imports, usedLocals) => {
+	const edits = [];
+	for (const item of imports) {
+		const usedSpecifiers = item.specifiers.filter((specifier) => usedLocals.has(specifier.local));
+		if (!usedSpecifiers.length) continue;
+		if (usedSpecifiers.length === item.specifiers.length && item.specifierCount === item.specifiers.length) {
+			edits.push({
+				type: "remove",
+				from: item.declarationRange[0],
+				to: extendToLineEnd(code, item.declarationRange[1])
+			});
+			continue;
+		}
+		for (const specifier of usedSpecifiers) {
+			const [from, to] = specifierRemovalRange(code, specifier.range);
+			edits.push({
+				type: "remove",
+				from,
+				to
+			});
+		}
+	}
+	return edits;
+};
+const cleanupScannedFontAwesomeComponentImports = (code, usedLocals) => {
+	const edits = [];
+	IMPORT_RE.lastIndex = 0;
+	for (const match of code.matchAll(IMPORT_RE)) {
+		const [statement, specifier, , source] = match;
+		if (source !== FONTAWESOME_REACT_PACK) continue;
+		const specifiers = [];
+		parseNamedSpecifiers(specifier, match.index + statement.indexOf(specifier), specifiers);
+		const removableSpecifiers = specifiers.filter((item) => item.exportName === "FontAwesomeIcon" && usedLocals.has(item.local));
+		if (!removableSpecifiers.length) continue;
+		if (removableSpecifiers.length === specifiers.length) {
+			edits.push({
+				type: "remove",
+				from: match.index,
+				to: extendToLineEnd(code, match.index + statement.length)
+			});
+			continue;
+		}
+		for (const specifier of removableSpecifiers) {
+			const [from, to] = specifierRemovalRange(code, specifier.range);
+			edits.push({
+				type: "remove",
+				from,
+				to
+			});
+		}
+	}
+	return edits;
+};
+const extendToLineEnd = (code, end) => {
+	let to = end;
+	while (to < code.length && /[ \t]/.test(code[to])) to += 1;
+	if (code[to] === "\r" && code[to + 1] === "\n") return to + 2;
+	if (code[to] === "\n") return to + 1;
+	return to;
+};
+const specifierRemovalRange = (code, [start, end]) => {
+	let from = start;
+	let to = end;
+	let before = start - 1;
+	while (before >= 0 && /\s/.test(code[before])) before -= 1;
+	if (before >= 0 && code[before] === ",") {
+		from = before;
+		return [from, to];
+	}
+	let after = end;
+	while (after < code.length && /\s/.test(code[after])) after += 1;
+	if (after < code.length && code[after] === ",") to = consumeTrailingWhitespace(code, after + 1);
+	return [from, to];
+};
+const consumeTrailingWhitespace = (code, start) => {
+	let to = start;
+	while (to < code.length && /\s/.test(code[to])) to += 1;
+	return to;
+};
+const transformModule = (code, id, register, sources = DEFAULT_ICON_SOURCES, options = {}) => {
+	const { sourceMap = false } = options;
+	if (!fastFilter(code)) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const scannedImports = scanImportsDetailed(code, sources);
+	if (!scannedImports.length) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const hasPotentialFontAwesomeUsage = code.includes(FONTAWESOME_REACT_PACK) && scannedImports.some((item) => isFontAwesomeIconPack(item.pack));
+	const table = buildScannedSymbolTable(scannedImports);
+	if (!table.size) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const spriteIconImport = code.includes("react-icons-sprite") ? scanSpriteIconImport(code) : {
+		hasImport: false,
+		localName: ICON_COMPONENT_NAME
+	};
+	const usages = scanJsxIconUsages(code, table);
+	const fontAwesomeUsages = hasPotentialFontAwesomeUsage ? scanFontAwesomeUsages(code, table, scanFontAwesomeComponents(code)) : [];
+	if (!usages.length && !fontAwesomeUsages.length) return {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	const used = /* @__PURE__ */ new Set();
+	const usedFontAwesomeComponents = /* @__PURE__ */ new Set();
+	const edits = buildEdits(usages, spriteIconImport.localName, 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: spriteIconImport.localName
+		});
+		if (!usage.hasIconId) edits.push({
+			type: "insert",
+			pos: usage.componentRange[1],
+			value: ` iconId="${computeIconId(usage.pack, usage.exportName)}"`
+		});
+		edits.push({
+			type: "remove",
+			from: usage.iconAttributeRange[0],
+			to: consumeTrailingWhitespace(code, usage.iconAttributeRange[1])
+		});
+		used.add(usage.iconLocal);
+		usedFontAwesomeComponents.add(usage.componentLocal);
+		const key = `${usage.pack}:${usage.exportName}`;
+		if (!registeredFontAwesomeIcons.has(key)) {
+			registeredFontAwesomeIcons.add(key);
+			register(usage.pack, usage.exportName);
+		}
+	}
+	const cleanupEdits = cleanupScannedImports(code, scannedImports, used);
+	const cleanupFontAwesomeEdits = usedFontAwesomeComponents.size ? cleanupScannedFontAwesomeComponentImports(code, usedFontAwesomeComponents) : [];
+	const allEdits = [
+		...edits,
+		...cleanupEdits,
+		...cleanupFontAwesomeEdits
+	];
+	const importPrefix = `import { ${ICON_COMPONENT_NAME} } from "${ICON_SOURCE}";\n`;
+	if (!sourceMap) return {
+		code: `${spriteIconImport.hasImport ? "" : importPrefix}${applyEditsToString(code, allEdits)}`,
+		map: null,
+		anyReplacements: true
+	};
+	const magicString = applyEdits(code, allEdits);
+	if (!spriteIconImport.hasImport) magicString.prepend(importPrefix);
+	return {
+		code: magicString.toString(),
+		map: sourceMap ? magicString.generateMap({
+			source: id,
+			hires: true
+		}) : null,
+		anyReplacements: true
+	};
+};
+//#endregion
+export { transformModule as t };

package/dist/vite/plugin.mjs

@@ -1,12 +1,13 @@
 import { REACT_ICONS_SPRITE_URL_PLACEHOLDER } from "../index.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 { i as createCollector, n as DEFAULT_ICON_SOURCES } from "../compute-icon-id-B590yK7l.mjs";
+import { t as buildSprite } from "../build-sprite-j9zt_17z.mjs";
+import { t as transformModule } from "../transform-module-zJo6_2rz.mjs";
 import { createHash } from "node:crypto";
 //#region src/vite/plugin.ts
 const reactIconsSprite = (options = {}) => {
 	const { fileName } = options;
 	const collector = createCollector();
+	let root = process.cwd();
 	return {
 		name: "vite-plugin-react-icons-sprite",
 		enforce: "pre",
@@ -14,6 +15,9 @@ const reactIconsSprite = (options = {}) => {
 		buildStart() {
 			collector.clear();
 		},
+		configResolved(config) {
+			root = config.root;
+		},
 		transform(code, id) {
 			const cleanId = id.split("?", 1)[0];
 			if (!/\.(mjs|cjs|js|jsx|ts|tsx)$/.test(cleanId)) return null;
@@ -32,7 +36,7 @@ const reactIconsSprite = (options = {}) => {
 			}
 		},
 		async generateBundle(_options, bundle) {
-			const spriteXml = await buildSprite(collector.toList());
+			const spriteXml = await buildSprite(collector.toList(), { baseDir: root });
 			const generatedHash = createHash("sha256").update(spriteXml).digest("hex").slice(0, 8);
 			const emitFileOptions = {
 				type: "asset",

package/dist/webpack/loader.mjs

@@ -1,5 +1,5 @@
-import { t as transformModule } from "../transform-module-DzmqobWK.mjs";
-import { t as collector } from "../collector-C6kn7NXC.mjs";
+import { t as transformModule } from "../transform-module-zJo6_2rz.mjs";
+import { t as collector } from "../collector-YV25X1xI.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 { t as buildSprite } from "../build-sprite-BFhBc3Ev.mjs";
-import { t as collector } from "../collector-C6kn7NXC.mjs";
+import { t as buildSprite } from "../build-sprite-j9zt_17z.mjs";
+import { t as collector } from "../collector-YV25X1xI.mjs";
 import { createHash } from "node:crypto";
 //#region src/webpack/plugin.ts
 var ReactIconsSpriteWebpackPlugin = class {
@@ -18,7 +18,7 @@ var ReactIconsSpriteWebpackPlugin = class {
 				name: pluginName,
 				stage
 			}, async () => {
-				const spriteXml = await buildSprite(collector.toList());
+				const spriteXml = await buildSprite(collector.toList(), { baseDir: compiler.context });
 				const generatedHash = createHash("sha256").update(spriteXml).digest("hex").slice(0, 8);
 				const name = this.fileName ?? `react-icons-sprite-${generatedHash}.svg`;
 				const RawSource = compiler.webpack?.sources?.RawSource;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "react-icons-sprite",
-  "version": "0.9.2-rc.1",
+  "version": "1.0.0-rc.2",
   "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>",
@@ -65,21 +65,20 @@
     "react-dom": ">= 16"
   },
   "dependencies": {
-    "magic-string": "0.30.21",
-    "oxc-parser": "0.119.0"
+    "magic-string": "0.30.21"
   },
   "devDependencies": {
-    "@carbon/icons-react": "11.76.0",
-    "@types/node": "25.5.0",
+    "@carbon/icons-react": "11.81.0",
+    "@types/node": "25.9.1",
     "@types/react-dom": "19.2.3",
-    "@typescript/native-preview": "7.0.0-dev.20260311.1",
-    "react": "19.2.4",
-    "react-dom": "19.2.4",
-    "tsdown": "0.21.2",
-    "typescript": "5.9.3",
-    "vite": "8.0.0",
-    "vitest": "4.1.0",
-    "webpack": "5.105.4"
+    "@typescript/native-preview": "7.0.0-dev.20260521.1",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "tsdown": "0.22.0",
+    "typescript": "6.0.3",
+    "vite": "8.0.14",
+    "vitest": "4.1.7",
+    "webpack": "5.107.1"
   },
   "keywords": [
     "vite",

package/dist/build-sprite-BFhBc3Ev.mjs

@@ -1,73 +0,0 @@
-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/transform-module-DzmqobWK.mjs

@@ -1,290 +0,0 @@
-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 };