unplugin-cheetah-grid-icon-svg 0.0.0

package/README.md

@@ -0,0 +1,115 @@
+# unplugin-cheetah-grid-icon-svg
+
+Unplugin that loads the icon module for Cheetah Grid from SVG.
+
+This package is the Vite-friendly replacement for `cheetah-grid-icon-svg-loader`.
+It uses the same SVG-to-icon conversion logic and also exposes Rollup, Rolldown,
+Webpack, Rspack, and esbuild adapters through `unplugin`.
+
+## Installation
+
+```bash
+npm install --save-dev unplugin-cheetah-grid-icon-svg
+```
+
+## Usage with Vite
+
+```js
+import cheetahGridIconSvg from "unplugin-cheetah-grid-icon-svg/vite";
+
+export default {
+  plugins: [
+    cheetahGridIconSvg(),
+  ],
+};
+```
+
+```js
+import gridOn from "material-design-icons/image/svg/production/ic_grid_on_24px.svg?cheetah-grid-icon";
+
+const icons = {
+  gridOn,
+};
+
+cheetahGrid.register.icons(icons);
+```
+
+## Transform a Set of SVG Files
+
+If you want imports from a known icon directory to behave like the old webpack
+loader without adding a query to every import, pass `include`.
+
+```js
+import cheetahGridIconSvg from "unplugin-cheetah-grid-icon-svg/vite";
+
+export default {
+  plugins: [
+    cheetahGridIconSvg({
+      include: /material-design-icons\/.+\.svg$/,
+    }),
+  ],
+};
+```
+
+## Font SVG
+
+Font SVG files are converted to an object whose keys are glyph unicode values,
+matching `cheetah-grid-icon-svg-loader`.
+
+```js
+import materialIcons from "material-design-icons/iconfont/MaterialIcons-Regular.svg?cheetah-grid-icon";
+```
+
+You can also load a single glyph.
+
+```js
+import add from "material-design-icons/iconfont/MaterialIcons-Regular.svg?cheetah-grid-icon&glyph-name=add";
+```
+
+## Other Bundlers
+
+```js
+const cheetahGridIconSvg = require("unplugin-cheetah-grid-icon-svg/webpack");
+
+module.exports = {
+  plugins: [
+    cheetahGridIconSvg(),
+  ],
+};
+```
+
+```js
+import cheetahGridIconSvg from "unplugin-cheetah-grid-icon-svg/rollup";
+
+export default {
+  plugins: [
+    cheetahGridIconSvg(),
+  ],
+};
+```
+
+```js
+import cheetahGridIconSvg from "unplugin-cheetah-grid-icon-svg/rolldown";
+
+export default {
+  plugins: [
+    cheetahGridIconSvg(),
+  ],
+};
+```
+
+## Options
+
+```ts
+interface Options {
+  include?: string | RegExp | ((id: string) => boolean) | Array<string | RegExp | ((id: string) => boolean)>;
+  exclude?: string | RegExp | ((id: string) => boolean) | Array<string | RegExp | ((id: string) => boolean)>;
+  query?: string | string[] | false;
+}
+```
+
+- `include` transforms matching SVG imports without requiring a query.
+- `exclude` prevents matching SVG imports from being transformed.
+- `query` changes the query names that opt in to transformation. The default is
+  `["cheetah-grid-icon", "cg-icon"]`. Set `query: false` to transform every
+  SVG matched by `include`, or every SVG import when `include` is omitted.

package/dist/esbuild.cjs

@@ -0,0 +1,4 @@
+//#region src/esbuild.ts
+var esbuild_default = require("./src.cjs").unplugin.esbuild;
+//#endregion
+module.exports = esbuild_default;

package/dist/esbuild.d.mts

@@ -0,0 +1,6 @@
+import { r as Options } from "./index.mjs";
+
+//#region src/esbuild.d.ts
+declare const _default: (options?: Options | undefined) => EsbuildPlugin;
+//#endregion
+export { _default as default };

package/dist/esbuild.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/esbuild.ts
+var esbuild_default = unplugin.esbuild;
+//#endregion
+export { esbuild_default as default };

package/dist/index.cjs

@@ -0,0 +1,2 @@
+const require_src = require("./src.cjs");
+module.exports = require_src.unplugin;

package/dist/index.d.mts

@@ -0,0 +1,14 @@
+import * as unplugin0 from "unplugin";
+
+//#region src/core/transform.d.ts
+type FilterPattern = string | RegExp | ((id: string) => boolean) | FilterPattern[];
+interface Options {
+  include?: FilterPattern;
+  exclude?: FilterPattern;
+  query?: string | string[] | false;
+}
+//#endregion
+//#region src/index.d.ts
+declare const unplugin: unplugin0.UnpluginInstance<Options | undefined, boolean>;
+//#endregion
+export { FilterPattern as n, Options as r, unplugin as t };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { t as unplugin } from "./src.mjs";
+export { unplugin as default };

package/dist/index2.d.mts

@@ -0,0 +1,2 @@
+import { n as FilterPattern, r as Options, t as unplugin } from "./index.mjs";
+export { FilterPattern, Options, unplugin as default };

package/dist/rolldown.cjs

@@ -0,0 +1,4 @@
+//#region src/rolldown.ts
+var rolldown_default = require("./src.cjs").unplugin.rolldown;
+//#endregion
+module.exports = rolldown_default;

