@icones/core 0.0.1

package/dist/runtime.js

@@ -0,0 +1,12 @@
+import { defaultIconLoader } from "./loaders.js";
+//#region src/runtime/compiled.ts
+const iconLoader = defaultIconLoader;
+const compiledIcons = /* @__PURE__ */ new Map();
+function registerStatic(name, icon) {
+	compiledIcons.set(name, icon);
+}
+function resolve(name) {
+	return compiledIcons.get(name);
+}
+//#endregion
+export { iconLoader, registerStatic, resolve };

package/dist/set-options-C2BMGh-r.d.ts

@@ -0,0 +1,11 @@
+//#region src/options/set-options.d.ts
+type IconSetMap<Value> = Readonly<Partial<Record<string, Value>>>;
+type IconSetOptions<Value> = Value | IconSetMap<Value>;
+declare function ownValue<Value>(values: IconSetMap<Value> | undefined, key: string | undefined): Value | undefined;
+/** The default discriminator is for primitive values; object values supply their own. */
+declare function isSetMap<Value>(value: IconSetOptions<Value>): value is IconSetMap<Value>;
+declare function resolveSetOption<Value>(value: IconSetOptions<Value> | undefined, set: string | undefined, isMap?: (value: IconSetOptions<Value>) => value is Readonly<Partial<Record<string, Value>>>): Value | undefined;
+/** Child maps merge by set; a shared value replaces the inherited map. */
+declare function mergeSetOptions<Value>(parent: IconSetOptions<Value> | undefined, next: IconSetOptions<Value> | undefined, isMap?: (value: IconSetOptions<Value>) => value is Readonly<Partial<Record<string, Value>>>): IconSetOptions<Value> | undefined;
+//#endregion
+export { ownValue as a, mergeSetOptions as i, IconSetOptions as n, resolveSetOption as o, isSetMap as r, IconSetMap as t };

package/dist/set-options.d.ts

@@ -0,0 +1,2 @@
+import { a as ownValue, i as mergeSetOptions, n as IconSetOptions, o as resolveSetOption, r as isSetMap, t as IconSetMap } from "./set-options-C2BMGh-r.js";
+export { IconSetMap, IconSetOptions, isSetMap, mergeSetOptions, ownValue, resolveSetOption };

package/dist/set-options.js

@@ -0,0 +1,23 @@
+//#region src/options/set-options.ts
+function ownValue(values, key) {
+	return values && key !== void 0 && Object.hasOwn(values, key) ? values[key] : void 0;
+}
+/** The default discriminator is for primitive values; object values supply their own. */
+function isSetMap(value) {
+	return typeof value === "object" && value !== null;
+}
+function resolveSetOption(value, set, isMap = isSetMap) {
+	if (value === void 0 || !isMap(value)) return value;
+	return ownValue(value, set) ?? ownValue(value, "default");
+}
+/** Child maps merge by set; a shared value replaces the inherited map. */
+function mergeSetOptions(parent, next, isMap = isSetMap) {
+	if (next === void 0) return parent;
+	if (!isMap(next)) return next;
+	return {
+		...parent !== void 0 && isMap(parent) ? parent : { default: parent },
+		...Object.fromEntries(Object.entries(next).filter(([, value]) => value !== void 0))
+	};
+}
+//#endregion
+export { isSetMap, mergeSetOptions, ownValue, resolveSetOption };

package/dist/sizes-CMxyEIpX.d.ts

