@menapo/icons 0.0.0-stage → 0.1.0

package/dist/vite.js

@@ -0,0 +1,2624 @@
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSync } from "vite";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+//#region ../glue/src/detect.ts
+/**
+* Which framework a module renders with (machine PLAN §5.5), the way vicss
+* decides it: `.vue` and `.svelte` (with `.svelte.js`/`.svelte.ts` rune
+* modules) by extension; JSX by its `@jsxImportSource` pragma, else the
+* project's JSX framework ({@link jsxFrameworkOf}); plain scripts by the
+* plugin's `framework` option, else the framework the root `package.json`
+* depends on, else none (vanilla). Plain data in and out, so it is
+* unit-tested without Vite.
+*
+* vi18n has a detection of its own (its `vite/glue/detect.ts`, by plugin
+* names); it is published, so moving it onto this module waits for its
+* next minor (machine PLAN §11).
+*/
+/** Root dependencies that name a project's framework, the first found winning. */
+const DEPENDENCIES = [
+	["vue", "vue"],
+	["svelte", "svelte"],
+	["solid-js", "solid"],
+	["preact", "preact"],
+	["react", "react"]
+];
+/** `preact`, `solid-js` and `vue` (and their subpaths) by name; any other JSX source takes React's. */
+function jsxFramework(source) {
+	const name = source.split("/")[0];
+	if (name === "preact") return "preact";
+	if (name === "solid-js") return "solid";
+	if (name === "vue") return "vue";
+	return "react";
+}
+/** The framework of module `id` with source `code`. */
+function frameworkOf(id, code, settings) {
+	const file = id.replace(/[?#].*$/, "").toLowerCase();
+	if (file.endsWith(".vue")) return "vue";
+	if (file.endsWith(".svelte") || /\.svelte\.[cm]?[jt]s$/.test(file)) return "svelte";
+	if (/\.[jt]sx$/.test(file)) {
+		const pragma = /@jsxImportSource\s+([^\s*]+)/.exec(code)?.[1];
+		return pragma ? jsxFramework(pragma) : settings.jsx;
+	}
+	return settings.scripts;
+}
+/** The names a `package.json` depends on, if it can be read. */
+function dependencies(root) {
+	const file = join(root, "package.json");
+	if (!existsSync(file)) return void 0;
+	try {
+		const pkg = JSON.parse(readFileSync(file, "utf8"));
+		return /* @__PURE__ */ new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
+	} catch {
+		return;
+	}
+}
+/** The framework the `package.json` in `root` depends on, if a known one. */
+function rootFramework(root) {
+	const names = dependencies(root);
+	return names && DEPENDENCIES.find(([name]) => names.has(name))?.[1];
+}
+/**
+* JSX frameworks by the names of the Vite plugins that compile them, as
+* vi18n recognises them: a prefix up to a separator, or the exact name.
+*/
+const JSX_PLUGINS = [
+	["react", /^(?:vite:react|@vitejs\/plugin-react)(?:[:/-]|$)/],
+	["preact", /^(?:preact:|vite:preact(?:[:/-]|$)|@preact\/|prefresh(?:[:/-]|$)|preact$)/],
+	["solid", /^(?:solid:|vite-plugin-solid(?:[:/-]|$)|solid-start(?:[:/-]|$)|solid$)/],
+	["vue", /^(?:vite:vue-jsx|@vitejs\/plugin-vue-jsx)(?:[:/-]|$)/]
+];
+/** The one JSX framework whose Vite plugin is in `plugins`; none when there are none or several. */
+function pluginFramework(plugins) {
+	const found = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		const name = plugin?.name;
+		if (typeof name !== "string") continue;
+		for (const [framework, pattern] of JSX_PLUGINS) if (pattern.test(name)) found.add(framework);
+	}
+	return found.size === 1 ? [...found][0] : void 0;
+}
+/** tsconfig's JSON with comments and trailing commas, as TypeScript reads it. */
+function parseJsonc(text) {
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (c === "\"") {
+			const end = /"(?:[^"\\]|\\.)*"/y;
+			end.lastIndex = i;
+			const string = end.exec(text)?.[0] ?? c;
+			out += string;
+			i += string.length - 1;
+		} else if (c === "/" && text[i + 1] === "/") {
+			while (i < text.length && text[i] !== "\n") i++;
+			out += "\n";
+		} else if (c === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end < 0 ? text.length : end + 1;
+		} else out += c;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+/** A tsconfig named by `extends` or a reference: a file, a directory's `tsconfig.json`, or a package's. */
+function tsconfigPath(from, name) {
+	const local = name.startsWith(".") || name.startsWith("/");
+	let path;
+	try {
+		path = local ? resolve(dirname(from), name) : createRequire(from).resolve(name);
+	} catch {
+		return;
+	}
+	if (existsSync(path) && statSync(path).isDirectory()) path = join(path, "tsconfig.json");
+	else if (!existsSync(path) && existsSync(`${path}.json`)) path = `${path}.json`;
+	return existsSync(path) ? path : void 0;
+}
+/**
+* `compilerOptions.jsxImportSource` as TypeScript resolves it for `file`:
+* its own, else its `extends`' (the last one first); then, for a solution
+* file (`references`, as create-vite writes), the first referenced project
+* that sets one.
+*/
+function tsconfigJsxSource(file, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(file) || !existsSync(file)) return void 0;
+	seen.add(file);
+	let config;
+	try {
+		config = parseJsonc(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+	const own = config.compilerOptions?.jsxImportSource;
+	if (typeof own === "string") return own;
+	const bases = typeof config.extends === "string" ? [config.extends] : config.extends ?? [];
+	for (const base of [...bases].reverse()) {
+		const path = tsconfigPath(file, base);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+	for (const reference of config.references ?? []) {
+		const path = tsconfigPath(file, reference.path);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+}
+/**
+* The framework of JSX without a pragma: the JSX import source the Vite
+* config gives Oxc or esbuild; else the one JSX framework whose Vite plugin
+* is installed (`vite-plugin-solid`, the Preact preset); else the root
+* tsconfig's `jsxImportSource`, through `extends` and `references`; else
+* Preact, Solid or Vue when the root `package.json` depends on it; else React.
+*/
+function jsxFrameworkOf(config, root) {
+	const oxc = config.oxc;
+	const esbuild = config.esbuild;
+	const fromVite = (oxc && oxc.jsx?.importSource) ?? (esbuild && esbuild.jsxImportSource);
+	if (typeof fromVite === "string") return jsxFramework(fromVite);
+	const plugin = pluginFramework(config.plugins ?? []);
+	if (plugin) return plugin;
+	const fromTsconfig = tsconfigJsxSource(join(root, "tsconfig.json"));
+	if (fromTsconfig) return jsxFramework(fromTsconfig);
+	const names = dependencies(root);
+	if (names?.has("preact")) return "preact";
+	if (names?.has("solid-js")) return "solid";
+	if (names?.has("vue") && !names.has("react")) return "vue";
+	return "react";
+}
+//#endregion
+//#region ../glue/src/vite.ts
+/**
+* The build side of the shared glue (machine PLAN §5.1, §5.5): a Vite
+* plugin that resolves a package's hooks (`useMachine` from
+* `@menapo/machine`) per module to that module's framework, so one import
+* works in React, Preact, Vue, Svelte, Solid and plain scripts, and no
+* package has a `/react` or `/vue` entry (repo rule: entries by role).
+*
+* - **Per module:** each module importing a hook gets the hook from
+*   `virtual:<package>/glue/<framework>`, which resolves to the package's
+*   glue module for that framework; the rest of the import stays. Every
+*   form that reaches a hook is rewritten: named imports (string names
+*   too), a namespace import's members, re-exports, `export *` and
+*   `import()`.
+* - **The app's framework:** a glue module and the adapters it uses import
+*   `react`, `vue`… by name. Those imports resolve from the project root, as
+*   the app's own do, so the app's single copy is used wherever the glue
+*   module lives (a workspace package, `node_modules`); one that does not
+*   resolve there fails the build, naming the fix.
+*/
+/**
+* A path as Vite writes ids, with forward slashes on every platform:
+* `fileURLToPath` gives backslashes on Windows, and a prefix test of one
+* against the other never matches.
+*/
+const posix = (path) => path.replace(/\\/g, "/");
+/** Whether `id` is inside one of `dirs`, both compared as Vite writes them. */
+const within = (dirs, id) => dirs.some((dir) => posix(id).startsWith(posix(dir)));
+dirname(fileURLToPath(import.meta.url));
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$1 = /* @__PURE__ */ new Uint8Array(64);
+var charToInt = /* @__PURE__ */ new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar$1[i] = c;
+	charToInt[c] = i;
+}
+function encodeInteger(builder, num) {
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		builder.write(intToChar$1[clamped]);
+	} while (num > 0);
+}
+function encodeSign(num) {
+	return num < 0 ? -num << 1 | 1 : num << 1;
+}
+var bufLength = 16384;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+function encodeRangeMappings(decoded) {
+	if (decoded.length === 0) return "";
+	const writer = new StringWriter();
+	for (let i = 0; i < decoded.length; i++) {
+		const indices = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		let index = 0;
+		for (let j = 0; j < indices.length; j++) {
+			const offset = indices[j];
+			encodeInteger(writer, offset - index);
+			index = offset;
+		}
+	}
+	return writer.flush();
+}
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			encodeInteger(writer, encodeSign(segment[0] - genColumn));
+			genColumn = segment[0];
+			if (segment.length === 1) continue;
+			encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+			encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+			encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+			sourcesIndex = segment[1];
+			sourceLine = segment[2];
+			sourceColumn = segment[3];
+			if (segment.length === 4) continue;
+			encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+			namesIndex = segment[4];
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/magic-string@1.4.3/node_modules/magic-string/dist/index.mjs
+var BitSet = class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+	has(n) {
+		return !!(this.bits[n >> 5] & 1 << (n & 31));
+	}
+};
+var Chunk = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+		this.intro = "";
+		this.outro = "";
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+		this.previous = null;
+		this.next = null;
+	}
+	appendLeft(content) {
+		this.outro += content;
+	}
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+		return chunk;
+	}
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+	eachNext(fn) {
+		fn(this);
+		let chunk = this.next;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+	eachPrevious(fn) {
+		fn(this);
+		let chunk = this.previous;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = "";
+			this.outro = "";
+		}
+		this.storeName = storeName;
+		this.edited = true;
+		return this;
+	}
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+	reset() {
+		this.intro = "";
+		this.outro = "";
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+	split(index) {
+		const sliceIndex = index - this.start;
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+		this.original = originalBefore;
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = "";
+		this.end = index;
+		if (this.edited) {
+			newChunk.edit("", false, true);
+			this.content = "";
+		} else this.content = originalBefore;
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+		return newChunk;
+	}
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else this.split(this.start + trimmed.length).edit("", void 0, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.intro = this.intro.replace(rx, "");
+			if (this.intro.length) return true;
+		}
+	}
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else {
+					this.split(this.end - trimmed.length);
+					this.edit("", void 0, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.outro = this.outro.replace(rx, "");
+			if (this.outro.length) return true;
+		}
+	}
+};
+/**
+* The single error type thrown by MagicString.
+*
+* Every message is prefixed with `[MagicString]` so its source is obvious at a
+* glance, and is kept short and consistent in tone.
+*/
+var MagicStringError = class extends Error {
+	name = "MagicStringError";
+	constructor(message, options) {
+		super(`[MagicString] ${message}`, options);
+	}
+};
+function getBtoa() {
+	/* v8 ignore next -- environment fallback, unreachable when `btoa` is present */
+	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	const buffer = globalThis["Buffer"];
+	if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
+	return () => {
+		throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
+	};
+	/* v8 ignore stop */
+}
+const btoa = /* #__PURE__ */ getBtoa();
+var SourceMap = class {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = typeof properties.mappings === "string" ? properties.mappings : encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
+		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+		if (typeof properties.rangeMappings !== "undefined") {
+			let shouldOutputRangeMapping = false;
+			for (const line of properties.rangeMappings) if (line.length !== 0) {
+				shouldOutputRangeMapping = true;
+				break;
+			}
+			if (shouldOutputRangeMapping) this.rangeMappings = encodeRangeMappings(properties.rangeMappings);
+		}
+	}
+	/**
+	* Returns the equivalent of `JSON.stringify(map)`
+	*/
+	toString() {
+		return JSON.stringify(this);
+	}
+	/**
+	* Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+	* `generateMap(options?: SourceMapOptions): SourceMap;`
+	*/
+	toUrl() {
+		return `data:application/json;charset=utf-8;base64,${btoa(this.toString())}`;
+	}
+};
+function getLocator(source) {
+	const lineOffsets = [0];
+	for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) lineOffsets.push(i + 1);
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
+}
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+	fromParts.pop();
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = "..";
+	}
+	return fromParts.concat(toParts).join("/");
+}
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return " ".repeat(min);
+}
+const toString = Object.prototype.toString;
+function isObject(thing) {
+	return toString.call(thing) === "[object Object]";
+}
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = /* #__PURE__ */ (() => {
+	const chars = /* @__PURE__ */ new Uint8Array(64);
+	for (let i = 0; i < 64; i++) chars[i] = BASE64_CHARS.charCodeAt(i);
+	return chars;
+})();
+const COMMA = 44;
+const SEMICOLON = 59;
+const BUFFER_SIZE = 16384;
+const FLUSH_THRESHOLD = 16348;
+const scratch = /* #__PURE__ */ new Uint8Array(BUFFER_SIZE);
+function writeVlq(pos, num) {
+	num = num < 0 ? -num << 1 | 1 : num << 1;
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		scratch[pos++] = intToChar[clamped];
+	} while (num > 0);
+	return pos;
+}
+const decoder = /* #__PURE__ */ new TextDecoder();
+var MappingsEncoder = class {
+	constructor() {
+		this.out = "";
+		this.pos = 0;
+		this.lines = [];
+		this.buffered = 0;
+		this.needsComma = false;
+		this.prevGenColumn = 0;
+		this.prevSourceIndex = 0;
+		this.prevSourceLine = 0;
+		this.prevSourceColumn = 0;
+		this.prevNameIndex = 0;
+	}
+	endLine(segments) {
+		this.lines.push(segments);
+		this.buffered += segments.length + 1;
+		if (this.buffered >= 4096) this.drain(null);
+	}
+	segments(segments) {
+		this.drain(segments);
+	}
+	finish(segments) {
+		this.drain(segments);
+		this.flush();
+		return this.out;
+	}
+	drain(trailing) {
+		const lines = this.lines;
+		const lineCount = lines.length;
+		for (let l = 0; l <= lineCount; l++) {
+			const line = l < lineCount ? lines[l] : trailing;
+			if (line === null) break;
+			for (let i = 0; i < line.length; i++) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				const segment = line[i];
+				if (this.needsComma) scratch[this.pos++] = COMMA;
+				this.needsComma = true;
+				this.pos = writeVlq(this.pos, segment[0] - this.prevGenColumn);
+				this.prevGenColumn = segment[0];
+				this.pos = writeVlq(this.pos, segment[1] - this.prevSourceIndex);
+				this.prevSourceIndex = segment[1];
+				this.pos = writeVlq(this.pos, segment[2] - this.prevSourceLine);
+				this.prevSourceLine = segment[2];
+				this.pos = writeVlq(this.pos, segment[3] - this.prevSourceColumn);
+				this.prevSourceColumn = segment[3];
+				if (segment.length === 5) {
+					this.pos = writeVlq(this.pos, segment[4] - this.prevNameIndex);
+					this.prevNameIndex = segment[4];
+				}
+			}
+			if (l < lineCount) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				scratch[this.pos++] = SEMICOLON;
+				this.needsComma = false;
+				this.prevGenColumn = 0;
+			}
+		}
+		lines.length = 0;
+		this.buffered = 0;
+		this.flush();
+	}
+	flush() {
+		this.out += decoder.decode(scratch.subarray(0, this.pos));
+		this.pos = 0;
+	}
+};
+const NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
+var Mappings = class {
+	constructor(hires, encoder = null) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.rawRangeMappings = [];
+		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+		this.encoder = encoder;
+	}
+	nextLine() {
+		if (this.encoder === null) {
+			this.generatedCodeLine += 1;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+		} else {
+			this.encoder.endLine(this.rawSegments);
+			this.rawSegments = [];
+			this.generatedCodeLine += 1;
+		}
+		this.generatedCodeColumn = 0;
+		this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+	}
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf("\n", 0);
+			let previousContentLineEnd = -1;
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				];
+				if (nameIndex >= 0) segment.push(nameIndex);
+				this.rawSegments.push(segment);
+				this.nextLine();
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+			}
+			const segment = [
+				this.generatedCodeColumn,
+				sourceIndex,
+				loc.line,
+				loc.column
+			];
+			if (nameIndex >= 0) segment.push(nameIndex);
+			this.rawSegments.push(segment);
+			this.advance(content.slice(previousContentLineEnd + 1));
+		}
+	}
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		const end = chunk.end;
+		let i = chunk.start;
+		if (this.hires) {
+			const boundary = this.hires === "boundary";
+			const experimentalRange = this.hires === "experimental-range";
+			const encoder = experimentalRange ? null : this.encoder;
+			let charInHiresBoundary = false;
+			while (i < end) {
+				if (encoder !== null && this.rawSegments.length >= 4096) {
+					encoder.segments(this.rawSegments);
+					this.rawSegments.length = 0;
+				}
+				if (experimentalRange && i + 1 >= end) this.rawSegments.push([
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				]);
+				const code = original.charCodeAt(i);
+				if (code === NEWLINE_CHAR$1) {
+					loc.line += 1;
+					loc.column = 0;
+					this.nextLine();
+					charInHiresBoundary = false;
+				} else {
+					if (boundary) {
+						if (isWordCode(code)) {
+							if (!charInHiresBoundary) {
+								this.rawSegments.push([
+									this.generatedCodeColumn,
+									sourceIndex,
+									loc.line,
+									loc.column
+								]);
+								charInHiresBoundary = true;
+							}
+						} else {
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+							charInHiresBoundary = false;
+						}
+					} else if (experimentalRange) {
+						if (i === chunk.start) {
+							this.rawRangeMappingsIndices.push(this.rawSegments.length);
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+						}
+					} else this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					loc.column += 1;
+					this.generatedCodeColumn += 1;
+				}
+				i += 1;
+			}
+		} else {
+			const bits = sourcemapLocations.bits;
+			while (i < end) {
+				let newline = original.indexOf("\n", i);
+				if (newline === -1 || newline > end) newline = end;
+				if (newline > i) {
+					this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					for (let w = i + 1 >> 5, last = newline - 1 >> 5; w <= last; w++) {
+						let word = bits[w];
+						if (!word) continue;
+						const base = w << 5;
+						while (word) {
+							const lowest = word & -word;
+							const index = base + 31 - Math.clz32(lowest);
+							if (index > i && index < newline) {
+								const offset = index - i;
+								this.rawSegments.push([
+									this.generatedCodeColumn + offset,
+									sourceIndex,
+									loc.line,
+									loc.column + offset
+								]);
+							}
+							word ^= lowest;
+						}
+					}
+					loc.column += newline - i;
+					this.generatedCodeColumn += newline - i;
+				}
+				if (newline === end) break;
+				loc.line += 1;
+				loc.column = 0;
+				this.nextLine();
+				i = newline + 1;
+			}
+		}
+	}
+	advance(str) {
+		if (!str) return;
+		const lastNewline = str.lastIndexOf("\n");
+		for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) this.nextLine();
+		this.generatedCodeColumn += str.length - lastNewline - 1;
+	}
+};
+const n = "\n";
+const NEWLINE_CHAR = "\n".charCodeAt(0);
+const CR_CHAR = "\r".charCodeAt(0);
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false
+};
+/**
+* Expands the `$` substitution patterns that `String.prototype.replace` accepts
+* in a string replacement.
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+*
+* `captures` holds the capture groups in order, so `captures[0]` is `$1`.
+* `namedCaptures` is `undefined` when the pattern has no named groups, and
+* `$<name>` is then literal text - which is also the case for a string search
+* value, where there are no groups of either kind.
+*/
+function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
+	if (!replacement.includes("$")) return replacement;
+	let result = "";
+	let index = 0;
+	while (index < replacement.length) {
+		const dollar = replacement.indexOf("$", index);
+		if (dollar === -1) {
+			result += replacement.slice(index);
+			break;
+		}
+		result += replacement.slice(index, dollar);
+		const char = replacement[dollar + 1];
+		let expansion = "$";
+		let consumed = 1;
+		if (char === "$") consumed = 2;
+		else if (char === "&") {
+			expansion = matched;
+			consumed = 2;
+		} else if (char === "`") {
+			expansion = str.slice(0, position);
+			consumed = 2;
+		} else if (char === "'") {
+			expansion = str.slice(position + matched.length);
+			consumed = 2;
+		} else if (char === "<" && namedCaptures !== void 0) {
+			const close = replacement.indexOf(">", dollar + 2);
+			if (close !== -1) {
+				expansion = namedCaptures[replacement.slice(dollar + 2, close)] ?? "";
+				consumed = close + 1 - dollar;
+			}
+		} else if (char >= "0" && char <= "9") {
+			const second = replacement[dollar + 2];
+			const double = second >= "0" && second <= "9" ? Number(char + second) : NaN;
+			const single = Number(char);
+			if (double >= 1 && double <= captures.length) {
+				expansion = captures[double - 1] ?? "";
+				consumed = 3;
+			} else if (single >= 1 && single <= captures.length) {
+				expansion = captures[single - 1] ?? "";
+				consumed = 2;
+			}
+		}
+		result += expansion;
+		index = dollar + consumed;
+	}
+	return result;
+}
+var MagicString = class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+		Object.defineProperties(this, {
+			original: {
+				writable: true,
+				value: string
+			},
+			outro: {
+				writable: true,
+				value: ""
+			},
+			intro: {
+				writable: true,
+				value: ""
+			},
+			firstChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastSearchedChunk: {
+				writable: true,
+				value: chunk
+			},
+			byStart: {
+				writable: true,
+				value: /* @__PURE__ */ new Map([[0, chunk]])
+			},
+			byEnd: {
+				writable: true,
+				value: /* @__PURE__ */ new Map([[string.length, chunk]])
+			},
+			filename: {
+				writable: true,
+				value: options.filename
+			},
+			indentExclusionRanges: {
+				writable: true,
+				value: options.indentExclusionRanges
+			},
+			sourcemapLocations: {
+				writable: true,
+				value: new BitSet()
+			},
+			storedNames: {
+				writable: true,
+				value: {}
+			},
+			indentStr: {
+				writable: true,
+				value: void 0
+			},
+			ignoreList: {
+				writable: true,
+				value: options.ignoreList
+			},
+			offset: {
+				writable: true,
+				value: options.offset || 0
+			},
+			hasMovedChunks: {
+				writable: true,
+				value: false
+			}
+		});
+	}
+	/**
+	* Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+	*/
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+	/**
+	* Appends the specified content to the end of the string.
+	*/
+	append(content) {
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this.outro += content;
+		return this;
+	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *ending* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependLeft(...)`.
+	*/
+	appendLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byEnd.get(index);
+		if (chunk) chunk.appendLeft(content);
+		else this.intro += content;
+		return this;
+	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *starting* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependRight(...)`.
+	*/
+	appendRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byStart.get(index);
+		if (chunk) chunk.appendRight(content);
+		else this.outro += content;
+		return this;
+	}
+	/**
+	* Does what you'd expect.
+	*/
+	clone() {
+		const cloned = new MagicString(this.original, {
+			filename: this.filename,
+			ignoreList: this.ignoreList,
+			offset: this.offset
+		});
+		let originalChunk = this.firstChunk;
+		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+		while (originalChunk) {
+			cloned.byStart.set(clonedChunk.start, clonedChunk);
+			cloned.byEnd.set(clonedChunk.end, clonedChunk);
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+				clonedChunk = nextClonedChunk;
+			}
+			originalChunk = nextOriginalChunk;
+		}
+		cloned.lastChunk = clonedChunk;
+		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.storedNames = { ...this.storedNames };
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+		cloned.hasMovedChunks = this.hasMovedChunks;
+		return cloned;
+	}
+	/**
+	* Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+	* Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+	*/
+	generateDecodedMap(options) {
+		options = options || {};
+		const mappings = new Mappings(options.hires);
+		const names = this._generateMappings(mappings);
+		return {
+			...this._mapProperties(options, names),
+			mappings: mappings.raw,
+			rangeMappings: mappings.rawRangeMappings
+		};
+	}
+	/**
+	* Generates a version 3 sourcemap.
+	*/
+	generateMap(options) {
+		options = options || {};
+		const encoder = new MappingsEncoder();
+		const mappings = new Mappings(options.hires, encoder);
+		const names = this._generateMappings(mappings);
+		return new SourceMap({
+			...this._mapProperties(options, names),
+			mappings: encoder.finish(mappings.rawSegments),
+			rangeMappings: mappings.rawRangeMappings
+		});
+	}
+	/** @internal */
+	_generateMappings(mappings) {
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const locate = getLocator(this.original);
+		if (this.intro) mappings.advance(this.intro);
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+		if (this.outro) mappings.advance(this.outro);
+		return names;
+	}
+	/** @internal */
+	_mapProperties(options, names) {
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
+			sourcesContent: options.includeContent ? [this.original] : void 0,
+			names,
+			x_google_ignoreList: this.ignoreList ? [0] : void 0
+		};
+	}
+	/** @internal */
+	_ensureindentStr() {
+		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
+	}
+	/** @internal */
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? "	" : this.indentStr;
+	}
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = void 0;
+		}
+		if (indentStr === void 0) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || "	";
+		}
+		if (indentStr === "") return this;
+		const resolvedIndentStr = indentStr;
+		options = options || {};
+		const isExcluded = {};
+		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+		});
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const indentPiece = (str) => {
+			if (str === "") return str;
+			const indented = str.replace(pattern, (match, offset) => offset > 0 || shouldIndentNextCharacter ? `${resolvedIndentStr}${match}` : match);
+			shouldIndentNextCharacter = str[str.length - 1] === "\n";
+			return indented;
+		};
+		this.intro = indentPiece(this.intro);
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+		const indentAt = (index) => {
+			shouldIndentNextCharacter = false;
+			if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
+			else {
+				this._splitChunk(chunk, index);
+				chunk = chunk.next;
+				chunk.prependRight(resolvedIndentStr);
+			}
+		};
+		while (chunk) {
+			const end = chunk.end;
+			if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
+			} else if (options.exclude) {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original.charCodeAt(charIndex);
+						if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
+						else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
+					}
+					charIndex += 1;
+				}
+			} else {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!shouldIndentNextCharacter) {
+						const nextLine = this.original.indexOf(n, charIndex);
+						if (nextLine === -1 || nextLine >= end) break;
+						shouldIndentNextCharacter = true;
+						charIndex = nextLine + 1;
+						continue;
+					}
+					const char = this.original.charCodeAt(charIndex);
+					if (char === NEWLINE_CHAR || char === CR_CHAR) {
+						charIndex += 1;
+						continue;
+					}
+					indentAt(charIndex);
+					charIndex += 1;
+				}
+			}
+			if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+		this.outro = indentPiece(this.outro);
+		return this;
+	}
+	/** @internal */
+	insert() {
+		throw new MagicStringError("insert() is deprecated, use appendLeft() or prependRight()");
+	}
+	/** @internal */
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+			warned.insertLeft = true;
+		}
+		return this.appendLeft(index, content);
+	}
+	/** @internal */
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+			warned.insertRight = true;
+		}
+		return this.prependRight(index, content);
+	}
+	/**
+	* Moves the characters from `start` and `end` to `index`.
+	*
+	* `affinity` controls where the range is anchored at `index`. With the
+	* default `'right'`, it is inserted before the content that starts at `index`;
+	* with `'left'`, it is inserted after the content that ends at `index`. The
+	* two differ only when other content has already been moved to that boundary,
+	* mirroring the `appendLeft`/`appendRight` distinction.
+	*/
+	move(start, end, index, affinity = "right") {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+		if (start === end) return this;
+		if (index >= start && index <= end) throw new MagicStringError("cannot move a selection inside itself");
+		this._split(start);
+		this._split(end);
+		this._split(index);
+		const first = this.byStart.get(start);
+		const last = this.byEnd.get(end);
+		if (this.hasMovedChunks) {
+			let cursor = first;
+			while (cursor !== last) {
+				cursor = cursor.next;
+				if (!cursor || cursor.start < start || cursor.end > end) throw new MagicStringError(`cannot move ${start} to ${end} because an earlier move split that range`);
+			}
+		}
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+		let newLeft;
+		let newRight;
+		if (affinity === "left") {
+			newLeft = this.byEnd.get(index) ?? null;
+			if (!newLeft) {
+				if (first === this.firstChunk) return this;
+				newRight = this.firstChunk;
+			} else {
+				if (newLeft.next === first) return this;
+				newRight = newLeft.next;
+			}
+		} else {
+			newRight = this.byStart.get(index) ?? null;
+			if (!newRight) {
+				if (last === this.lastChunk) return this;
+				newLeft = this.lastChunk;
+			} else {
+				if (newRight.previous === last) return this;
+				newLeft = newRight.previous;
+			}
+		}
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+		first.previous = newLeft;
+		last.next = newRight || null;
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		this.hasMovedChunks = true;
+		return this;
+	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+	* that range. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and a contentOnly property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*
+	* It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+	*/
+	overwrite(start, end, content, options) {
+		const optionObject = typeof options === "object" && options ? options : {};
+		return this.update(start, end, content, {
+			...optionObject,
+			overwrite: !optionObject.contentOnly
+		});
+	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and an overwrite property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*/
+	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start < 0) throw new MagicStringError(`start ${start} is out of bounds`);
+		if (end > this.original.length) throw new MagicStringError(`end ${end} is out of bounds`);
+		if (start === end) throw new MagicStringError(`cannot overwrite a zero-length range at ${start}, use appendLeft() or prependRight()`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+				warned.storeName = true;
+			}
+			options = { storeName: true };
+		}
+		const optionObject = typeof options === "object" && options ? options : {};
+		const storeName = optionObject.storeName || false;
+		const overwrite = optionObject.overwrite || false;
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true
+			});
+		}
+		const first = this.byStart.get(start);
+		const last = this.byEnd.get(end);
+		/* v8 ignore else -- unreachable: a valid start/end always yields a `first` chunk */
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
+				chunk = chunk.next;
+				chunk.edit("", false, !overwrite);
+			}
+			first.edit(content, storeName, !overwrite);
+		} else {
+			const newChunk = new Chunk(start, end, "").edit(content, storeName);
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+	/**
+	* Prepends the string with the specified content.
+	*/
+	prepend(content) {
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this.intro = content + this.intro;
+		return this;
+	}
+	/**
+	* Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+	*/
+	prependLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byEnd.get(index);
+		if (chunk) chunk.prependLeft(content);
+		else this.intro = content + this.intro;
+		return this;
+	}
+	/**
+	* Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+	*/
+	prependRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byStart.get(index);
+		if (chunk) chunk.prependRight(content);
+		else this.outro = content + this.outro;
+		return this;
+	}
+	/**
+	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Content appended or prepended at positions strictly inside the range is removed with it, while
+	* content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
+	* the range including its edge inserts.
+	* Repeated removals and removals with partially overlapping ranges are allowed.
+	*/
+	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart.get(start);
+		while (chunk) {
+			if (chunk.start > start) chunk.intro = "";
+			if (chunk.end < end) chunk.outro = "";
+			chunk.edit("", false, true);
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+		}
+		return this;
+	}
+	/**
+	* Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+	*/
+	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart.get(start);
+		while (chunk) {
+			chunk.reset();
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+		}
+		return this;
+	}
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		while (chunk) {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+			chunk = chunk.previous;
+		}
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return "";
+	}
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		while (chunk) {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+			chunk = chunk.previous;
+		}
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+	/**
+	* Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+	* Throws error if the indices are for characters that were already removed.
+	*/
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		let result = "";
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
+			chunk = chunk.next;
+		}
+		if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
+		const startChunk = chunk;
+		while (chunk) {
+			if (end === 0 && chunk.start === 0) break;
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new MagicStringError(`cannot use edited character ${end} as slice end anchor`);
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+			result += chunk.content.slice(sliceStart, sliceEnd);
+			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
+			if (containsEnd) break;
+			chunk = chunk.next;
+		}
+		return result;
+	}
+	/**
+	* Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+	*/
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+		return clone;
+	}
+	/** @internal */
+	_split(index) {
+		if (this.byStart.get(index) || this.byEnd.get(index)) return;
+		let chunk = this.lastSearchedChunk;
+		let previousChunk = chunk;
+		const searchForward = index > chunk.end;
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+			chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+			if (chunk === previousChunk) return;
+			previousChunk = chunk;
+		}
+	}
+	/** @internal */
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			const loc = getLocator(this.original)(index);
+			throw new MagicStringError(`cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+		}
+		const newChunk = chunk.split(index);
+		this.byEnd.set(index, chunk);
+		this.byStart.set(index, newChunk);
+		this.byEnd.set(newChunk.end, newChunk);
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+	/**
+	* Returns the generated string.
+	*/
+	toString() {
+		let str = this.intro;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+		return str + this.outro;
+	}
+	/**
+	* Returns true if the resulting source is empty (disregarding white space).
+	*/
+	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+			chunk = chunk.next;
+		}
+		if (this.outro.length && this.outro.trim()) return false;
+		return true;
+	}
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		while (chunk) {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+			chunk = chunk.next;
+		}
+		return length;
+	}
+	/**
+	* Removes empty lines from the start and end.
+	*/
+	trimLines() {
+		return this.trim("[\\r\\n]");
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+	*/
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+	/** @internal */
+	trimEndAborted(charType) {
+		const rx = new RegExp(`${charType || "\\s"}+$`);
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		let chunk = this.lastChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
+			}
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+		this.intro = this.intro.replace(rx, "");
+		return this.intro.length > 0;
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+	*/
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	/** @internal */
+	trimStartAborted(charType) {
+		const rx = new RegExp(`^${charType || "\\s"}+`);
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		let chunk = this.firstChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+			if (chunk.end !== end) {
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
+			}
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+		this.outro = this.outro.replace(rx, "");
+		return this.outro.length > 0;
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+	*/
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+	/**
+	* Indicates if the string has been changed.
+	*/
+	hasChanged() {
+		if (this.intro || this.outro) return true;
+		let outputIndex = 0;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.intro || chunk.outro) return true;
+			if (!chunk.edited && chunk.start === outputIndex) outputIndex = chunk.end;
+			else {
+				if (!this.original.startsWith(chunk.content, outputIndex)) return true;
+				outputIndex += chunk.content.length;
+			}
+			chunk = chunk.next;
+		}
+		return outputIndex !== this.original.length;
+	}
+	/**
+	* Whether the original range [start, end) has had any of its characters
+	* removed. `replace`/`replaceAll` search `original`, so a match can land on
+	* text that is no longer in the output - overwriting it would resurrect the
+	* removed characters, so such matches are skipped instead.
+	*
+	* @internal
+	*/
+	_hasRemovedContent(start, end) {
+		let chunk = this.byStart.get(start);
+		if (!chunk) {
+			chunk = this.lastSearchedChunk;
+			const searchForward = start >= chunk.end;
+			while (chunk && !chunk.contains(start)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+			if (chunk) this.lastSearchedChunk = chunk;
+		}
+		while (chunk && chunk.start < end) {
+			if (chunk.content === "") return true;
+			chunk = this.byStart.get(chunk.end);
+		}
+		return false;
+	}
+	/** @internal */
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === "string") return expandReplacement(replacement, match[0], match.index, str, match.slice(1), match.groups);
+			else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), match.index, str) : replacement(match[0], ...match.slice(1), match.index, str, match.groups);
+		}
+		const replaceMatch = (match) => {
+			/* v8 ignore next 2 -- `match.index` is always defined for matches from `matchAll` */
+			if (match.index == null) return false;
+			if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
+			const replacement = getReplacement(match, this.original);
+			if (replacement === match[0]) return true;
+			if (match[0].length === 0) this.appendRight(match.index - this.offset, replacement);
+			else this.overwrite(match.index - this.offset, match.index + match[0].length - this.offset, replacement);
+			return true;
+		};
+		if (searchValue.global) {
+			searchValue.lastIndex = 0;
+			for (const match of this.original.matchAll(searchValue)) replaceMatch(match);
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && !replaceMatch(match)) {
+				const global = new RegExp(searchValue.source, `${searchValue.flags}g`);
+				for (const next of this.original.matchAll(global)) if (replaceMatch(next)) break;
+			}
+		}
+		return this;
+	}
+	/** @internal */
+	_replaceString(string, replacement) {
+		const { original } = this;
+		let index = original.indexOf(string);
+		while (index !== -1) {
+			if (this._hasRemovedContent(index, index + string.length)) {
+				index = original.indexOf(string, index + string.length);
+				continue;
+			}
+			if (typeof replacement === "function") replacement = replacement(string, index, original);
+			else replacement = expandReplacement(replacement, string, index, original, [], void 0);
+			if (string !== replacement) {
+				if (string.length === 0) this.appendRight(index - this.offset, replacement);
+				else this.overwrite(index - this.offset, index + string.length - this.offset, replacement);
+			}
+			break;
+		}
+		return this;
+	}
+	/**
+	* String replacement with RegExp or string.
+	*/
+	replace(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
+		return this._replaceRegexp(searchValue, replacement);
+	}
+	/** @internal */
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		if (stringLength === 0) {
+			for (let index = 0; index <= original.length; index += 1) {
+				if (this._hasRemovedContent(index, index)) continue;
+				const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
+				if (_replacement !== "") this.appendRight(index - this.offset, _replacement);
+			}
+			return this;
+		}
+		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			if (this._hasRemovedContent(index, index + stringLength)) continue;
+			const previous = original.slice(index, index + stringLength);
+			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
+			if (previous !== _replacement) this.overwrite(index - this.offset, index + stringLength - this.offset, _replacement);
+		}
+		return this;
+	}
+	/**
+	* Same as `s.replace`, but replace all matched strings instead of just one.
+	*/
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+		if (!searchValue.global) throw new MagicStringError("replaceAll() requires a global RegExp");
+		return this._replaceRegexp(searchValue, replacement);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/svg/url.js
+/**
+* Encode SVG for use in url()
+*
+* Short alternative to encodeURIComponent() that encodes only stuff used in SVG, generating
+* smaller code.
+*/
+function encodeSVGforURL(svg) {
+	return svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/svg/encode-svg-for-css.js
+/**
+* Encode the `SVG` to be used on `CSS`: https://bl.ocks.org/jennyknuth/222825e315d45a738ed9d6e04c7a88d0.
+*
+* @param svg The `SVG` source.
+*/
+function encodeSvgForCss(svg) {
+	let useSvg = svg.startsWith("<svg>") ? svg.replace("<svg>", "<svg >") : svg;
+	if (!useSvg.includes(" xmlns:xlink=") && useSvg.includes(" xlink:")) useSvg = useSvg.replace("<svg ", "<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" ");
+	if (!useSvg.includes(" xmlns=")) useSvg = useSvg.replace("<svg ", "<svg xmlns=\"http://www.w3.org/2000/svg\" ");
+	return encodeSVGforURL(useSvg);
+}
+/** `lucide:check` → `mi-lucide--check`: `--` never occurs in a name, so the class reads back (D4). */
+function iconClass(name) {
+	return `mi-${name.replace(":", "--")}`;
+}
+/** `mi-lucide--check` (among other classes) → `lucide:check`, the inverse of `iconClass`. */
+function nameOfClass(classes) {
+	for (const c of classes.split(/\s+/)) {
+		const match = /^mi-([a-z0-9-]+?)--([a-z0-9-]+)$/.exec(c);
+		if (match) return `${match[1]}:${match[2]}`;
+	}
+}
+const FILL = "50%/100% 100% no-repeat";
+function baseCss(layer) {
+	return `@layer ${layer}{.mi{display:inline-block;width:1em;height:1em;flex-shrink:0;vertical-align:-.125em;background:currentColor;mask:var(--mi) ${FILL};forced-color-adjust:none}}\n`;
+}
+/** One icon's rule. A wider or taller icon keeps its ratio at `1em` high. */
+function iconCss(name, icon, layer) {
+	const body = icon.mono ? icon.body.replaceAll("currentColor", "black") : icon.body;
+	let rule = `--mi:url("data:image/svg+xml,${encodeSvgForCss(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${icon.width} ${icon.height}">${body}</svg>`)}");`;
+	if (!icon.mono) rule += `background:var(--mi) ${FILL};mask:none;`;
+	if (icon.width !== icon.height) rule += `width:${round(icon.width / icon.height)}em;`;
+	return `@layer ${layer}{${rule.indexOf(";") === rule.length - 1 ? `.${iconClass(name)}` : `.mi.${iconClass(name)}`}{${rule.slice(0, -1)}}}\n`;
+}
+function round(n) {
+	return Math.round(n * 1e3) / 1e3;
+}
+//#endregion
+//#region src/vite/compile.ts
+/**
+* The transform (D2, D3, D6): every `icon("set:name", { label, class })`
+* of a module becomes a literal attribute object, and the module imports
+* the base CSS and one CSS module per icon it names. It runs on JavaScript,
+* after the framework compilers, so `.vue`, `.svelte`, `.astro` and JSX
+* are one case; Vue's templates call the import through `$setup` or `_unref`.
+*/
+const PACKAGE$1 = "@menapo/icons";
+/** The virtual CSS modules, `virtual:menapo-icons/base.css` and `…/lucide--check.css`. */
+const VIRTUAL = "virtual:menapo-icons/";
+/** A message for a call the plugin cannot compile, at `start` in the module. */
+var CompileError = class extends Error {
+	name = "CompileError";
+	start;
+	constructor(message, start) {
+		super(message);
+		this.start = start;
+	}
+};
+const RUNTIME_NAME = `icon() takes the name as a string literal: icon("lucide:check"). For a name chosen at runtime, pick from compiled calls: { pdf: icon("lucide:file-text"), other: icon("lucide:file") }`;
+/** `null` when the module calls no `icon()`. */
+function compile(code, id, options) {
+	const { program, errors } = parseSync(`${id.replace(/[?#].*$/, "")}.js`, code);
+	if (errors.length) return null;
+	const locals = /* @__PURE__ */ new Set();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.source.value !== "@menapo/icons") continue;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "icon") locals.add(specifier.local.name);
+	}
+	if (!locals.size) return null;
+	const s = new MagicString(code);
+	const icons = [];
+	walk(program, (node) => {
+		if (node.type !== "CallExpression" || !isIconCallee(node.callee, locals)) return;
+		const [nameArg, optionsArg, extra] = node.arguments;
+		const name = literal(nameArg);
+		if (name === void 0 || extra) throw new CompileError(RUNTIME_NAME, node.start);
+		options.check(name, nameArg.start);
+		if (!icons.includes(name)) icons.push(name);
+		const { label, extraClass } = readOptions(code, optionsArg);
+		const classes = JSON.stringify(`mi ${iconClass(name)}`);
+		const classValue = extraClass ? `${classes.slice(0, -1)} "+((${extraClass})??"")` : classes;
+		const rest = label ? `role:"img","aria-label":(${label})` : `"aria-hidden":"true"`;
+		s.overwrite(node.start, node.end, `({${options.classAttribute}:${classValue},${rest}})`);
+	});
+	if (!icons.length) return null;
+	const imports = [`${VIRTUAL}base.css`, ...icons.map((n) => `${VIRTUAL}${n.replace(":", "--")}.css`)].map((source) => `import ${JSON.stringify(source)};`).join("");
+	let at = 0;
+	for (const node of program.body) if (node.type === "ExpressionStatement" && "directive" in node && node.directive) at = node.end;
+	else break;
+	if (at) s.appendLeft(at, `\n${imports}`);
+	else s.prepend(`${imports}\n`);
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: "boundary",
+			source: id
+		}),
+		icons
+	};
+}
+/** `icon(…)`, or Vue's `$setup.icon(…)` / `$setup["icon"](…)` (dev) and `_unref(icon)(…)` (build) in a template. */
+function isIconCallee(callee, locals) {
+	if (callee.type === "Identifier") return locals.has(callee.name);
+	if (callee.type === "CallExpression") {
+		const [arg] = callee.arguments;
+		return callee.callee.type === "Identifier" && callee.callee.name === "_unref" && callee.arguments.length === 1 && arg?.type === "Identifier" && locals.has(arg.name);
+	}
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return false;
+	if (callee.object.name !== "$setup") return false;
+	const property = callee.property;
+	const key = callee.computed ? literal(property) : property.type === "Identifier" ? property.name : void 0;
+	return key !== void 0 && locals.has(key);
+}
+/** A string literal's value, or an expression-free template literal's. */
+function literal(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? void 0;
+}
+/** The source text of `label` and `class`, kept as written. */
+function readOptions(code, node) {
+	if (!node) return {};
+	if (node.type !== "ObjectExpression") throw new CompileError("icon()'s options are an object literal: icon(\"lucide:x\", { label: t(\"Close\") })", node.start);
+	const out = {};
+	for (const property of node.properties) {
+		const key = property.type === "Property" && !property.computed ? property.key.type === "Identifier" ? property.key.name : literal(property.key) : void 0;
+		if (property.type !== "Property" || key !== "label" && key !== "class") throw new CompileError("icon() takes two options, label and class: icon(name, { label, class })", property.start);
+		const text = code.slice(property.value.start, property.value.end);
+		if (key === "label") out.label = text;
+		else out.extraClass = text;
+	}
+	return out;
+}
+/** Visits every node, parents first. */
+function walk(node, visit) {
+	if (Array.isArray(node)) {
+		for (const child of node) walk(child, visit);
+		return;
+	}
+	if (node === null || typeof node !== "object") return;
+	const n = node;
+	if (typeof n.type === "string") visit(n);
+	for (const key in n) {
+		if (key === "type" || key === "start" || key === "end" || key === "range" || key === "loc") continue;
+		const value = n[key];
+		if (value !== null && typeof value === "object") walk(value, visit);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/icon/defaults.js
+/** Default values for dimensions */
+const defaultIconDimensions = Object.freeze({
+	left: 0,
+	top: 0,
+	width: 16,
+	height: 16
+});
+/** Default values for transformations */
+const defaultIconTransformations = Object.freeze({
+	rotate: 0,
+	vFlip: false,
+	hFlip: false
+});
+/** Default values for all optional IconifyIcon properties */
+const defaultIconProps = Object.freeze({
+	...defaultIconDimensions,
+	...defaultIconTransformations
+});
+/** Default values for all properties used in ExtendedIconifyIcon */
+const defaultExtendedIconProps = Object.freeze({
+	...defaultIconProps,
+	body: "",
+	hidden: false
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/icon/transformations.js
+/**
+* Merge transformations
+*/
+function mergeIconTransformations(obj1, obj2) {
+	const result = {};
+	if (!obj1.hFlip !== !obj2.hFlip) result.hFlip = true;
+	if (!obj1.vFlip !== !obj2.vFlip) result.vFlip = true;
+	const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+	if (rotate) result.rotate = rotate;
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/icon/merge.js
+/**
+* Merge icon and alias
+*
+* Can also be used to merge default values and icon
+*/
+function mergeIconData(parent, child) {
+	const result = mergeIconTransformations(parent, child);
+	for (const key in defaultExtendedIconProps) if (key in defaultIconTransformations) {
+		if (key in parent && !(key in result)) result[key] = defaultIconTransformations[key];
+	} else if (key in child) result[key] = child[key];
+	else if (key in parent) result[key] = parent[key];
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/icon-set/tree.js
+/**
+* Resolve icon set icons
+*
+* Returns parent icon for each icon
+*/
+function getIconsTree(data, names) {
+	const icons = data.icons;
+	const aliases = data.aliases || Object.create(null);
+	const resolved = Object.create(null);
+	function resolve(name) {
+		if (icons[name]) return resolved[name] = [];
+		if (!(name in resolved)) {
+			resolved[name] = null;
+			const parent = aliases[name] && aliases[name].parent;
+			const value = parent && resolve(parent);
+			if (value) resolved[name] = [parent].concat(value);
+		}
+		return resolved[name];
+	}
+	(names || Object.keys(icons).concat(Object.keys(aliases))).forEach(resolve);
+	return resolved;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/icon-set/get-icon.js
+/**
+* Get icon data, using prepared aliases tree
+*/
+function internalGetIconData(data, name, tree) {
+	const icons = data.icons;
+	const aliases = data.aliases || Object.create(null);
+	let currentProps = {};
+	function parse(name) {
+		currentProps = mergeIconData(icons[name] || aliases[name], currentProps);
+	}
+	parse(name);
+	tree.forEach(parse);
+	return mergeIconData(data, currentProps);
+}
+/**
+* Get data for icon
+*/
+function getIconData(data, name) {
+	if (data.icons[name]) return internalGetIconData(data, name, []);
+	const tree = getIconsTree(data, [name])[name];
+	return tree ? internalGetIconData(data, name, tree) : null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/customisations/defaults.js
+/**
+* Default icon customisations values
+*/
+const defaultIconSizeCustomisations = Object.freeze({
+	width: null,
+	height: null
+});
+const defaultIconCustomisations = Object.freeze({
+	...defaultIconSizeCustomisations,
+	...defaultIconTransformations
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/svg/size.js
+/**
+* Regular expressions for calculating dimensions
+*/
+const unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+const unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+	if (ratio === 1) return size;
+	precision = precision || 100;
+	if (typeof size === "number") return Math.ceil(size * ratio * precision) / precision;
+	if (typeof size !== "string") return size;
+	const oldParts = size.split(unitsSplit);
+	if (oldParts === null || !oldParts.length) return size;
+	const newParts = [];
+	let code = oldParts.shift();
+	let isNumber = unitsTest.test(code);
+	while (true) {
+		if (isNumber) {
+			const num = parseFloat(code);
+			if (isNaN(num)) newParts.push(code);
+			else newParts.push(Math.ceil(num * ratio * precision) / precision);
+		} else newParts.push(code);
+		code = oldParts.shift();
+		if (code === void 0) return newParts.join("");
+		isNumber = !isNumber;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/svg/defs.js
+function splitSVGDefs(content, tag = "defs") {
+	let defs = "";
+	const index = content.indexOf("<" + tag);
+	while (index >= 0) {
+		const start = content.indexOf(">", index);
+		const end = content.indexOf("</" + tag);
+		if (start === -1 || end === -1) break;
+		const endEnd = content.indexOf(">", end);
+		if (endEnd === -1) break;
+		defs += content.slice(start + 1, end).trim();
+		content = content.slice(0, index).trim() + content.slice(endEnd + 1);
+	}
+	return {
+		defs,
+		content
+	};
+}
+/**
+* Merge defs and content
+*/
+function mergeDefsAndContent(defs, content) {
+	return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+/**
+* Wrap SVG content, without wrapping definitions
+*/
+function wrapSVGContent(body, start, end) {
+	const split = splitSVGDefs(body);
+	return mergeDefsAndContent(split.defs, start + split.content + end);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@iconify+utils@3.1.7/node_modules/@iconify/utils/lib/svg/build.js
+/**
+* Check if value should be unset. Allows multiple keywords
+*/
+const isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+/**
+* Get SVG attributes and content from icon + customisations
+*
+* Does not generate style to make it compatible with frameworks that use objects for style, such as React.
+* Instead, it generates 'inline' value. If true, rendering engine should add verticalAlign: -0.125em to icon.
+*
+* Customisations should be normalised by platform specific parser.
+* Result should be converted to <svg> by platform specific parser.
+* Use replaceIDs to generate unique IDs for body.
+*/
+function iconToSVG(icon, customisations) {
+	const fullIcon = {
+		...defaultIconProps,
+		...icon
+	};
+	const fullCustomisations = {
+		...defaultIconCustomisations,
+		...customisations
+	};
+	const box = {
+		left: fullIcon.left,
+		top: fullIcon.top,
+		width: fullIcon.width,
+		height: fullIcon.height
+	};
+	let body = fullIcon.body;
+	[fullIcon, fullCustomisations].forEach((props) => {
+		const transformations = [];
+		const hFlip = props.hFlip;
+		const vFlip = props.vFlip;
+		let rotation = props.rotate;
+		if (hFlip) {
+			if (vFlip) rotation += 2;
+			else {
+				transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+				transformations.push("scale(-1 1)");
+				box.top = box.left = 0;
+			}
+		} else if (vFlip) {
+			transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+			transformations.push("scale(1 -1)");
+			box.top = box.left = 0;
+		}
+		let tempValue;
+		if (rotation < 0) rotation -= Math.floor(rotation / 4) * 4;
+		rotation = rotation % 4;
+		switch (rotation) {
+			case 1:
+				tempValue = box.height / 2 + box.top;
+				transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+				break;
+			case 2:
+				transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+				break;
+			case 3:
+				tempValue = box.width / 2 + box.left;
+				transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+		}
+		if (rotation % 2 === 1) {
+			if (box.left !== box.top) {
+				tempValue = box.left;
+				box.left = box.top;
+				box.top = tempValue;
+			}
+			if (box.width !== box.height) {
+				tempValue = box.width;
+				box.width = box.height;
+				box.height = tempValue;
+			}
+		}
+		if (transformations.length) body = wrapSVGContent(body, "<g transform=\"" + transformations.join(" ") + "\">", "</g>");
+	});
+	const customisationsWidth = fullCustomisations.width;
+	const customisationsHeight = fullCustomisations.height;
+	const boxWidth = box.width;
+	const boxHeight = box.height;
+	let width;
+	let height;
+	if (customisationsWidth === null) {
+		height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+		width = calculateSize(height, boxWidth / boxHeight);
+	} else {
+		width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+		height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+	}
+	const attributes = {};
+	const setAttr = (prop, value) => {
+		if (!isUnsetKeyword(value)) attributes[prop] = value.toString();
+	};
+	setAttr("width", width);
+	setAttr("height", height);
+	const viewBox = [
+		box.left,
+		box.top,
+		boxWidth,
+		boxHeight
+	];
+	attributes.viewBox = viewBox.join(" ");
+	return {
+		attributes,
+		viewBox,
+		body
+	};
+}
+//#endregion
+//#region src/vite/suggest.ts
+/**
+* "Did you mean": the closest names by edit distance, as vicss and vi18n
+* suggest theirs. A set holds a few thousand names, which this scans in
+* well under a millisecond.
+*/
+/** Up to three names within a third of `name`'s length (at least two edits). */
+function closest(name, names) {
+	const limit = Math.max(2, Math.floor(name.length / 3));
+	const scored = [];
+	for (const candidate of names) {
+		if (Math.abs(candidate.length - name.length) > limit) continue;
+		const d = distance(name, candidate, limit);
+		if (d <= limit) scored.push([d, candidate]);
+	}
+	scored.sort((a, b) => a[0] - b[0] || a[1].localeCompare(b[1]));
+	return scored.slice(0, 3).map(([, candidate]) => candidate);
+}
+/** Levenshtein distance, stopping once every path exceeds `limit`. */
+function distance(a, b, limit) {
+	let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		const row = [i];
+		let best = i;
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			const value = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + cost);
+			row.push(value);
+			if (value < best) best = value;
+		}
+		if (best > limit) return limit + 1;
+		previous = row;
+	}
+	return previous[b.length];
+}
+//#endregion
+//#region src/vite/svg.ts
+/** The whole `<svg>` element: what a data URL holds and what og inlines. */
+function svgElement(icon) {
+	const { width, height, body } = icon;
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}">${body}</svg>`;
+}
+const BLACK = /^(?:black|#000|#000000|#000f|#000000ff|rgb\(0,\s*0,\s*0\))$/i;
+const NO_PAINT = /^(?:none|transparent|currentcolor|inherit|unset|initial|context-fill|context-stroke)$/i;
+const PAINT_ATTRIBUTE = /\b(?:fill|stroke|stop-color|flood-color|lighting-color|color)\s*[=:]\s*["']?([^"';)>\s]+(?:\([^)]*\))?)/gi;
+/**
+* Whether `body` paints in one colour: only `currentColor`, black (the
+* default fill, and what Figma exports hard-code) or no paint. A gradient
+* or a `url(#…)` paint counts as a colour.
+*/
+function isMonochrome(body) {
+	for (const match of body.matchAll(PAINT_ATTRIBUTE)) {
+		const value = match[1];
+		if (!NO_PAINT.test(value) && !BLACK.test(value)) return false;
+	}
+	return !/<(?:linear|radial)Gradient\b|<pattern\b|<image\b/i.test(body);
+}
+/** Black paints become `currentColor`, so an inlined monochrome icon follows `color` like the mask does. */
+function paintCurrentColor(body) {
+	return body.replace(PAINT_ATTRIBUTE, (all, value) => BLACK.test(value) ? all.replace(value, "currentColor") : all);
+}
+/**
+* A local SVG file as an icon. The clean-up removes what a CSS image never
+* uses and what would be active content inlined (D13); it is not an
+* optimiser. Throws a message for a file that is not an SVG or has no size.
+*/
+function parseSvg(source) {
+	const text = source.replace(/<\?xml[\s\S]*?\?>/gi, "").replace(/<!DOCTYPE[\s\S]*?>/gi, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<(script|metadata|foreignObject|title|desc)\b[\s\S]*?<\/\1\s*>/gi, "").replace(/<(script|metadata|foreignObject)\b[^>]*\/>/gi, "").replace(/\s+on[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/\s+(?:xlink:)?href\s*=\s*(?:"(?!#)[^"]*"|'(?!#)[^']*')/gi, "");
+	const open = /<svg\b([^>]*)>/i.exec(text);
+	const close = text.lastIndexOf("</svg>");
+	if (!open || close < open.index) throw new Error("is not an <svg> element");
+	const attributes = open[1];
+	const body = text.slice(open.index + open[0].length, close).trim();
+	const viewBox = /\bviewBox\s*=\s*["']([^"']+)["']/i.exec(attributes)?.[1];
+	let width;
+	let height;
+	if (viewBox) {
+		const box = viewBox.trim().split(/[\s,]+/).map(Number);
+		if (box.length !== 4 || box.some((n) => !Number.isFinite(n))) throw new Error(`has a viewBox "${viewBox}" that is not four numbers`);
+		const [x, y] = box;
+		width = box[2];
+		height = box[3];
+		return finish(x !== 0 || y !== 0 ? `<g transform="translate(${-x} ${-y})">${body}</g>` : body, width, height);
+	}
+	width = Number(/\bwidth\s*=\s*["']?([\d.]+)/i.exec(attributes)?.[1]);
+	height = Number(/\bheight\s*=\s*["']?([\d.]+)/i.exec(attributes)?.[1]);
+	if (!(width > 0 && height > 0)) throw new Error("has no viewBox and no width and height");
+	return finish(body, width, height);
+	function finish(inner, w, h) {
+		const paint = [...attributes.matchAll(/\s(fill|stroke|stroke-width|stroke-linecap|stroke-linejoin)\s*=\s*("[^"]*"|'[^']*')/gi)].map((m) => ` ${m[1]}=${m[2]}`).join("");
+		const wrapped = paint ? `<g${paint}>${inner}</g>` : inner;
+		const mono = isMonochrome(wrapped);
+		return {
+			body: mono ? paintCurrentColor(wrapped) : wrapped,
+			width: w,
+			height: h,
+			mono
+		};
+	}
+}
+//#endregion
+//#region src/vite/resolve.ts
+/**
+* Names to SVGs (PLAN §4): the `@iconify-json/*` sets the root
+* `package.json` lists (D9) and the app's folders. A set is parsed on first
+* use and kept for the process; a folder file is read on each resolve, so a
+* changed SVG is picked up when the plugin asks again.
+*/
+/** A name that cannot be resolved; the message names the fix. */
+var IconError = class extends Error {
+	name = "IconError";
+};
+/** Iconify's id grammar: lowercase words joined by single dashes. */
+const PART = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const PACKAGE = "@iconify-json/";
+/** Parsed sets by file, for the process: a dev server restart or a second build reuses them. */
+const parsed = /* @__PURE__ */ new Map();
+/** The icons one project can name. */
+var IconSource = class {
+	root;
+	/** Installed set prefixes, from `package.json`. */
+	sets;
+	/** Folder prefixes to absolute directories. */
+	folders;
+	#require;
+	#built = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.root = options.root;
+		this.#require = createRequire(join(options.root, "package.json"));
+		this.sets = installedSets(options.root);
+		const folders = /* @__PURE__ */ new Map();
+		for (const [prefix, dir] of Object.entries(options.folders ?? {})) {
+			if (!PART.test(prefix)) throw new IconError(`folders: "${prefix}" is not a set name: use lowercase words joined by dashes, like "brand"`);
+			if (this.sets.includes(prefix)) throw new IconError(`folders: "${prefix}" is also the installed ${PACKAGE}${prefix}: give the folder another name`);
+			const abs = resolve(options.root, dir);
+			if (!existsSync(abs) || !statSync(abs).isDirectory()) throw new IconError(`folders: "${prefix}" points to ${dir}, which is not a directory`);
+			folders.set(prefix, abs);
+		}
+		this.folders = folders;
+	}
+	/** Every name, sorted per set: the `IconName` union (D10). */
+	names(skipped = []) {
+		const out = [];
+		for (const prefix of this.sets) for (const name of this.#set(prefix).names) out.push(`${prefix}:${name}`);
+		for (const [prefix, dir] of this.folders) for (const name of folderNames(dir, skipped)) out.push(`${prefix}:${name}`);
+		return out;
+	}
+	/** `prefix:name` to its SVG; throws an `IconError` naming the closest names. */
+	resolve(id) {
+		const colon = id.indexOf(":");
+		const prefix = id.slice(0, colon);
+		const name = id.slice(colon + 1);
+		if (colon < 1 || !PART.test(prefix) || !PART.test(name)) throw new IconError(`"${id}" is not an icon name: write "set:name" in lowercase, like "lucide:check"`);
+		const dir = this.folders.get(prefix);
+		if (dir) return this.#fromFolder(id, prefix, name, dir);
+		if (this.sets.includes(prefix)) return this.#fromSet(id, prefix, name);
+		const known = [...this.sets, ...this.folders.keys()];
+		throw new IconError(`no icon set "${prefix}" for "${id}". ${known.length ? `Installed: ${this.sets.join(", ") || "none"}; folders: ${[...this.folders.keys()].join(", ") || "none"}.` : "No set is installed and no folder is listed."}${hint(prefix, known)} To add it: vp add -D ${PACKAGE}${prefix}`);
+	}
+	#set(prefix) {
+		const file = this.#require.resolve(`${PACKAGE}${prefix}/icons.json`);
+		let set = parsed.get(file);
+		if (!set) {
+			const json = JSON.parse(readFileSync(file, "utf8"));
+			set = {
+				json,
+				file,
+				names: [...Object.keys(json.icons), ...Object.keys(json.aliases ?? {})].sort(),
+				palette: palette(file.slice(0, -10))
+			};
+			parsed.set(file, set);
+		}
+		return set;
+	}
+	#fromSet(id, prefix, name) {
+		let icon = this.#built.get(id);
+		if (!icon) this.#built.set(id, icon = this.#buildFromSet(id, prefix, name));
+		return icon;
+	}
+	#buildFromSet(id, prefix, name) {
+		const set = this.#set(prefix);
+		const data = getIconData(set.json, name);
+		if (!data) throw new IconError(`icon "${id}" is not in ${PACKAGE}${prefix}.${hint(name, set.names, prefix)}`);
+		const built = iconToSVG(data, { height: "auto" });
+		const [x, y, width, height] = built.viewBox;
+		const body = x || y ? `<g transform="translate(${-x} ${-y})">${built.body}</g>` : built.body;
+		const mono = set.palette === void 0 ? isMonochrome(body) : !set.palette;
+		return {
+			name: id,
+			file: set.file,
+			body: mono ? paintCurrentColor(body) : body,
+			width,
+			height,
+			mono
+		};
+	}
+	#fromFolder(id, prefix, name, dir) {
+		const file = folderFile(dir, name);
+		if (!file) throw new IconError(`icon "${id}" has no file in ${relative(this.root, dir) || "."}.` + hint(name, folderNames(dir), prefix));
+		try {
+			return {
+				name: id,
+				file,
+				...parseSvg(readFileSync(file, "utf8"))
+			};
+		} catch (error) {
+			throw new IconError(`${relative(this.root, file)} ${error.message}`);
+		}
+	}
+};
+/** A set's `info.json` palette; the packages ship it beside `icons.json`, which lacks `info`. */
+function palette(dir) {
+	try {
+		const info = JSON.parse(readFileSync(join(dir, "info.json"), "utf8"));
+		return typeof info.palette === "boolean" ? info.palette : void 0;
+	} catch {
+		return;
+	}
+}
+/** ` Did you mean "lucide:check"?`, or nothing. */
+function hint(name, names, prefix) {
+	const found = closest(name, names);
+	if (!found.length) return "";
+	return ` Did you mean ${found.map((n) => `"${prefix ? `${prefix}:` : ""}${n}"`).join(", ")}?`;
+}
+/** The set prefixes of the `@iconify-json/*` packages `root/package.json` depends on. */
+function installedSets(root) {
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+	} catch {
+		return [];
+	}
+	return [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})].filter((name) => name.startsWith(PACKAGE)).map((name) => name.slice(14)).sort();
+}
+/** A folder's icon names: `arrows/left.svg` is `arrows-left` (D4). */
+function folderNames(dir, skipped = [], base = "") {
+	const out = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) out.push(...folderNames(join(dir, entry.name), skipped, `${base}${entry.name}-`));
+	else if (entry.name.endsWith(".svg")) {
+		const name = base + entry.name.slice(0, -4);
+		(PART.test(name) ? out : skipped).push(name);
+	}
+	return out.sort();
+}
+/** The file for `name` in `dir`, trying each dash as a folder separator. */
+function folderFile(dir, name) {
+	const direct = join(dir, `${name}.svg`);
+	if (existsSync(direct)) return direct;
+	const dash = name.indexOf("-");
+	for (let i = dash; i > 0; i = name.indexOf("-", i + 1)) {
+		const sub = join(dir, name.slice(0, i));
+		if (existsSync(sub) && statSync(sub).isDirectory()) {
+			const found = folderFile(sub, name.slice(i + 1));
+			if (found) return found;
+		}
+	}
+}
+//#endregion
+//#region src/vite/types.ts
+/**
+* The generated `icons.d.ts` (D10): the names and the framework, registered
+* on `@menapo/icons`'s `Register` the way vicss registers its tokens.
+*/
+/** `src/icons.d.ts`, else `app/icons.d.ts`, else the root's: where a tsconfig's `include` looks. */
+function typesFile(root) {
+	const dir = ["src", "app"].map((name) => join(root, name)).find((d) => existsSync(d));
+	return join(dir ?? root, "icons.d.ts");
+}
+function typesText(names, framework) {
+	const union = names.length ? names.map((n) => `\n      | ${JSON.stringify(n)}`).join("") : " never";
+	return `// Generated by @menapo/icons/vite from the installed sets and folders. Commit it; do not edit.
+import "@menapo/icons";
+
+declare module "@menapo/icons" {
+  interface Register {
+    framework: ${JSON.stringify(framework)};\n    names:${union};\n  }
+}
+`;
+}
+/** Writes unless unchanged, so a type checker or watcher sees no edit for nothing. */
+function writeIfChanged(file, text) {
+	try {
+		if (readFileSync(file, "utf8") === text) return false;
+	} catch {}
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, text);
+	return true;
+}
+//#endregion
+//#region src/vite/index.ts
+/**
+* `@menapo/icons/vite`: `plugins: [icons()]` (PLAN §0). It compiles every
+* `icon()` call to a literal, serves each icon's CSS as a virtual module the
+* calling module imports, and writes `icons.d.ts`. `resolveIcon` and
+* `iconName` are the build-side door og's renderer uses (D11). The only
+* entry that imports from the build side.
+*/
+const RESOLVED = `\0${VIRTUAL}`;
+const SCRIPT = /\.(?:[cm]?[jt]sx?|vue|svelte|astro)(?:[?#]|$)/;
+const OWN = posix(fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../" : "./", import.meta.url)));
+/** `plugins: [icons()]` in a Vite config. */
+function icons(options = {}) {
+	let config;
+	let source;
+	let settings;
+	let layer = "base";
+	/** Folder files to the virtual ids built from them, for dev updates. */
+	const built = /* @__PURE__ */ new Map();
+	function writeTypes() {
+		const skipped = [];
+		const names = source.names(skipped);
+		for (const name of skipped) config.logger.warn(`[icons] ${name}.svg is skipped: name icon files in lowercase words joined by dashes`);
+		const framework = rootFramework(config.root) ?? "vanilla";
+		writeIfChanged(typesFile(config.root), typesText(names, framework));
+	}
+	return {
+		name: "icons",
+		api: { folders: options.folders },
+		enforce: "post",
+		configResolved(resolved) {
+			config = resolved;
+			source = new IconSource({
+				root: resolved.root,
+				folders: options.folders
+			});
+			settings = {
+				scripts: rootFramework(resolved.root) ?? "vanilla",
+				jsx: jsxFrameworkOf(resolved, resolved.root)
+			};
+			if (resolved.plugins.some((plugin) => plugin.name === "vicss")) layer = "vicss.global";
+			writeTypes();
+		},
+		configureServer(server) {
+			const dirs = [...source.folders.values()];
+			if (!dirs.length) return;
+			server.watcher.add(dirs);
+			const changed = (file) => {
+				if (file.endsWith(".svg") && dirs.some((dir) => file.startsWith(dir + sep))) writeTypes();
+			};
+			server.watcher.on("add", changed);
+			server.watcher.on("unlink", changed);
+		},
+		hotUpdate({ file, modules }) {
+			const ids = built.get(file);
+			if (!ids) return;
+			const updated = [...ids].flatMap((id) => {
+				const module = this.environment.moduleGraph.getModuleById(id);
+				if (!module) return [];
+				this.environment.moduleGraph.invalidateModule(module);
+				return [module];
+			});
+			return [...modules, ...updated];
+		},
+		resolveId: {
+			filter: { id: new RegExp(`^${VIRTUAL}`) },
+			handler: (id) => `\0${id}`
+		},
+		load: {
+			filter: { id: new RegExp(`^${RESOLVED.replace("\0", "\\0")}`) },
+			handler(id) {
+				const file = id.slice(RESOLVED.length, -4);
+				if (file === "base") return baseCss(layer);
+				const name = file.replace("--", ":");
+				let icon;
+				try {
+					icon = source.resolve(name);
+				} catch (error) {
+					if (error instanceof IconError) this.error(error.message);
+					throw error;
+				}
+				if (source.folders.has(name.slice(0, name.indexOf(":")))) {
+					this.addWatchFile(icon.file);
+					let ids = built.get(icon.file);
+					if (!ids) built.set(icon.file, ids = /* @__PURE__ */ new Set());
+					ids.add(id);
+				}
+				return iconCss(name, icon, layer);
+			}
+		},
+		transform: {
+			filter: {
+				id: {
+					include: SCRIPT,
+					exclude: /^\0/
+				},
+				code: PACKAGE$1
+			},
+			handler(code, id) {
+				if (within([OWN], id)) return null;
+				const framework = /\.astro(?:[?#]|$)/.test(id) ? "astro" : frameworkOf(id, code, settings);
+				try {
+					const out = compile(code, id, {
+						classAttribute: framework === "react" ? "className" : "class",
+						check: (name, start) => {
+							try {
+								source.resolve(name);
+							} catch (error) {
+								if (error instanceof IconError) throw new CompileError(error.message, start);
+								throw error;
+							}
+						}
+					});
+					return out && {
+						code: out.code,
+						map: out.map
+					};
+				} catch (error) {
+					if (error instanceof CompileError) {
+						const file = posix(relative(config.root, id.replace(/[?#].*$/, "")));
+						this.error({
+							message: `${file}: ${error.message}`,
+							pos: error.start
+						});
+					}
+					throw error;
+				}
+			}
+		}
+	};
+}
+const sources = /* @__PURE__ */ new Map();
+/**
+* `lucide:check` to its SVG, from the sets and folders of the project at
+* `root`, as the plugin resolves it. Throws a message naming the fix for an
+* unknown name. Build side only: og calls it while it renders.
+*/
+function resolveIcon(name, options) {
+	const key = JSON.stringify([options.root, options.folders ?? {}]);
+	let icons = sources.get(key);
+	if (!icons) sources.set(key, icons = new IconSource(options));
+	const icon = icons.resolve(name);
+	const svg = svgElement(icon);
+	return {
+		...icon,
+		svg: icon.mono ? svg.replace("<svg ", "<svg fill=\"currentColor\" ") : svg
+	};
+}
+/**
+* The name an `icon()` result stands for, read back from its classes:
+* `iconName({ class: "mi mi-lucide--x" })` is `"lucide:x"`. A spread in a
+* markup template is just attributes; this is how a renderer knows it is
+* an icon. Takes `class` or `className` (D3).
+*/
+function iconName(attributes) {
+	const classes = attributes.class ?? attributes.className;
+	return typeof classes === "string" ? nameOfClass(classes) : void 0;
+}
+//#endregion
+export { iconName, icons, resolveIcon };