package/dist/rolldown.d.mts

@@ -0,0 +1,7 @@
+import { r as Options } from "./index.mjs";
+import * as rolldown0 from "rolldown";
+
+//#region src/rolldown.d.ts
+declare const _default: (options?: Options | undefined) => rolldown0.Plugin<any> | rolldown0.Plugin<any>[];
+//#endregion
+export { _default as default };

package/dist/rolldown.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/rolldown.ts
+var rolldown_default = unplugin.rolldown;
+//#endregion
+export { rolldown_default as default };

package/dist/rollup.cjs

@@ -0,0 +1,4 @@
+//#region src/rollup.ts
+var rollup_default = require("./src.cjs").unplugin.rollup;
+//#endregion
+module.exports = rollup_default;

package/dist/rollup.d.mts

@@ -0,0 +1,6 @@
+import { r as Options } from "./index.mjs";
+
+//#region src/rollup.d.ts
+declare const _default: (options?: Options | undefined) => any;
+//#endregion
+export { _default as default };

package/dist/rollup.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/rollup.ts
+var rollup_default = unplugin.rollup;
+//#endregion
+export { rollup_default as default };

package/dist/rspack.cjs

@@ -0,0 +1,4 @@
+//#region src/rspack.ts
+var rspack_default = require("./src.cjs").unplugin.rspack;
+//#endregion
+module.exports = rspack_default;

package/dist/rspack.d.mts

@@ -0,0 +1,6 @@
+import { r as Options } from "./index.mjs";
+
+//#region src/rspack.d.ts
+declare const _default: (options?: Options | undefined) => RspackPluginInstance;
+//#endregion
+export { _default as default };

package/dist/rspack.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/rspack.ts
+var rspack_default = unplugin.rspack;
+//#endregion
+export { rspack_default as default };

package/dist/src.cjs