@@ -0,0 +1,10 @@
+//#region src/options/sizes.d.ts
+type DefaultSizeName = "xs" | "sm" | "md" | "lg" | "xl";
+type CustomSizeName<CustomSize extends object> = keyof CustomSize & string;
+type EnabledCustomSizeName<CustomSize extends object> = { [Key in CustomSizeName<CustomSize>]: CustomSize[Key] extends true ? Key : never; }[CustomSizeName<CustomSize>];
+type DisabledDefaultSizeName<CustomSize extends object> = { [Key in DefaultSizeName]: Key extends keyof CustomSize ? CustomSize[Key] extends false ? Key : never : never; }[DefaultSizeName];
+type ResolveSizeName<CustomSize extends object> = Exclude<DefaultSizeName, DisabledDefaultSizeName<CustomSize>> | EnabledCustomSizeName<CustomSize>;
+type CSSLengthUnit = "%" | "cap" | "ch" | "cm" | "dvb" | "dvh" | "dvi" | "dvmax" | "dvmin" | "dvw" | "em" | "ex" | "ic" | "in" | "lh" | "lvb" | "lvh" | "lvi" | "lvmax" | "lvmin" | "lvw" | "mm" | "pc" | "pt" | "px" | "Q" | "rcap" | "rch" | "rem" | "rex" | "ric" | "rlh" | "svb" | "svh" | "svi" | "svmax" | "svmin" | "svw" | "vb" | "vh" | "vi" | "vmax" | "vmin" | "vw";
+type CSSSize = "0" | "auto" | "inherit" | "initial" | "revert" | "revert-layer" | "unset" | `${number}${CSSLengthUnit}` | `calc(${string})` | `clamp(${string})` | `max(${string})` | `min(${string})` | `var(${string})`;
+//#endregion
+export { DefaultSizeName as n, ResolveSizeName as r, CSSSize as t };

package/dist/sizes.d.ts

@@ -0,0 +1,2 @@
+import { n as DefaultSizeName, r as ResolveSizeName, t as CSSSize } from "./sizes-CMxyEIpX.js";
+export { CSSSize, DefaultSizeName, ResolveSizeName };

package/dist/slug.d.ts

@@ -0,0 +1,5 @@
+//#region src/resources/slug.d.ts
+/** Normalize an ASCII slug; the caller decides how to handle an empty result. */
+declare function toAsciiSlug(value: string): string;
+//#endregion
+export { toAsciiSlug };

package/dist/slug.js

