react-icons-sprite 1.3.0 → 1.4.0-rc1

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { ReactIconsSpriteIcon } from "./icon.mjs";
 //#region src/index.d.ts
-declare const REACT_ICONS_SPRITE_URL_PLACEHOLDER = "__SPRITE_URL_PLACEHOLDER__";
+export declare const REACT_ICONS_SPRITE_URL_PLACEHOLDER = "__SPRITE_URL_PLACEHOLDER__";
 //#endregion
-export { REACT_ICONS_SPRITE_URL_PLACEHOLDER, ReactIconsSpriteIcon };
+export { ReactIconsSpriteIcon };

package/dist/plugin-options-DYfIgasR.d.mts

@@ -0,0 +1,17 @@
+//#region src/plugin-options.d.ts
+type IconSourceExclusion = RegExp | readonly RegExp[];
+type ReactIconsSpritePluginOptions = {
+  /**
+   * Optional directory inside the bundler output where the sprite asset should be emitted.
+   */
+  outputDir?: string;
+  /**
+   * Icon import sources to leave as inline React components.
+   *
+   * Use this when CSS needs to target elements inside an icon SVG. Those
+   * selectors cannot cross an SVG <use> reference into the generated sprite.
+   */
+  exclude?: IconSourceExclusion;
+};
+//#endregion
+export { ReactIconsSpritePluginOptions as t };

package/dist/transform-module-Cabatwdp.mjs