@@ -0,0 +1,374 @@
+let unplugin = require("unplugin");
+let node_module = require("node:module");
+let _xmldom_xmldom = require("@xmldom/xmldom");
+//#region src/core/svg-data.ts
+const ELEMENT_NODE = 1;
+const parser = new (typeof window !== "undefined" && window.DOMParser ? window.DOMParser : _xmldom_xmldom.DOMParser)();
+function isElementNode(node) {
+	return node.nodeType === ELEMENT_NODE && typeof node.tagName === "string";
+}
+function findElement(el, test) {
+	const { childNodes } = el;
+	for (let i = 0; i < childNodes.length; i++) {
+		const child = childNodes[i];
+		if (!isElementNode(child)) continue;
+		if (test(child)) return child;
+		const result = findElement(child, test);
+		if (result) return result;
+	}
+	return null;
+}
+var Svg = class {
+	constructor(svgCode) {
+		this.glyphs = {};
+		this.glyphUnicodes = {};
+		const document = parser.parseFromString(svgCode, "image/svg+xml");
+		this.svg = document.documentElement;
+	}
+	findElement(test) {
+		return findElement(this.svg, test);
+	}
+	get fontFaceElement() {
+		if (this.cachedFontFaceElement === void 0) this.cachedFontFaceElement = this.findElement((child) => child.tagName.toLowerCase() === "font-face");
+		return this.cachedFontFaceElement;
+	}
+	get fontElement() {
+		if (this.cachedFontElement === void 0) this.cachedFontElement = this.findElement((child) => child.tagName.toLowerCase() === "font");
+		return this.cachedFontElement;
+	}
+	findGlyph(glyphName) {
+		if (!(glyphName in this.glyphs)) this.glyphs[glyphName] = this.findElement((child) => child.getAttribute("glyph-name") === glyphName);
+		return this.glyphs[glyphName] || null;
+	}
+	findGlyphByUnicode(unicode) {
+		if (!(unicode in this.glyphUnicodes)) this.glyphUnicodes[unicode] = this.findElement((child) => child.getAttribute("unicode") === unicode);
+		return this.glyphUnicodes[unicode] || null;
+	}
+	walkAllGlyph(callback) {
+		const walkGlyph = (el) => {
+			const { childNodes } = el;
+			for (let i = 0; i < childNodes.length; i++) {
+				const child = childNodes[i];
+				if (!isElementNode(child)) continue;
+				const unicode = child.getAttribute("unicode");
+				if (unicode && child.getAttribute("d")) {
+					if (!this.glyphUnicodes[unicode]) this.glyphUnicodes[unicode] = child;
+					const glyphName = child.getAttribute("glyph-name");
+					if (glyphName && !this.glyphs[glyphName]) this.glyphs[glyphName] = child;
+					callback(child);
+				} else walkGlyph(child);
+			}
+		};
+		walkGlyph(this.svg);
+	}
+};
+const cache = {};
+function get(svgCode) {
+	const cacheKey = `font:${svgCode}`;
+	cache[cacheKey] = cache[cacheKey] || new Svg(svgCode);
+	return cache[cacheKey];
+}
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function attr(el, name) {
+	return el.getAttribute(name) || "";
+}
+function polygonToPath(polygon) {
+	return `M${attr(polygon, "points")}z`;
+}
+function polylineToPath(polyline) {
+	return `M${attr(polyline, "points")}`;
+}
+function circleToPath(circle) {
+	const cx = Number(attr(circle, "cx"));
+	const cy = Number(attr(circle, "cy"));
+	const r = Number(attr(circle, "r"));
+	const segments = 8;
+	const angle = 2 * Math.PI / segments;
+	const anchorX = (theta) => r * Math.cos(theta);
+	const anchorY = (theta) => r * Math.sin(theta);
+	const controlX = (theta) => anchorX(theta) + r * Math.tan(angle / 2) * Math.cos(theta - Math.PI / 2);
+	const controlY = (theta) => anchorY(theta) + r * Math.tan(angle / 2) * Math.sin(theta - Math.PI / 2);
+	let paths = `M${cx + r} ${cy}`;
+	for (let index = 1; index <= segments; index++) {
+		const theta = index * angle;
+		paths += `Q${controlX(theta) + cx} ${controlY(theta) + cy} ${anchorX(theta) + cx} ${anchorY(theta) + cy}`;
+	}
+	return paths;
+}
+function rectToPath(rect) {
+	const x = Number(attr(rect, "x"));
+	const y = Number(attr(rect, "y"));
+	const width = Number(attr(rect, "width"));
+	return `M${x},${y} h${width} v${Number(attr(rect, "height"))} h${-width}z`;
+}
+function getD(path) {
+	if (path.getAttribute("fill") === "none") return "";
+	return attr(path, "d").replace(/[\n\r]/gu, "");
+}
+function elementToPaths(el, resource) {
+	switch (el.tagName.toLowerCase()) {
+		case "path":
+		case "glyph": return getD(el);
+		case "circle": return circleToPath(el);
+		case "polygon": return polygonToPath(el);
+		case "polyline": return polylineToPath(el);
+		case "rect": return rectToPath(el);
+		case "g": {
+			let path = "";
+			const { childNodes } = el;
+			for (let i = 0; i < childNodes.length; i++) {
+				const child = childNodes[i];
+				if (!isElementNode(child)) continue;
+				if (!child.getAttribute("fill")) child.setAttribute("fill", el.getAttribute("fill"));
+				path += elementToPaths(child, resource);
+			}
+			return path;
+		}
+		default: console.warn(`unsupported:${el.tagName}`, `@ ${resource}\n${el.innerHTML}`);
+	}
+	return "";
+}
+function buildScript({ offsetX = 0, offsetY = 0, width, height, d, isGlyph, html, resource }) {
+	let flags = "";
+	if (isGlyph) flags += `ud: 1,
+	`;
+	if (offsetX !== 0) flags += `x: ${offsetX},
+	`;
+	if (offsetY !== 0) flags += `y: ${offsetY},
+	`;
+	return `{
+	/*
+	original svg
+	${html}
+	@ ${resource}
+	*/
+	d: '${d}',
+	width: ${width},
+	height: ${height},
+	${flags}
+}`;
+}
+function glyphToJSON(svgString, { glyphName, unicode }, resource) {
+	const svg = get(svgString);
+	const findGlyph = () => {
+		if (glyphName && glyphName !== true) return svg.findGlyph(glyphName);
+		return unicode && unicode !== true ? svg.findGlyphByUnicode(unicode) : null;
+	};
+	const emptyElement = { getAttribute: () => "" };
+	const fontFace = svg.fontFaceElement || emptyElement;
+	const font = svg.fontElement || emptyElement;
+	const glyph = findGlyph();
+	if (!glyph) throw new Error(`Glyph not found: ${glyphName && glyphName !== true ? glyphName : unicode && unicode !== true ? unicode : ""}`);
+	const fontHorizAdvX = Number(font.getAttribute("horiz-adv-x")) || 0;
+	const fontVertAdvX = Number(font.getAttribute("vert-adv-x")) || 0;
+	const horizAdvX = Number(glyph.getAttribute("horiz-adv-x")) || fontHorizAdvX || 0;
+	const vertAdvX = Number(glyph.getAttribute("vert-adv-x")) || fontVertAdvX || 0;
+	const unitsPerEm = Number(fontFace.getAttribute("units-per-em")) || 1e3;
+	const descent = Number(fontFace.getAttribute("descent")) || vertAdvX;
+	let size = unitsPerEm;
+	const contentSize = {
+		width: horizAdvX || unitsPerEm,
+		height: vertAdvX || unitsPerEm
+	};
+	if (horizAdvX > size) size = horizAdvX;
+	if (vertAdvX > size) size = vertAdvX;
+	let offsetX = 0;
+	let offsetY = -descent;
+	offsetX += Math.round((size - contentSize.width) / 2);
+	offsetY += Math.round((size - contentSize.height) / 2);
+	return buildScript({
+		offsetX,
+		offsetY,
+		width: size,
+		height: size,
+		d: elementToPaths(glyph, resource),
+		isGlyph: true,
+		html: glyph.outerHTML,
+		resource
+	});
+}
+function svgToJSON(svgString, resource) {
+	const { svg } = get(svgString);
+	const viewBox = attr(svg, "viewBox").split(" ");
+	const width = Number(attr(svg, "width") || viewBox[2]) || 0;
+	const height = Number(attr(svg, "height") || viewBox[3]) || 0;
+	const offsetX = 0 - Number(viewBox[0]) || 0;
+	const offsetY = 0 - Number(viewBox[1]) || 0;
+	let d = "";
+	const { childNodes } = svg;
+	for (let i = 0; i < childNodes.length; i++) {
+		const el = childNodes[i];
+		if (!isElementNode(el)) continue;
+		d += elementToPaths(el, resource);
+	}
+	return buildScript({
+		offsetX,
+		offsetY,
+		width,
+		height,
+		d,
+		html: svgString,
+		resource
+	});
+}
+function normalizeResource$1(resource) {
+	let index = resource.indexOf("\\node_modules\\");
+	if (index === -1) index = resource.indexOf("/node_modules/");
+	if (index >= 0) return resource.slice(index + 14);
+	return resource;
+}
+function sourceToIconJsObject$1(svgCode, opt = {}) {
+	const resource = normalizeResource$1(opt.resource || "");
+	if (opt["glyph-name"] || opt.unicode) return glyphToJSON(svgCode, {
+		glyphName: opt["glyph-name"],
+		unicode: opt.unicode
+	}, resource);
+	return svgToJSON(svgCode, resource);
+}
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function toGlyphs(svgCode) {
+	const svg = get(svgCode);
+	const glyphs = [];
+	svg.walkAllGlyph((el) => glyphs.push(el));
+	return glyphs;
+}
+function transform(glyphUnicode, svgCode, svgfile) {
+	return sourceToIconJsObject$1(svgCode, {
+		unicode: glyphUnicode,
+		resource: svgfile
+	});
+}
+function charToHexCodeStr(char) {
+	if (/[!#-&(-[\]-_a-~]/u.test(char)) return char;
+	return `\\u${`0000${char.charCodeAt(0).toString(16)}`.slice(-4)}`;
+}
+function toCodeString(code) {
+	let result = "";
+	for (let i = 0; i < code.length; i++) result += charToHexCodeStr(code[i]);
+	return result;
+}
+function buildObjectCode(svgCode, resource, { name = "unicode" } = {}) {
+	let script = "{\n";
+	toGlyphs(svgCode).forEach((glyph) => {
+		const unicode = glyph.getAttribute("unicode") || "";
+		const targetName = glyph.getAttribute(name) || "";
+		script += `
+	'${toCodeString(targetName)}': ${transform(unicode, svgCode, resource).replace(/\r?\n|\r/gu, `
+	`)},`;
+	});
+	script += "\n}";
+	return script;
+}
+function normalizeResource(resource) {
+	let index = resource.indexOf("\\node_modules\\");
+	if (index === -1) index = resource.indexOf("/node_modules/");
+	if (index >= 0) return resource.slice(index + 14);
+	return resource;
+}
+function sourceToIconsJsObject(svgCode, opt = {}) {
+	return buildObjectCode(svgCode, normalizeResource(opt.resource || ""), opt);
+}
+//#endregion
+//#region src/core/transform.ts
+const DEFAULT_QUERY_NAMES = ["cheetah-grid-icon", "cg-icon"];
+const SVG_EXT_RE = /\.svg$/iu;
+function parseId(id) {
+	const queryIndex = id.indexOf("?");
+	if (queryIndex < 0) return {
+		filename: id,
+		query: {}
+	};
+	return {
+		filename: id.slice(0, queryIndex),
+		query: parseQuery(id.slice(queryIndex + 1))
+	};
+}
+function parseQuery(queryText) {
+	const query = {};
+	if (!queryText) return query;
+	queryText.split("&").forEach((part) => {
+		if (!part) return;
+		const equalIndex = part.indexOf("=");
+		const rawKey = equalIndex < 0 ? part : part.slice(0, equalIndex);
+		const rawValue = equalIndex < 0 ? true : part.slice(equalIndex + 1);
+		query[decode(rawKey)] = rawValue === true ? true : decode(rawValue);
+	});
+	return query;
+}
+function decode(value) {
+	try {
+		return decodeURIComponent(value.replace(/\+/gu, " "));
+	} catch (_err) {
+		return value;
+	}
+}
+function normalizeQueryNames(query) {
+	if (query === false) return [];
+	if (query == null) return DEFAULT_QUERY_NAMES;
+	return Array.isArray(query) ? query : [query];
+}
+function hasOwn(object, key) {
+	return Object.prototype.hasOwnProperty.call(object, key);
+}
+function matchesPattern(pattern, value) {
+	if (pattern == null) return false;
+	if (Array.isArray(pattern)) return pattern.some((item) => matchesPattern(item, value));
+	if (pattern instanceof RegExp) {
+		pattern.lastIndex = 0;
+		return pattern.test(value);
+	}
+	if (typeof pattern === "function") return Boolean(pattern(value));
+	return value.indexOf(String(pattern)) >= 0;
+}
+function matchesFilter(pattern, id, filename) {
+	return matchesPattern(pattern, id) || matchesPattern(pattern, filename);
+}
+function hasPluginQuery(query, options = {}) {
+	return normalizeQueryNames(options.query).some((queryName) => hasOwn(query, queryName));
+}
+function shouldTransform(id, options = {}) {
+	const { filename, query } = parseId(id);
+	if (!SVG_EXT_RE.test(filename)) return false;
+	if (matchesFilter(options.exclude, id, filename)) return false;
+	if (hasPluginQuery(query, options)) return true;
+	if (options.include != null) return matchesFilter(options.include, id, filename);
+	return options.query === false;
+}
+function buildParams(id, options = {}) {
+	const { filename, query } = parseId(id);
+	const queryNames = normalizeQueryNames(options.query);
+	const params = { resource: filename };
+	for (const key in query) if (queryNames.indexOf(key) < 0) params[key] = query[key];
+	return params;
+}
+function sourceToIconJsObject(source, id, options = {}) {
+	const params = buildParams(id, options);
+	if (source.indexOf("<font-face") >= 0 && !params["glyph-name"] && !params.unicode) return sourceToIconsJsObject(source, params);
+	return sourceToIconJsObject$1(source, params);
+}
+function transformSvg(source, id, options = {}) {
+	return {
+		code: `export default ${sourceToIconJsObject(source, id, options)};\n`,
+		map: { mappings: "" }
+	};
+}
+//#endregion
+//#region src/index.ts
+const unplugin$1 = (0, unplugin.createUnplugin)((options = {}) => ({
+	name: "unplugin-cheetah-grid-icon-svg",
+	enforce: "pre",
+	transformInclude(id) {
+		return shouldTransform(id, options);
+	},
+	transform(source, id) {
+		if (!shouldTransform(id, options)) return null;
+		return transformSvg(source, id, options);
+	}
+}));
+//#endregion
+Object.defineProperty(exports, "unplugin", {
+	enumerable: true,
+	get: function() {
+		return unplugin$1;
+	}
+});

package/dist/src.mjs

@@ -0,0 +1,369 @@
+import { createRequire } from "node:module";
+import { createUnplugin } from "unplugin";
+import { DOMParser } from "@xmldom/xmldom";
+//#region src/core/svg-data.ts
+const ELEMENT_NODE = 1;
+const parser = new (typeof window !== "undefined" && window.DOMParser ? window.DOMParser : DOMParser)();
+function isElementNode(node) {
+	return node.nodeType === ELEMENT_NODE && typeof node.tagName === "string";
+}
+function findElement(el, test) {
+	const { childNodes } = el;
+	for (let i = 0; i < childNodes.length; i++) {
+		const child = childNodes[i];
+		if (!isElementNode(child)) continue;
+		if (test(child)) return child;
+		const result = findElement(child, test);
+		if (result) return result;
+	}
+	return null;
+}
+var Svg = class {
+	constructor(svgCode) {
+		this.glyphs = {};
+		this.glyphUnicodes = {};
+		const document = parser.parseFromString(svgCode, "image/svg+xml");
+		this.svg = document.documentElement;
+	}
+	findElement(test) {
+		return findElement(this.svg, test);
+	}
+	get fontFaceElement() {
+		if (this.cachedFontFaceElement === void 0) this.cachedFontFaceElement = this.findElement((child) => child.tagName.toLowerCase() === "font-face");
+		return this.cachedFontFaceElement;
+	}
+	get fontElement() {
+		if (this.cachedFontElement === void 0) this.cachedFontElement = this.findElement((child) => child.tagName.toLowerCase() === "font");
+		return this.cachedFontElement;
+	}
+	findGlyph(glyphName) {
+		if (!(glyphName in this.glyphs)) this.glyphs[glyphName] = this.findElement((child) => child.getAttribute("glyph-name") === glyphName);
+		return this.glyphs[glyphName] || null;
+	}
+	findGlyphByUnicode(unicode) {
+		if (!(unicode in this.glyphUnicodes)) this.glyphUnicodes[unicode] = this.findElement((child) => child.getAttribute("unicode") === unicode);
+		return this.glyphUnicodes[unicode] || null;
+	}
+	walkAllGlyph(callback) {
+		const walkGlyph = (el) => {
+			const { childNodes } = el;
+			for (let i = 0; i < childNodes.length; i++) {
+				const child = childNodes[i];
+				if (!isElementNode(child)) continue;
+				const unicode = child.getAttribute("unicode");
+				if (unicode && child.getAttribute("d")) {
+					if (!this.glyphUnicodes[unicode]) this.glyphUnicodes[unicode] = child;
+					const glyphName = child.getAttribute("glyph-name");
+					if (glyphName && !this.glyphs[glyphName]) this.glyphs[glyphName] = child;
+					callback(child);
+				} else walkGlyph(child);
+			}
+		};
+		walkGlyph(this.svg);
+	}
+};
+const cache = {};
+function get(svgCode) {
+	const cacheKey = `font:${svgCode}`;
+	cache[cacheKey] = cache[cacheKey] || new Svg(svgCode);
+	return cache[cacheKey];
+}
+createRequire(import.meta.url);
+function attr(el, name) {
+	return el.getAttribute(name) || "";
+}
+function polygonToPath(polygon) {
+	return `M${attr(polygon, "points")}z`;
+}
+function polylineToPath(polyline) {
+	return `M${attr(polyline, "points")}`;
+}
+function circleToPath(circle) {
+	const cx = Number(attr(circle, "cx"));
+	const cy = Number(attr(circle, "cy"));
+	const r = Number(attr(circle, "r"));
+	const segments = 8;
+	const angle = 2 * Math.PI / segments;
+	const anchorX = (theta) => r * Math.cos(theta);
+	const anchorY = (theta) => r * Math.sin(theta);
+	const controlX = (theta) => anchorX(theta) + r * Math.tan(angle / 2) * Math.cos(theta - Math.PI / 2);
+	const controlY = (theta) => anchorY(theta) + r * Math.tan(angle / 2) * Math.sin(theta - Math.PI / 2);
+	let paths = `M${cx + r} ${cy}`;
+	for (let index = 1; index <= segments; index++) {
+		const theta = index * angle;
+		paths += `Q${controlX(theta) + cx} ${controlY(theta) + cy} ${anchorX(theta) + cx} ${anchorY(theta) + cy}`;
+	}
+	return paths;
+}
+function rectToPath(rect) {
+	const x = Number(attr(rect, "x"));
+	const y = Number(attr(rect, "y"));
+	const width = Number(attr(rect, "width"));
+	return `M${x},${y} h${width} v${Number(attr(rect, "height"))} h${-width}z`;
+}
+function getD(path) {
+	if (path.getAttribute("fill") === "none") return "";
+	return attr(path, "d").replace(/[\n\r]/gu, "");
+}
+function elementToPaths(el, resource) {
+	switch (el.tagName.toLowerCase()) {
+		case "path":
+		case "glyph": return getD(el);
+		case "circle": return circleToPath(el);
+		case "polygon": return polygonToPath(el);
+		case "polyline": return polylineToPath(el);
+		case "rect": return rectToPath(el);
+		case "g": {
+			let path = "";
+			const { childNodes } = el;
+			for (let i = 0; i < childNodes.length; i++) {
+				const child = childNodes[i];
+				if (!isElementNode(child)) continue;
+				if (!child.getAttribute("fill")) child.setAttribute("fill", el.getAttribute("fill"));
+				path += elementToPaths(child, resource);
+			}
+			return path;
+		}
+		default: console.warn(`unsupported:${el.tagName}`, `@ ${resource}\n${el.innerHTML}`);
+	}
+	return "";
+}
+function buildScript({ offsetX = 0, offsetY = 0, width, height, d, isGlyph, html, resource }) {
+	let flags = "";
+	if (isGlyph) flags += `ud: 1,
+	`;
+	if (offsetX !== 0) flags += `x: ${offsetX},
+	`;
+	if (offsetY !== 0) flags += `y: ${offsetY},
+	`;
+	return `{
+	/*
+	original svg
+	${html}
+	@ ${resource}
+	*/
+	d: '${d}',
+	width: ${width},
+	height: ${height},
+	${flags}
+}`;
+}
+function glyphToJSON(svgString, { glyphName, unicode }, resource) {
+	const svg = get(svgString);
+	const findGlyph = () => {
+		if (glyphName && glyphName !== true) return svg.findGlyph(glyphName);
+		return unicode && unicode !== true ? svg.findGlyphByUnicode(unicode) : null;
+	};
+	const emptyElement = { getAttribute: () => "" };
+	const fontFace = svg.fontFaceElement || emptyElement;
+	const font = svg.fontElement || emptyElement;
+	const glyph = findGlyph();
+	if (!glyph) throw new Error(`Glyph not found: ${glyphName && glyphName !== true ? glyphName : unicode && unicode !== true ? unicode : ""}`);
+	const fontHorizAdvX = Number(font.getAttribute("horiz-adv-x")) || 0;
+	const fontVertAdvX = Number(font.getAttribute("vert-adv-x")) || 0;
+	const horizAdvX = Number(glyph.getAttribute("horiz-adv-x")) || fontHorizAdvX || 0;
+	const vertAdvX = Number(glyph.getAttribute("vert-adv-x")) || fontVertAdvX || 0;
+	const unitsPerEm = Number(fontFace.getAttribute("units-per-em")) || 1e3;
+	const descent = Number(fontFace.getAttribute("descent")) || vertAdvX;
+	let size = unitsPerEm;
+	const contentSize = {
+		width: horizAdvX || unitsPerEm,
+		height: vertAdvX || unitsPerEm
+	};
+	if (horizAdvX > size) size = horizAdvX;
+	if (vertAdvX > size) size = vertAdvX;
+	let offsetX = 0;
+	let offsetY = -descent;
+	offsetX += Math.round((size - contentSize.width) / 2);
+	offsetY += Math.round((size - contentSize.height) / 2);
+	return buildScript({
+		offsetX,
+		offsetY,
+		width: size,
+		height: size,
+		d: elementToPaths(glyph, resource),
+		isGlyph: true,
+		html: glyph.outerHTML,
+		resource
+	});
+}
+function svgToJSON(svgString, resource) {
+	const { svg } = get(svgString);
+	const viewBox = attr(svg, "viewBox").split(" ");
+	const width = Number(attr(svg, "width") || viewBox[2]) || 0;
+	const height = Number(attr(svg, "height") || viewBox[3]) || 0;
+	const offsetX = 0 - Number(viewBox[0]) || 0;
+	const offsetY = 0 - Number(viewBox[1]) || 0;
+	let d = "";
+	const { childNodes } = svg;
+	for (let i = 0; i < childNodes.length; i++) {
+		const el = childNodes[i];
+		if (!isElementNode(el)) continue;
+		d += elementToPaths(el, resource);
+	}
+	return buildScript({
+		offsetX,
+		offsetY,
+		width,
+		height,
+		d,
+		html: svgString,
+		resource
+	});
+}
+function normalizeResource$1(resource) {
+	let index = resource.indexOf("\\node_modules\\");
+	if (index === -1) index = resource.indexOf("/node_modules/");
+	if (index >= 0) return resource.slice(index + 14);
+	return resource;
+}
+function sourceToIconJsObject$1(svgCode, opt = {}) {
+	const resource = normalizeResource$1(opt.resource || "");
+	if (opt["glyph-name"] || opt.unicode) return glyphToJSON(svgCode, {
+		glyphName: opt["glyph-name"],
+		unicode: opt.unicode
+	}, resource);
+	return svgToJSON(svgCode, resource);
+}
+createRequire(import.meta.url);
+function toGlyphs(svgCode) {
+	const svg = get(svgCode);
+	const glyphs = [];
+	svg.walkAllGlyph((el) => glyphs.push(el));
+	return glyphs;
+}
+function transform(glyphUnicode, svgCode, svgfile) {
+	return sourceToIconJsObject$1(svgCode, {
+		unicode: glyphUnicode,
+		resource: svgfile
+	});
+}
+function charToHexCodeStr(char) {
+	if (/[!#-&(-[\]-_a-~]/u.test(char)) return char;
+	return `\\u${`0000${char.charCodeAt(0).toString(16)}`.slice(-4)}`;
+}
+function toCodeString(code) {
+	let result = "";
+	for (let i = 0; i < code.length; i++) result += charToHexCodeStr(code[i]);
+	return result;
+}
+function buildObjectCode(svgCode, resource, { name = "unicode" } = {}) {
+	let script = "{\n";
+	toGlyphs(svgCode).forEach((glyph) => {
+		const unicode = glyph.getAttribute("unicode") || "";
+		const targetName = glyph.getAttribute(name) || "";
+		script += `
+	'${toCodeString(targetName)}': ${transform(unicode, svgCode, resource).replace(/\r?\n|\r/gu, `
+	`)},`;
+	});
+	script += "\n}";
+	return script;
+}
+function normalizeResource(resource) {
+	let index = resource.indexOf("\\node_modules\\");
+	if (index === -1) index = resource.indexOf("/node_modules/");
+	if (index >= 0) return resource.slice(index + 14);
+	return resource;
+}
+function sourceToIconsJsObject(svgCode, opt = {}) {
+	return buildObjectCode(svgCode, normalizeResource(opt.resource || ""), opt);
+}
+//#endregion
+//#region src/core/transform.ts
+const DEFAULT_QUERY_NAMES = ["cheetah-grid-icon", "cg-icon"];
+const SVG_EXT_RE = /\.svg$/iu;
+function parseId(id) {
+	const queryIndex = id.indexOf("?");
+	if (queryIndex < 0) return {
+		filename: id,
+		query: {}
+	};
+	return {
+		filename: id.slice(0, queryIndex),
+		query: parseQuery(id.slice(queryIndex + 1))
+	};
+}
+function parseQuery(queryText) {
+	const query = {};
+	if (!queryText) return query;
+	queryText.split("&").forEach((part) => {
+		if (!part) return;
+		const equalIndex = part.indexOf("=");
+		const rawKey = equalIndex < 0 ? part : part.slice(0, equalIndex);
+		const rawValue = equalIndex < 0 ? true : part.slice(equalIndex + 1);
+		query[decode(rawKey)] = rawValue === true ? true : decode(rawValue);
+	});
+	return query;
+}
+function decode(value) {
+	try {
+		return decodeURIComponent(value.replace(/\+/gu, " "));
+	} catch (_err) {
+		return value;
+	}
+}
+function normalizeQueryNames(query) {
+	if (query === false) return [];
+	if (query == null) return DEFAULT_QUERY_NAMES;
+	return Array.isArray(query) ? query : [query];
+}
+function hasOwn(object, key) {
+	return Object.prototype.hasOwnProperty.call(object, key);
+}
+function matchesPattern(pattern, value) {
+	if (pattern == null) return false;
+	if (Array.isArray(pattern)) return pattern.some((item) => matchesPattern(item, value));
+	if (pattern instanceof RegExp) {
+		pattern.lastIndex = 0;
+		return pattern.test(value);
+	}
+	if (typeof pattern === "function") return Boolean(pattern(value));
+	return value.indexOf(String(pattern)) >= 0;
+}
+function matchesFilter(pattern, id, filename) {
+	return matchesPattern(pattern, id) || matchesPattern(pattern, filename);
+}
+function hasPluginQuery(query, options = {}) {
+	return normalizeQueryNames(options.query).some((queryName) => hasOwn(query, queryName));
+}
+function shouldTransform(id, options = {}) {
+	const { filename, query } = parseId(id);
+	if (!SVG_EXT_RE.test(filename)) return false;
+	if (matchesFilter(options.exclude, id, filename)) return false;
+	if (hasPluginQuery(query, options)) return true;
+	if (options.include != null) return matchesFilter(options.include, id, filename);
+	return options.query === false;
+}
+function buildParams(id, options = {}) {
+	const { filename, query } = parseId(id);
+	const queryNames = normalizeQueryNames(options.query);
+	const params = { resource: filename };
+	for (const key in query) if (queryNames.indexOf(key) < 0) params[key] = query[key];
+	return params;
+}
+function sourceToIconJsObject(source, id, options = {}) {
+	const params = buildParams(id, options);
+	if (source.indexOf("<font-face") >= 0 && !params["glyph-name"] && !params.unicode) return sourceToIconsJsObject(source, params);
+	return sourceToIconJsObject$1(source, params);
+}
+function transformSvg(source, id, options = {}) {
+	return {
+		code: `export default ${sourceToIconJsObject(source, id, options)};\n`,
+		map: { mappings: "" }
+	};
+}
+//#endregion
+//#region src/index.ts
+const unplugin = createUnplugin((options = {}) => ({
+	name: "unplugin-cheetah-grid-icon-svg",
+	enforce: "pre",
+	transformInclude(id) {
+		return shouldTransform(id, options);
+	},
+	transform(source, id) {
+		if (!shouldTransform(id, options)) return null;
+		return transformSvg(source, id, options);
+	}
+}));
+//#endregion
+export { unplugin as t };

package/dist/vite.cjs

@@ -0,0 +1,4 @@
+//#region src/vite.ts
+var vite_default = require("./src.cjs").unplugin.vite;
+//#endregion
+module.exports = vite_default;

package/dist/vite.d.mts

@@ -0,0 +1,7 @@
+import { r as Options } from "./index.mjs";
+import * as vite0 from "vite";
+
+//#region src/vite.d.ts
+declare const _default: (options?: Options | undefined) => vite0.Plugin<any> | vite0.Plugin<any>[];
+//#endregion
+export { _default as default };

package/dist/vite.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/vite.ts
+var vite_default = unplugin.vite;
+//#endregion
+export { vite_default as default };

package/dist/webpack.cjs

@@ -0,0 +1,4 @@
+//#region src/webpack.ts
+var webpack_default = require("./src.cjs").unplugin.webpack;
+//#endregion
+module.exports = webpack_default;

package/dist/webpack.d.mts

@@ -0,0 +1,6 @@
+import { r as Options } from "./index.mjs";
+
+//#region src/webpack.d.ts
+declare const _default: (options?: Options | undefined) => WebpackPluginInstance;
+//#endregion
+export { _default as default };

package/dist/webpack.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin } from "./src.mjs";
+//#region src/webpack.ts
+var webpack_default = unplugin.webpack;
+//#endregion
+export { webpack_default as default };

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "unplugin-cheetah-grid-icon-svg",
+  "version": "0.0.0",
+  "description": "Unplugin that loads the icon module for Cheetah Grid from SVG.",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.mts",
+      "require": "./dist/vite.cjs",
+      "import": "./dist/vite.mjs"
+    },
+    "./rollup": {
+      "types": "./dist/rollup.d.mts",
+      "require": "./dist/rollup.cjs",
+      "import": "./dist/rollup.mjs"
+    },
+    "./rolldown": {
+      "types": "./dist/rolldown.d.mts",
+      "require": "./dist/rolldown.cjs",
+      "import": "./dist/rolldown.mjs"
+    },
+    "./webpack": {
+      "types": "./dist/webpack.d.mts",
+      "require": "./dist/webpack.cjs",
+      "import": "./dist/webpack.mjs"
+    },
+    "./rspack": {
+      "types": "./dist/rspack.d.mts",
+      "require": "./dist/rspack.cjs",
+      "import": "./dist/rspack.mjs"
+    },
+    "./esbuild": {
+      "types": "./dist/esbuild.d.mts",
+      "require": "./dist/esbuild.cjs",
+      "import": "./dist/esbuild.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "pretest": "npm run lint",
+    "test:base": "vitest run",
+    "test": "npm run build && vitest run --coverage",
+    "test:nyc": "npm run test",
+    "test:d": "vitest --inspect-brk",
+    "watch": "vitest",
+    "build": "npm run build:tsdown",
+    "build:tsdown": "tsdown",
+    "prepack": "npm run build",
+    "lint": "npm run eslint && npm run tsc",
+    "eslint": "eslint . --ext .js,.ts",
+    "eslint:fix": "eslint . --fix --ext .js,.ts",
+    "tsc": "tsc --project ./tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/future-architect/cheetah-grid.git"
+  },
+  "keywords": [
+    "svg",
+    "vite",
+    "rollup",
+    "rolldown",
+    "webpack",
+    "unplugin",
+    "icon",
+    "cheetah-grid"
+  ],
+  "author": {
+    "name": "yosuke ota",
+    "email": "otameshiyo23@gmail.com",
+    "url": "https://www.npmjs.com/~ota-meshi"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/future-architect/cheetah-grid/issues"
+  },
+  "homepage": "https://github.com/future-architect/cheetah-grid/tree/master/packages/unplugin-cheetah-grid-icon-svg",
+  "dependencies": {
+    "@xmldom/xmldom": "^0.9.10",
+    "unplugin": "^2.3.10"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "@typescript-eslint/eslint-plugin": "^4.0.0",
+    "@typescript-eslint/parser": "^4.0.0",
+    "@vitest/coverage-v8": "^4.1.6",
+    "eslint": "^7.11.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "font-awesome": "^4.7.0",
+    "prettier": "^2.5.1",
+    "tsdown": "^0.14.1",
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": "^22.12.0 || ^24.11.0"
+  },
+  "peerDependencies": {
+    "@rspack/core": ">=0.5.0",
+    "esbuild": ">=0.14.0",
+    "rolldown": ">=1.0.0-beta.0",
+    "rollup": ">=2.0.0",
+    "vite": ">=2.0.0",
+    "webpack": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "rolldown": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "@rspack/core": {
+      "optional": true
+    }
+  }
+}