@@ -0,0 +1,7 @@
+//#region src/resources/slug.ts
+/** Normalize an ASCII slug; the caller decides how to handle an empty result. */
+function toAsciiSlug(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+//#endregion
+export { toAsciiSlug };

package/dist/sources-CXcG9DjB.d.ts

@@ -0,0 +1,11 @@
+import { i as IconSet, n as IconData } from "./icon-data-HGvJGwoB.js";
+import { Data, IconLoaderResult, ParsedIconName } from "./types.js";
+//#region src/runtime/sources.d.ts
+/** Resolve an icon name from a full icon set payload when prefix/provider match. */
+declare function resolveIconSetData(data: IconSet, name: string): IconData | null;
+/** Parse user icon refs and keep provider-aware prefix/name fields. */
+declare function parseIconName(value: string): ParsedIconName | null;
+/** Convert loaded results from loaders into a canonical runtime data shape. */
+declare function toData(value: IconLoaderResult, name: string): Data | null;
+//#endregion
+export { resolveIconSetData as n, toData as r, parseIconName as t };

package/dist/store.d.ts

@@ -0,0 +1,36 @@
+import { Data, IconLoadState, IconLoader, IconSources } from "./types.js";
+import { r as IconApiConfig } from "./loaders-DxxA-L6t.js";
+import { r as toData } from "./sources-CXcG9DjB.js";
+//#region src/runtime/store.d.ts
+type IconStoreOptions = {
+  sources?: IconSources | readonly IconSources[];
+  api?: IconApiConfig;
+  parent?: IconStore;
+  /** Serialized per-request data for hydration. Also subject to maxEntries. */
+  initialData?: Readonly<Record<string, Data>>;
+  /** LRU capacity. Active entries and the current snapshot may temporarily exceed it. */
+  maxEntries?: number;
+  ttl?: number;
+  missingTtl?: number;
+  concurrency?: number;
+  timeout?: number;
+};
+type LoadOptions = {
+  force?: boolean;
+  loader?: IconLoader;
+};
+type IconStore = {
+  sources: readonly IconSources[];
+  api: IconApiConfig | undefined;
+  getState(name: string): IconLoadState;
+  load(name: string, options?: LoadOptions): Promise<Data | null>;
+  retry(name: string): Promise<Data | null>;
+  invalidate(name?: string | ((name: string) => boolean)): void;
+  preload(names: readonly string[]): Promise<void>;
+  snapshot(): Record<string, Data>;
+  subscribe(name: string, listener: () => void): () => void;
+};
+/** One store per SSR request or client application. Snapshot reads never run loaders. */
+declare function createIconStore(options?: IconStoreOptions): IconStore;
+//#endregion
+export { IconStore, IconStoreOptions, createIconStore, toData };

package/dist/store.js

@@ -0,0 +1,265 @@
+import { parseIconName, toData } from "./data.js";
+import { createIconApiLoader, isSymbolApi, mergeIconApi, resolveIconApi } from "./loaders.js";
+import { resolveIconSymbol } from "./symbol.js";
+//#region src/runtime/store.ts
+const idle = { status: "idle" };
+const deferred = Symbol("deferred source");
+/** One store per SSR request or client application. Snapshot reads never run loaders. */
+function createIconStore(options = {}) {
+	for (const key of [
+		"maxEntries",
+		"concurrency",
+		"timeout",
+		"ttl",
+		"missingTtl"
+	]) {
+		const value = options[key];
+		if (value === void 0) continue;
+		const minimum = key === "ttl" || key === "missingTtl" ? 0 : 1;
+		if (!Number.isFinite(value) || value < minimum || (key === "maxEntries" || key === "concurrency") && !Number.isInteger(value)) throw new RangeError(`Invalid icon store ${key}: ${value}`);
+	}
+	const local = options.sources ? Array.isArray(options.sources) ? options.sources : [options.sources] : [];
+	const inherited = options.parent;
+	const delegate = options.api === void 0 ? inherited : void 0;
+	const sources = [...local, ...inherited?.sources ?? []];
+	const activeSources = delegate ? local : sources;
+	const api = mergeIconApi(inherited?.api, options.api);
+	const loaders = /* @__PURE__ */ new Map();
+	const loader = (name, parsed, request) => {
+		const selected = resolveIconApi(api, name);
+		let selectedLoader = loaders.get(selected);
+		if (!selectedLoader) {
+			selectedLoader = createIconApiLoader(isSymbolApi(selected) ? false : selected);
+			loaders.set(selected, selectedLoader);
+		}
+		return selectedLoader(name, parsed, request);
+	};
+	const reference = (name) => {
+		const selected = resolveIconApi(api, name);
+		return isSymbolApi(selected) ? resolveIconSymbol(selected, name) : null;
+	};
+	const maxEntries = Math.max(1, options.maxEntries ?? 512);
+	const concurrency = Math.max(1, options.concurrency ?? 8);
+	const states = /* @__PURE__ */ new Map();
+	const requests = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	const queue = [];
+	let running = 0;
+	for (const [name, data] of Object.entries(options.initialData ?? {})) {
+		const resolved = toData(data, name);
+		if (resolved) cache(name, {
+			status: "loaded",
+			data: resolved
+		}, options.ttl ?? 3e5);
+	}
+	/** Drop unreferenced cache entries when the in-memory budget is exceeded. */
+	function trim(current) {
+		for (const name of states.keys()) {
+			if (states.size <= maxEntries) break;
+			if (name !== current && !listeners.has(name) && !requests.has(name)) states.delete(name);
+		}
+	}
+	/** Record state and expiration for stable reads during a render tick. */
+	function cache(name, state, ttl = Infinity) {
+		states.delete(name);
+		states.set(name, {
+			state,
+			expires: Date.now() + ttl
+		});
+		trim(name);
+		return state;
+	}
+	function publish(name, state, ttl = Infinity) {
+		cache(name, state, ttl);
+		listeners.get(name)?.forEach((listener) => listener());
+	}
+	/** Read one source entry by full name or by set fallback when name is namespaced. */
+	function sourceValue(source, name) {
+		const parsed = parseIconName(name);
+		const key = Object.hasOwn(source, name) ? name : name.includes(":") ? parsed?.prefix ?? "" : "";
+		return Object.hasOwn(source, key) ? source[key] : void 0;
+	}
+	/** Probe all active sources and return deferred marker when async callbacks appear. */
+	function probe(name) {
+		for (const source of activeSources) {
+			if (typeof source === "function") return deferred;
+			const value = sourceValue(source, name);
+			if (typeof value === "function") return deferred;
+			const data = toData(value, name);
+			if (data) return data;
+		}
+		return null;
+	}
+	/** Resolve current state from cache/probe/delegate/reference without mutating listeners. */
+	function getState(name) {
+		const cached = states.get(name);
+		if (cached) {
+			states.delete(name);
+			states.set(name, cached);
+			return cached.state;
+		}
+		let data;
+		try {
+			data = probe(name);
+		} catch (cause) {
+			return cache(name, {
+				status: "error",
+				error: cause instanceof Error ? cause : new Error(String(cause))
+			}, 0);
+		}
+		if (data === deferred) return idle;
+		if (!data) {
+			if (delegate) return delegate.getState(name);
+			const symbol = reference(name);
+			if (!symbol) return idle;
+			return cache(name, {
+				status: "referenced",
+				...symbol
+			});
+		}
+		return cache(name, {
+			status: "loaded",
+			data
+		});
+	}
+	/** Resolve icon data from active sources in order, supporting sync and async sources. */
+	async function resolveSources(name, signal) {
+		for (const source of activeSources) {
+			signal.throwIfAborted();
+			const value = typeof source === "function" ? await source(name, parseIconName(name), { signal }) : sourceValue(source, name);
+			const data = toData(typeof value === "function" ? await value() : value, name);
+			if (data) return data;
+		}
+		return null;
+	}
+	/** Clear cache, requests and subscribers for one key or a predicate match set. */
+	function invalidate(name) {
+		const names = typeof name !== "string" ? /* @__PURE__ */ new Set([
+			...states.keys(),
+			...requests.keys(),
+			...listeners.keys()
+		]) : /* @__PURE__ */ new Set([name]);
+		for (const key of names) {
+			if (typeof name === "function" && !name(key)) continue;
+			const request = requests.get(key);
+			requests.delete(key);
+			request?.controller.abort();
+			states.delete(key);
+			listeners.get(key)?.forEach((listener) => listener());
+		}
+	}
+	function load(name, loadOptions = {}) {
+		if (loadOptions.force) invalidate(name);
+		const pending = requests.get(name);
+		if (pending) return pending.promise;
+		const state = getState(name);
+		if (state.href && !loadOptions.loader) return Promise.resolve(null);
+		const cached = states.get(name);
+		if (delegate && !cached && probe(name) === null && !loadOptions.loader) return delegate.load(name, loadOptions);
+		if (!loadOptions.force && (!cached || cached.expires > Date.now())) {
+			if (state.data) return Promise.resolve(state.data);
+			if (state.status === "missing") return Promise.resolve(null);
+		}
+		if (delegate && state.status !== "error" && probe(name) === null && !loadOptions.loader) return delegate.load(name, loadOptions);
+		const controller = new AbortController();
+		const request = {
+			controller,
+			promise: null
+		};
+		requests.set(name, request);
+		request.promise = new Promise((resolve, reject) => {
+			let started = false;
+			const run = () => {
+				if (controller.signal.aborted) return;
+				started = true;
+				running++;
+				const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`Icon request timed out: ${name}`)), options.timeout ?? 15e3);
+				const abort = () => reject(controller.signal.reason);
+				controller.signal.addEventListener("abort", abort, { once: true });
+				(async () => {
+					try {
+						const data = await resolveSources(name, controller.signal);
+						controller.signal.throwIfAborted();
+						resolve(data ?? (delegate && !loadOptions.loader ? await delegate.load(name, loadOptions) : toData(await (loadOptions.loader ?? loader)(name, parseIconName(name), { signal: controller.signal }), name)));
+					} catch (error) {
+						reject(error);
+					}
+				})();
+				request.promise.finally(() => {
+					clearTimeout(timer);
+					controller.signal.removeEventListener("abort", abort);
+					running--;
+					queue.shift()?.();
+				}).catch(() => {});
+			};
+			controller.signal.addEventListener("abort", () => {
+				if (started) return;
+				const index = queue.indexOf(run);
+				if (index >= 0) queue.splice(index, 1);
+				reject(controller.signal.reason);
+			}, { once: true });
+			queueMicrotask(() => {
+				if (controller.signal.aborted) return;
+				if (running < concurrency) run();
+				else queue.push(run);
+			});
+		}).then((data) => {
+			const symbol = !data && !loadOptions.loader ? reference(name) : null;
+			if (requests.get(name) === request) publish(name, data ? {
+				status: "loaded",
+				data
+			} : symbol ? {
+				status: "referenced",
+				...symbol
+			} : { status: "missing" }, data ? options.ttl ?? 3e5 : options.missingTtl ?? 3e4);
+			return data;
+		}).catch((cause) => {
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			if (requests.get(name) === request) publish(name, {
+				status: "error",
+				error
+			}, 0);
+			throw error;
+		}).finally(() => {
+			if (requests.get(name) === request) requests.delete(name);
+			trim();
+		});
+		publish(name, { status: "loading" });
+		return request.promise;
+	}
+	return {
+		sources,
+		api,
+		getState,
+		load,
+		retry: (name) => load(name, { force: true }),
+		invalidate,
+		async preload(names) {
+			await Promise.all(names.map((name) => load(name)));
+		},
+		snapshot() {
+			const parentData = Object.entries(delegate?.snapshot() ?? {}).filter(([name]) => {
+				try {
+					return probe(name) === null;
+				} catch {
+					return false;
+				}
+			});
+			return Object.fromEntries([...parentData, ...[...states].flatMap(([name, { state }]) => state.data ? [[name, state.data]] : [])]);
+		},
+		subscribe(name, listener) {
+			const subscribers = listeners.get(name) ?? /* @__PURE__ */ new Set();
+			listeners.set(name, subscribers);
+			subscribers.add(listener);
+			const unsubscribeParent = delegate?.subscribe(name, listener);
+			return () => {
+				unsubscribeParent?.();
+				subscribers.delete(listener);
+				if (!subscribers.size) listeners.delete(name);
+				trim();
+			};
+		}
+	};
+}
+//#endregion
+export { createIconStore, toData };