@@ -0,0 +1,471 @@
+import { n as normalizePackAlias, s as DEFAULT_ICON_SOURCES } from "./compute-icon-id-C42PyoDX.mjs";
+import MagicString from "magic-string";
+import { parseSync, rawTransferSupported, visitorKeys } from "oxc-parser";
+//#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, presorted = false) => {
+	if (!edits.length) return code;
+	const orderedEdits = presorted ? edits : [...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/fast-filter.ts
+const fastFilter = (code) => {
+	if (!code.includes("<")) return false;
+	if (!code.includes("import")) return false;
+	return true;
+};
+//#endregion
+//#region src/transform/parse-module.ts
+const createModuleParser = (preferRawTransfer = true) => {
+	const options = {
+		sourceType: "unambiguous",
+		lang: "tsx",
+		astType: "ts",
+		preserveParens: false,
+		showSemanticErrors: true,
+		experimentalRawTransfer: preferRawTransfer && rawTransferSupported()
+	};
+	return (id, code) => {
+		const result = parseSync(id, code, options);
+		return result.errors.length ? null : result.program;
+	};
+};
+//#endregion
+//#region src/transform/is-referenced.ts
+const isReferenced$1 = (node, parent, grandparent) => {
+	switch (parent.type) {
+		case "MemberExpression": return parent.object === node || parent.computed;
+		case "JSXMemberExpression": return parent.object === node;
+		case "Property": return parent.key === node ? parent.computed : grandparent?.type !== "ObjectPattern";
+		case "MethodDefinition":
+		case "TSAbstractMethodDefinition":
+		case "PropertyDefinition":
+		case "TSAbstractPropertyDefinition":
+		case "AccessorProperty": return parent.key !== node || parent.computed;
+		case "VariableDeclarator": return parent.init === node;
+		case "AssignmentPattern": return parent.right === node;
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "TSDeclareFunction":
+		case "TSEmptyBodyFunctionExpression":
+		case "ArrowFunctionExpression": return parent.body === node;
+		case "ClassDeclaration":
+		case "ClassExpression": return parent.superClass === node;
+		case "ExportSpecifier": return parent.local === node && !(grandparent && "source" in grandparent && grandparent.source);
+		case "TSQualifiedName": return parent.left === node;
+		case "TSEnumMember": return parent.initializer === node;
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier":
+		case "ImportAttribute":
+		case "ObjectPattern":
+		case "ArrayPattern":
+		case "RestElement":
+		case "CatchClause":
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement":
+		case "MetaProperty":
+		case "JSXAttribute": return false;
+		default: return true;
+	}
+};
+//#endregion
+//#region src/transform/analyze-module.ts
+const isReferenced = isReferenced$1;
+const getBinding$1 = (scope, name) => {
+	const cached = scope.resolved[name];
+	if (cached !== void 0) return cached ?? void 0;
+	const binding = scope.bindings[name] ?? (scope.parent && getBinding$1(scope.parent, name));
+	scope.resolved[name] = binding ?? null;
+	return binding;
+};
+const analyzeModule = (ast) => {
+	const imports = [];
+	const elements = [];
+	const names = /* @__PURE__ */ new Set();
+	const bindings = [];
+	const root = {
+		functionScope: true,
+		bindings: Object.create(null),
+		resolved: Object.create(null)
+	};
+	const scopes = [root];
+	const tracked = /* @__PURE__ */ new Set();
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		imports.push({
+			node,
+			scope: root
+		});
+		for (const specifier of node.specifiers) {
+			tracked.add(specifier.local.name);
+			names.add(specifier.local.name);
+			const binding = {
+				identifier: specifier.local,
+				references: []
+			};
+			root.bindings[specifier.local.name] = binding;
+			bindings.push(binding);
+		}
+	}
+	const bind = (node, scope) => {
+		if (!node) return;
+		switch (node.type) {
+			case "Identifier":
+				if (tracked.has(node.name) && scope.bindings[node.name] === void 0) {
+					const binding = {
+						identifier: node,
+						references: []
+					};
+					scope.bindings[node.name] = binding;
+					bindings.push(binding);
+				}
+				return;
+			case "AssignmentPattern":
+				bind(node.left, scope);
+				return;
+			case "RestElement":
+				bind(node.argument, scope);
+				return;
+			case "ObjectPattern":
+				for (const property of node.properties) bind(property.type === "RestElement" ? property.argument : property.value, scope);
+				return;
+			case "ArrayPattern":
+				for (const element of node.elements) bind(element, scope);
+				return;
+			case "TSParameterProperty":
+				bind(node.parameter, scope);
+				return;
+		}
+	};
+	const walk = (node, inherited, parent, grandparent) => {
+		if (node.type === "ImportDeclaration") return;
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") {
+			names.add(node.name);
+			if (tracked.has(node.name) && parent && isReferenced(node, parent, grandparent)) {
+				inherited.references ??= [];
+				inherited.references.push(node);
+			}
+			return;
+		}
+		if (node.type === "JSXElement") {
+			elements.push({
+				node,
+				scope: inherited
+			});
+			const opening = node.openingElement;
+			walk(opening.name, inherited, opening, node);
+			for (const attribute of opening.attributes) if (attribute.type === "JSXSpreadAttribute") walk(attribute.argument, inherited, attribute, opening);
+			else if (attribute.value?.type === "JSXExpressionContainer") walk(attribute.value.expression, inherited, attribute.value, attribute);
+			for (const child of node.children) if (child.type === "JSXElement" || child.type === "JSXFragment") walk(child, inherited, node, parent);
+			else if (child.type === "JSXExpressionContainer" || child.type === "JSXSpreadChild") walk(child.expression, inherited, child, node);
+			return;
+		}
+		if (node.type === "JSXFragment") {
+			for (const child of node.children) if (child.type === "JSXElement" || child.type === "JSXFragment") walk(child, inherited, node, parent);
+			else if (child.type === "JSXExpressionContainer" || child.type === "JSXSpreadChild") walk(child.expression, inherited, child, node);
+			return;
+		}
+		let scope = inherited;
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration" || node.type === "TSModuleDeclaration") bind(node.id, inherited);
+		const isFunction = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+		if (isFunction || node.type === "BlockStatement" || node.type === "CatchClause" || node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "SwitchStatement" || node.type === "ClassDeclaration" || node.type === "ClassExpression" || node.type === "StaticBlock" || node.type === "TSModuleDeclaration" || node.type === "TSEnumDeclaration") {
+			scope = {
+				parent: inherited,
+				functionScope: isFunction || node.type === "StaticBlock" || node.type === "TSModuleDeclaration",
+				bindings: Object.create(null),
+				resolved: Object.create(null)
+			};
+			scopes.push(scope);
+		}
+		if ("params" in node && isFunction) for (const parameter of node.params) bind(parameter, scope);
+		if (node.type === "FunctionExpression" || node.type === "ClassExpression" || node.type === "ClassDeclaration") bind(node.id, scope);
+		if (node.type === "TSImportEqualsDeclaration") bind(node.id, scope);
+		if (node.type === "CatchClause") bind(node.param, scope);
+		if (node.type === "VariableDeclaration") {
+			let target = scope;
+			if (node.kind === "var") while (!target.functionScope && target.parent) target = target.parent;
+			for (const declaration of node.declarations) bind(declaration.id, target);
+		}
+		if (node.type === "TSEnumDeclaration") for (const member of node.body.members) bind(member.id, scope);
+		const record = node;
+		for (const key of visitorKeys[node.type] ?? []) {
+			const child = record[key];
+			const childScope = isFunction && (key === "key" || key === "decorators") ? inherited : scope;
+			if (Array.isArray(child)) {
+				for (const item of child) if (item) walk(item, childScope, node, parent);
+			} else if (child) walk(child, childScope, node, parent);
+		}
+	};
+	walk(ast, root);
+	for (const scope of scopes) for (const reference of scope.references ?? []) getBinding$1(scope, reference.name)?.references.push(reference);
+	return {
+		imports,
+		elements,
+		names,
+		bindings
+	};
+};
+//#endregion
+//#region src/transform/transform-module.ts
+const getBinding = getBinding$1;
+const parseModule = createModuleParser();
+const ICON_COMPONENT_NAME = "ReactIconsSpriteIcon";
+const matches = (sources, pack) => sources.some((source) => {
+	source.lastIndex = 0;
+	return source.test(pack);
+});
+const isDefinition = (pack) => /^@fortawesome\/[\w-]+-svg-icons$/.test(pack) || /^@hugeicons\/core-free-icons(?:\/.*)?$/.test(pack);
+const defaultSourceHints = DEFAULT_ICON_SOURCES.map((source) => {
+	const pattern = source.source;
+	let prefix = "";
+	for (let index = 1; index < pattern.length; index++) {
+		const char = pattern[index];
+		if (char === "(" || char === "[" || char === "$") break;
+		if (char === "\\" && pattern[index + 1] === "/") index++;
+		prefix += pattern[index];
+	}
+	return prefix;
+});
+const hasPossibleIconSource = (code, sources, excluded) => {
+	if (code.includes("\\")) return true;
+	if (sources === DEFAULT_ICON_SOURCES && !defaultSourceHints.some((hint) => code.includes(hint))) return false;
+	for (let index = 0; index < code.length; index++) {
+		const quote = code[index];
+		if (quote !== "\"" && quote !== "'") continue;
+		const end = code.indexOf(quote, index + 1);
+		if (end === -1) continue;
+		const candidate = code.slice(index + 1, end);
+		if (matches(sources, candidate) && !matches(excluded, candidate)) return true;
+	}
+	return false;
+};
+const range = (node) => [node.start, node.end];
+const importedName = (node) => node.type === "ImportDefaultSpecifier" ? "default" : node.type === "ImportSpecifier" ? node.imported.type === "Identifier" ? node.imported.name : node.imported.value : "*";
+const transformModule = (code, id, register, sources = DEFAULT_ICON_SOURCES, options = {}) => {
+	const unchanged = {
+		code,
+		map: null,
+		anyReplacements: false
+	};
+	if (!fastFilter(code) || !hasPossibleIconSource(code, sources, options.excludedSources ?? [])) return unchanged;
+	let ast;
+	try {
+		const parsed = parseModule(id, code);
+		if (!parsed) return unchanged;
+		ast = parsed;
+	} catch {
+		return unchanged;
+	}
+	if (!ast.body.some((node) => node.type === "ImportDeclaration" && matches(sources, node.source.value) && !matches(options.excludedSources ?? [], node.source.value))) return unchanged;
+	const icons = /* @__PURE__ */ new Map();
+	const symbols = /* @__PURE__ */ new Map();
+	const wrappers = /* @__PURE__ */ new Map();
+	const { imports, elements, names, bindings } = analyzeModule(ast);
+	let spriteBinding;
+	for (const path of imports) {
+		const pack = path.node.source.value;
+		const supported = matches(sources, pack) && !matches(options.excludedSources ?? [], pack);
+		const definition = supported && isDefinition(pack);
+		const idPrefix = supported ? `ri-${normalizePackAlias(pack)}-` : "";
+		let exports = symbols.get(pack);
+		if (supported && !exports) {
+			exports = /* @__PURE__ */ new Map();
+			symbols.set(pack, exports);
+		}
+		for (const specifier of path.node.specifiers) {
+			if (path.node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+			const binding = getBinding(path.scope, specifier.local.name);
+			if (!binding || specifier.type === "ImportNamespaceSpecifier") continue;
+			const exportName = importedName(specifier);
+			if (pack === "react-icons-sprite" && exportName === "ReactIconsSpriteIcon") spriteBinding = binding;
+			if (pack === "@fortawesome/react-fontawesome" && exportName === "FontAwesomeIcon" || pack === "@hugeicons/react" && exportName === "HugeiconsIcon") wrappers.set(binding, pack);
+			if (supported && exports) {
+				let symbol = exports.get(exportName);
+				if (!symbol) {
+					symbol = {
+						pack,
+						exportName,
+						idPrefix,
+						definition,
+						openingReplacement: "",
+						referenceReplacement: ""
+					};
+					exports.set(exportName, symbol);
+				}
+				icons.set(binding, symbol);
+			}
+		}
+	}
+	if (!icons.size) return unchanged;
+	let componentName = spriteBinding?.identifier.name ?? "ReactIconsSpriteIcon";
+	const reuseSprite = spriteBinding && !bindings.some((binding) => binding !== spriteBinding && binding.identifier.name === componentName);
+	if (!reuseSprite) {
+		let suffix = 0;
+		while (names.has(componentName)) componentName = ICON_COMPONENT_NAME + ++suffix;
+	}
+	const openingReplacement = (icon) => icon.openingReplacement ||= `${componentName} iconId="${icon.idPrefix}${icon.exportName}"`;
+	const referenceReplacement = (icon) => icon.referenceReplacement ||= `(props) => <${componentName} {...props} iconId="${icon.idPrefix}${icon.exportName}" />`;
+	const edits = [];
+	const replaced = /* @__PURE__ */ new Set();
+	const usedImports = /* @__PURE__ */ new Set();
+	const registrations = [
+		[],
+		[],
+		[]
+	];
+	const replace = (node, value) => {
+		edits.push({
+			type: "replace",
+			from: node.start,
+			to: node.end,
+			value
+		});
+		replaced.add(node);
+	};
+	const elementBinding = (path) => {
+		const name = path.node.openingElement.name;
+		return name.type === "JSXIdentifier" ? getBinding(path.scope, name.name) : void 0;
+	};
+	const hasIconId = (path) => path.node.openingElement.attributes.some((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "iconId");
+	for (const path of elements) {
+		const binding = elementBinding(path);
+		const opening = path.node.openingElement;
+		const direct = binding && icons.get(binding);
+		if (binding && direct && !direct.definition) {
+			replace(opening.name, hasIconId(path) ? componentName : openingReplacement(direct));
+			if (path.node.closingElement) replace(path.node.closingElement.name, componentName);
+			usedImports.add(binding);
+			registrations[0].push(direct);
+			continue;
+		}
+		const wrapper = binding && wrappers.get(binding);
+		if (binding && wrapper) {
+			const attribute = opening.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "icon");
+			if (attribute?.type !== "JSXAttribute" || attribute.value?.type !== "JSXExpressionContainer" || attribute.value.expression.type !== "Identifier") continue;
+			const iconBinding = getBinding(path.scope, attribute.value.expression.name);
+			const icon = iconBinding && icons.get(iconBinding);
+			if (!iconBinding || !icon?.definition || wrapper === "@hugeicons/react" !== icon.pack.startsWith("@hugeicons/")) continue;
+			replace(opening.name, hasIconId(path) ? componentName : openingReplacement(icon));
+			if (path.node.closingElement) replace(path.node.closingElement.name, componentName);
+			let to = attribute.end;
+			while (/\s/.test(code[to] ?? "") && to < code.length) to++;
+			edits.push({
+				type: "remove",
+				from: attribute.start,
+				to
+			});
+			replaced.add(attribute.value.expression);
+			usedImports.add(binding);
+			usedImports.add(iconBinding);
+			registrations[2].push(icon);
+			continue;
+		}
+		for (const attribute of opening.attributes) {
+			if (attribute.type !== "JSXAttribute" || attribute.value?.type !== "JSXExpressionContainer" || attribute.value.expression.type !== "Identifier") continue;
+			const expression = attribute.value.expression;
+			const iconBinding = getBinding(path.scope, expression.name);
+			const icon = iconBinding && icons.get(iconBinding);
+			if (!iconBinding || !icon || icon.definition) continue;
+			replace(expression, referenceReplacement(icon));
+			usedImports.add(iconBinding);
+			registrations[1].push(icon);
+		}
+	}
+	const registered = /* @__PURE__ */ new Set();
+	for (const bucket of registrations) for (const icon of bucket) {
+		if (registered.has(icon)) continue;
+		registered.add(icon);
+		register(icon.pack, icon.exportName);
+	}
+	if (!edits.length) return unchanged;
+	for (const path of imports) {
+		const declaration = path.node;
+		const kept = declaration.specifiers.filter((specifier) => {
+			const binding = getBinding(path.scope, specifier.local.name);
+			return !binding || !usedImports.has(binding) || binding.references.some((reference) => !replaced.has(reference));
+		});
+		if (kept.length === declaration.specifiers.length) continue;
+		if (!kept.length) {
+			const [from, end] = range(declaration);
+			let to = end;
+			while (code[to] === " " || code[to] === "	" || code[to] === "\r") to++;
+			if (code[to] === "\n") to++;
+			edits.push({
+				type: "remove",
+				from,
+				to
+			});
+		} else {
+			const ordinary = kept.filter((spec) => spec.type !== "ImportSpecifier").map((spec) => code.slice(...range(spec)));
+			const named = kept.filter((spec) => spec.type === "ImportSpecifier").map((spec) => code.slice(...range(spec)));
+			if (named.length) ordinary.push(`{ ${named.join(", ")} }`);
+			edits.push({
+				type: "replace",
+				from: declaration.start + 6,
+				to: declaration.source.start,
+				value: ` ${ordinary.join(", ")} from `
+			});
+		}
+	}
+	if (!reuseSprite) {
+		const specifier = componentName === "ReactIconsSpriteIcon" ? ICON_COMPONENT_NAME : `${ICON_COMPONENT_NAME} as ${componentName}`;
+		const pos = ast.body.filter((node) => node.type === "ExpressionStatement" && "directive" in node).at(-1)?.end ?? ast.hashbang?.end ?? 0;
+		edits.push({
+			type: "insert",
+			pos,
+			value: (pos ? "\n" : "") + "import { " + specifier + " } from \"react-icons-sprite\";\n"
+		});
+	}
+	if (!options.sourceMap) return {
+		code: applyEditsToString(code, edits),
+		map: null,
+		anyReplacements: true
+	};
+	const result = applyEdits(code, edits);
+	return {
+		code: result.toString(),
+		map: result.generateMap({
+			source: id,
+			hires: true
+		}),
+		anyReplacements: true
+	};
+};
+//#endregion
+export { transformModule as t };

package/dist/vite/plugin.d.mts

@@ -1,7 +1,6 @@
-import { t as ReactIconsSpritePluginOptions } from "../plugin-options-ByGrVpdG.mjs";
+import { t as ReactIconsSpritePluginOptions } from "../plugin-options-DYfIgasR.mjs";
 import { Plugin } from "vite";
 //#region src/vite/plugin.d.ts
-type ReactIconsSpriteVitePluginOptions = ReactIconsSpritePluginOptions;
-declare const reactIconsSprite: (options?: ReactIconsSpriteVitePluginOptions) => Plugin;
-//#endregion
-export { ReactIconsSpriteVitePluginOptions, reactIconsSprite };
+export type ReactIconsSpriteVitePluginOptions = ReactIconsSpritePluginOptions;
+export declare const reactIconsSprite: (options?: ReactIconsSpriteVitePluginOptions) => Plugin;
+//#endregion

package/dist/vite/plugin.mjs

@@ -1,12 +1,13 @@
 import { REACT_ICONS_SPRITE_URL_PLACEHOLDER } from "../index.mjs";
-import { i as createSpriteAssetName, r as createIconSources, s as createCollector } from "../compute-icon-id-1Gop_fRM.mjs";
-import { t as buildSprite } from "../build-sprite-Dci5SlWn.mjs";
-import { t as transformModule } from "../transform-module-BakS0Tzh.mjs";
+import { a as createIconSources, c as createCollector, i as createExcludedIconSources, o as createSpriteAssetName } from "../compute-icon-id-C42PyoDX.mjs";
+import { t as buildSprite } from "../build-sprite-DEOFEWm0.mjs";
+import { t as transformModule } from "../transform-module-Cabatwdp.mjs";
 import { createHash } from "node:crypto";
 //#region src/vite/plugin.ts
 const reactIconsSprite = (options = {}) => {
 	const { outputDir } = options;
 	const iconSources = createIconSources();
+	const excludedIconSources = createExcludedIconSources(options.exclude);
 	const collector = createCollector();
 	let root = process.cwd();
 	return {
@@ -25,7 +26,7 @@ const reactIconsSprite = (options = {}) => {
 			try {
 				const { code: next, map, anyReplacements } = transformModule(code, id, (pack, exportName) => {
 					collector.add(pack, exportName, { importer: cleanId });
-				}, iconSources);
+				}, iconSources, { excludedSources: excludedIconSources });
 				if (!anyReplacements) return null;
 				return {
 					code: next,

package/dist/webpack/loader.d.mts

@@ -1,5 +1,8 @@
+import { t as ReactIconsSpritePluginOptions } from "../plugin-options-DYfIgasR.mjs";
 import { LoaderDefinitionFunction } from "webpack";
 //#region src/webpack/loader.d.ts
-declare const reactIconsSpriteLoader: LoaderDefinitionFunction;
+export type ReactIconsSpriteWebpackLoaderOptions = Pick<ReactIconsSpritePluginOptions, 'exclude'>;
+type SpriteLoader = LoaderDefinitionFunction<ReactIconsSpriteWebpackLoaderOptions>;
+declare const reactIconsSpriteLoader: SpriteLoader;
 //#endregion
 export { reactIconsSpriteLoader as default };

package/dist/webpack/loader.mjs

@@ -1,6 +1,6 @@
-import { r as createIconSources } from "../compute-icon-id-1Gop_fRM.mjs";
-import { t as transformModule } from "../transform-module-BakS0Tzh.mjs";
-import { t as collector } from "../collector-dvzR3TG1.mjs";
+import { a as createIconSources, i as createExcludedIconSources } from "../compute-icon-id-C42PyoDX.mjs";
+import { t as transformModule } from "../transform-module-Cabatwdp.mjs";
+import { t as collector } from "../collector-1bZHiz4N.mjs";
 //#region src/webpack/loader.ts
 const reactIconsSpriteLoader = async function(source) {
 	if (this.mode === "development") return source;
@@ -8,9 +8,11 @@ const reactIconsSpriteLoader = async function(source) {
 	try {
 		if (!/\.(mjs|cjs|js|jsx|ts|tsx)$/i.test(id)) return source;
 		const iconSources = createIconSources();
+		const { exclude } = this.getOptions();
+		const excludedIconSources = createExcludedIconSources(exclude);
 		const { code, anyReplacements } = transformModule(String(source), id, (pack, exportName) => {
 			collector.add(pack, exportName, { importer: id });
-		}, iconSources);
+		}, iconSources, { excludedSources: excludedIconSources });
 		if (!anyReplacements) return source;
 		return code;
 	} catch (err) {

package/dist/webpack/plugin.d.mts

@@ -1,11 +1,10 @@
-import { t as ReactIconsSpritePluginOptions } from "../plugin-options-ByGrVpdG.mjs";
+import { t as ReactIconsSpritePluginOptions } from "../plugin-options-DYfIgasR.mjs";
 import { Compiler } from "webpack";
 //#region src/webpack/plugin.d.ts
-type ReactIconsSpriteWebpackPluginOptions = ReactIconsSpritePluginOptions;
-declare class ReactIconsSpriteWebpackPlugin {
+export type ReactIconsSpriteWebpackPluginOptions = Pick<ReactIconsSpritePluginOptions, 'outputDir'>;
+export declare class ReactIconsSpriteWebpackPlugin {
   private readonly outputDir?;
   constructor(options?: ReactIconsSpriteWebpackPluginOptions);
   apply(compiler: Compiler): void;
 }
-//#endregion
-export { ReactIconsSpriteWebpackPlugin, ReactIconsSpriteWebpackPluginOptions };
+//#endregion

package/dist/webpack/plugin.mjs

@@ -1,7 +1,7 @@
 import { REACT_ICONS_SPRITE_URL_PLACEHOLDER } from "../index.mjs";
-import { i as createSpriteAssetName } from "../compute-icon-id-1Gop_fRM.mjs";
-import { t as buildSprite } from "../build-sprite-Dci5SlWn.mjs";
-import { t as collector } from "../collector-dvzR3TG1.mjs";
+import { o as createSpriteAssetName } from "../compute-icon-id-C42PyoDX.mjs";
+import { t as buildSprite } from "../build-sprite-DEOFEWm0.mjs";
+import { t as collector } from "../collector-1bZHiz4N.mjs";
 import { createHash } from "node:crypto";
 //#region src/webpack/plugin.ts
 var ReactIconsSpriteWebpackPlugin = class {