package/dist/svg-data.d.ts

@@ -0,0 +1,2 @@
+import { n as elementDataToIcon, r as renderSvgData, t as createSvgSymbolDocument } from "./data-DtdeiZ5o.js";
+export { createSvgSymbolDocument, elementDataToIcon, renderSvgData };

package/dist/svg-data.js

@@ -0,0 +1,2 @@
+import { n as elementDataToIcon, r as renderSvgData, t as createSvgSymbolDocument } from "./data-N59s4mFY.js";
+export { createSvgSymbolDocument, elementDataToIcon, renderSvgData };

package/dist/svg.d.ts

@@ -0,0 +1,19 @@
+import { n as IconData } from "./icon-data-HGvJGwoB.js";
+//#region src/svg/index.d.ts
+/** Built-in drawing coordinates. Rendered pixel dimensions are controlled by size. */
+declare const iconViewBoxes: Readonly<{
+  readonly default: "0 0 24 24";
+  readonly flagSquare: "0 0 512 512";
+  readonly flagLandscape: "0 0 640 480";
+}>;
+declare function getIconViewBox(name?: string): "0 0 24 24" | "0 0 512 512" | "0 0 640 480";
+/** Only named Flag assets follow the filename contract; direct Data stays untouched. */
+declare function withIconViewBox(data: IconData, name?: string): IconData;
+/** Component CSS contract; low-level rewriting is shared with build tools. */
+declare function configurableStrokeBody(body: string, variable?: string): string;
+/** Let inherited configuration override widths inside inline and external SVG. */
+declare function rewriteStrokeWidths(body: string, variable: string): string;
+/** Rewrite SVG IDs and references using a caller-provided instance prefix. */
+declare function replaceSvgIds(body: string, prefix: string): string;
+//#endregion
+export { configurableStrokeBody, getIconViewBox, iconViewBoxes, replaceSvgIds, rewriteStrokeWidths, withIconViewBox };

package/dist/svg.js

@@ -0,0 +1,49 @@
+//#region src/svg/index.ts
+/** Built-in drawing coordinates. Rendered pixel dimensions are controlled by size. */
+const iconViewBoxes = Object.freeze({
+	default: "0 0 24 24",
+	flagSquare: "0 0 512 512",
+	flagLandscape: "0 0 640 480"
+});
+function getIconViewBox(name) {
+	if (!name?.startsWith("flag:")) return iconViewBoxes.default;
+	return /-(circle|square)$/.test(name) ? iconViewBoxes.flagSquare : iconViewBoxes.flagLandscape;
+}
+/** Only named Flag assets follow the filename contract; direct Data stays untouched. */
+function withIconViewBox(data, name) {
+	const viewBox = getIconViewBox(name);
+	if (viewBox === iconViewBoxes.default) return data;
+	const [, , width, height] = viewBox.split(" ").map(Number);
+	return {
+		...data,
+		left: 0,
+		top: 0,
+		width,
+		height
+	};
+}
+/** Component CSS contract; low-level rewriting is shared with build tools. */
+function configurableStrokeBody(body, variable = "--icones-stroke-width") {
+	return rewriteStrokeWidths(body, variable);
+}
+/** Let inherited configuration override widths inside inline and external SVG. */
+function rewriteStrokeWidths(body, variable) {
+	const strokes = [...body.matchAll(/\bstroke\s*=\s*(["'])(.*?)\1/gi)].map((match) => match[2]);
+	const styledStrokes = [...body.matchAll(/(?:^|[;"'])\s*stroke\s*:\s*([^;"']+)/gi)].map((match) => match[1]);
+	if ([...strokes, ...styledStrokes].some((stroke) => !/^(currentcolor|none|inherit)$/i.test(stroke.trim()))) return body;
+	return body.replace(/\bstroke-width\s*=\s*(["'])(.*?)\1/g, (_match, quote, width) => `stroke-width=${quote}${strokeValue(width, variable)}${quote}`).replace(/\bstyle\s*=\s*(["'])(.*?)\1/g, (_match, quote, style) => `style=${quote}${style.replace(/(^|;)\s*stroke-width\s*:\s*([^;]+)/g, (_declaration, separator, width) => `${separator}stroke-width:${strokeValue(width, variable)}`)}${quote}`);
+}
+function strokeValue(width, variable) {
+	return width.includes(variable) ? width : `var(${variable}, ${width.trim()})`;
+}
+/** Rewrite SVG IDs and references using a caller-provided instance prefix. */
+function replaceSvgIds(body, prefix) {
+	const ids = new Set([...body.matchAll(/\bid\s*=\s*(["'])(.*?)\1/g)].map((match) => match[2]));
+	for (const id of ids) {
+		const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		body = body.replace(new RegExp(`([#;"'])${escaped}([)"']|\\.[a-z])`, "g"), (_match, before, after) => before + prefix + id + after);
+	}
+	return body;
+}
+//#endregion
+export { configurableStrokeBody, getIconViewBox, iconViewBoxes, replaceSvgIds, rewriteStrokeWidths, withIconViewBox };

package/dist/symbol.d.ts

@@ -0,0 +1,7 @@
+import { RuntimeIcon } from "./types.js";
+import { c as IconSymbolApiOptions } from "./loaders-DxxA-L6t.js";
+//#region src/runtime/symbol.d.ts
+/** URL resolution only: never fetches or evaluates a data source. Safe during SSR. */
+declare function resolveIconSymbol(api: IconSymbolApiOptions, name: string): RuntimeIcon | null;
+//#endregion
+export { resolveIconSymbol };

package/dist/symbol.js

@@ -0,0 +1,22 @@
+import { parseViewBox } from "./view-box.js";
+import { parseIconName } from "./data.js";
+import { getIconViewBox } from "./svg.js";
+//#region src/runtime/symbol.ts
+/** URL resolution only: never fetches or evaluates a data source. Safe during SSR. */
+function resolveIconSymbol(api, name) {
+	const parsed = parseIconName(name);
+	if (!api.url && (!name.includes(":") || !parsed || parsed.provider)) return null;
+	const base = (api.baseUrl ?? "/icons").replace(/\/+$/, "");
+	const href = String(api.url ? api.url(name, parsed) : `${base}/${encodeURIComponent(parsed.prefix)}/${encodeURIComponent(parsed.name)}.svg#icon`);
+	const url = new URL(href, "https://icones.invalid/");
+	if (!/^https?:$/.test(url.protocol) || !url.hash || url.hash === "#") throw new TypeError("Symbol URL must use HTTP(S) or a relative path and include a fragment ID.");
+	const viewBox = api.viewBox ?? getIconViewBox(name);
+	const dimensions = parseViewBox(viewBox);
+	if (!dimensions) throw new TypeError("Invalid symbol viewBox.");
+	return {
+		href,
+		viewBox: dimensions.join(" ")
+	};
+}
+//#endregion
+export { resolveIconSymbol };

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+import { i as ElementNode, n as ElementChild, r as ElementData, t as ElementAttributes } from "./element-types-C9jOyda4.js";
+import { i as IconSet, n as IconData } from "./icon-data-HGvJGwoB.js";
+import { IconName, IconName as IconName$1, IconNamesBySet, IconSetName } from "@icones/names";
+//#region src/runtime/types.d.ts
+type Data = IconData | ElementData;
+type Name = IconName$1 | (string & {});
+type RuntimeIcon = {
+  data?: Data;
+  href?: string;
+  viewBox?: string;
+  fill?: string;
+};
+type ParsedIconName = {
+  provider: string;
+  prefix: string;
+  name: string;
+};
+type IconLoaderResult = Data | IconSet | null | undefined;
+type IconLoader = (name: string, parsedName: ParsedIconName | null, request?: {
+  signal: AbortSignal;
+}) => IconLoaderResult | Promise<IconLoaderResult>;
+type IconLoadStatus = "idle" | "loading" | "loaded" | "referenced" | "missing" | "error";
+type IconLoadState = RuntimeIcon & {
+  status: IconLoadStatus;
+  error?: Error;
+};
+type IconSource = string | Data;
+type IconSources = Readonly<Record<string, Data | IconSet | (() => IconLoaderResult | Promise<IconLoaderResult>)>> | IconLoader;
+//#endregion
+export { Data, type ElementAttributes, type ElementChild, type ElementData, type ElementNode, type IconData, IconLoadState, IconLoadStatus, IconLoader, IconLoaderResult, type IconName, type IconNamesBySet, type IconSet, type IconSetName, IconSource, IconSources, Name, ParsedIconName, RuntimeIcon };

package/dist/view-box.d.ts

@@ -0,0 +1,6 @@
+//#region src/svg/view-box.d.ts
+type ViewBox = [left: number, top: number, width: number, height: number];
+/** Parse finite SVG coordinates with positive dimensions. Callers supply error context. */
+declare function parseViewBox(value: string): ViewBox | null;
+//#endregion
+export { ViewBox, parseViewBox };

package/dist/view-box.js

@@ -0,0 +1,9 @@
+//#region src/svg/view-box.ts
+/** Parse finite SVG coordinates with positive dimensions. Callers supply error context. */
+function parseViewBox(value) {
+	const dimensions = value.trim().split(/[\s,]+/).map(Number);
+	if (dimensions.length !== 4 || !dimensions.every(Number.isFinite) || dimensions[2] <= 0 || dimensions[3] <= 0) return null;
+	return dimensions;
+}
+//#endregion
+export { parseViewBox };