@icones/core 0.0.1

package/dist/loaders.js

@@ -0,0 +1,112 @@
+import { isIconData, isIconSet, readIconSet } from "./icon-data.js";
+import { isElementData } from "./elements.js";
+import { parseIconName, resolveIconSetData } from "./data.js";
+import { mergeSetOptions, resolveSetOption } from "./set-options.js";
+//#region src/runtime/loaders.ts
+/** Default first-party static icon service used by the framework adapters. */
+const defaultIconServiceDomain = "icones.go-slim.dev";
+/** Determine whether an API config is a shared map or a direct API value. */
+function isIconApiMap(api) {
+	if (typeof api !== "object" || api === null) return false;
+	if (Object.hasOwn(api, "default")) return true;
+	return Object.entries(api).some(([key, value]) => {
+		switch (key) {
+			case "type": return value !== void 0 && value !== "fetch" && value !== "symbol";
+			case "baseUrl":
+			case "viewBox": return value !== void 0 && typeof value !== "string";
+			case "url":
+			case "fetch":
+			case "transform": return value !== void 0 && typeof value !== "function";
+			case "requestInit": return value !== void 0 && (typeof value !== "object" || value === null);
+			default: return true;
+		}
+	});
+}
+function mergeIconApi(parent, next) {
+	return mergeSetOptions(parent, next, isIconApiMap);
+}
+function resolveIconApi(api, name) {
+	return resolveSetOption(api, parseIconName(name)?.prefix, isIconApiMap);
+}
+/** Check whether a resolved API entry points to an external symbol sprite. */
+function isSymbolApi(api) {
+	return typeof api === "object" && api.type === "symbol";
+}
+/** Build a fetch-based icon loader from API option object, URL or callback. */
+function createIconApiLoader(api = false) {
+	if (api === false) return () => null;
+	if (typeof api === "function") return api;
+	const options = typeof api === "string" ? { baseUrl: api } : api;
+	const baseUrl = trimTrailingSlash(options.baseUrl ?? "/icons");
+	return async (name, parsed, request) => {
+		if (!options.url && (!name.includes(":") || !parsed || parsed.provider)) return null;
+		const resolved = parsed ?? parseIconName(name);
+		const url = options.url ? options.url(name, parsed) : `${baseUrl}/${encodeURIComponent(resolved.prefix)}.json?icons=${encodeURIComponent(resolved.name)}`;
+		const response = await (options.fetch ?? globalThis.fetch)(url, {
+			...options.requestInit,
+			signal: request?.signal && options.requestInit?.signal ? AbortSignal.any([request.signal, options.requestInit.signal]) : request?.signal ?? options.requestInit?.signal
+		});
+		if (response.status === 404) return null;
+		if (!response.ok) throw new Error(`Unable to load icon ${name} (${response.status}).`);
+		const json = await response.json();
+		const result = options.transform ? await options.transform(json, name) : parseLoaderResult(json, name);
+		return !options.url && isIconSet(result) ? resolveIconSetData(result, name) : result;
+	};
+}
+/** Opt in to mirrored static assets: <base>/<set>/data/<slug>.json. */
+function createStaticIconLoader(options = {}) {
+	const normalized = typeof options === "string" ? { baseUrl: options } : options;
+	const base = trimTrailingSlash(normalized.baseUrl ?? "/icons");
+	const load = createIconApiLoader({
+		...normalized,
+		url: (_name, parsed) => `${base}/${encodeURIComponent(parsed.prefix)}/data/${encodeURIComponent(parsed.name)}.json`
+	});
+	return (name, parsed, request) => {
+		const resolved = parsed ?? parseIconName(name);
+		const segment = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+		if (!name.includes(":") || !resolved || resolved.provider || !segment.test(resolved.prefix) || !segment.test(resolved.name)) return null;
+		return load(name, resolved, request);
+	};
+}
+/** Load <set>:<name> from https://<set>.<domain>/data/<name>.json. */
+function createIconesIconLoader(options = {}) {
+	const domain = options.domain ?? "icones.go-slim.dev";
+	if (domain.length > 253 || !domain.includes(".") || domain.split(".").some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label))) throw new TypeError(`Invalid icon service domain: ${domain}`);
+	const load = createIconApiLoader({
+		fetch: options.fetch,
+		requestInit: options.requestInit,
+		url: (_name, parsed) => `https://${parsed.prefix}.${domain}/data/${encodeURIComponent(parsed.name)}.json`
+	});
+	return (name, parsed, request) => {
+		const resolved = parsed ?? parseIconName(name);
+		const segment = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+		if (!name.includes(":") || !resolved || resolved.provider || !segment.test(resolved.prefix) || !segment.test(resolved.name)) return null;
+		return load(name, resolved, request);
+	};
+}
+function createFileIconLoader(options = {}) {
+	const normalizedOptions = typeof options === "string" ? { baseUrl: options } : options;
+	const baseUrl = trimTrailingSlash(normalizedOptions.baseUrl ?? "/icons");
+	const extension = normalizedOptions.extension ?? ".json";
+	const request = normalizedOptions.fetch ?? globalThis.fetch;
+	return async (name, _parsed, context) => {
+		const response = await request(`${baseUrl}/${encodeURIComponent(name)}${extension}`, { signal: context?.signal });
+		if (response.status === 404) return null;
+		if (!response.ok) throw new Error(`Unable to load icon ${name} (${response.status}).`);
+		return parseLoaderResult(await response.json(), name);
+	};
+}
+/** Unconfigured adapters fall back to the first-party per-collection service. */
+const defaultIconLoader = createIconesIconLoader();
+/** Validate file/network responses and keep only supported payload shapes. */
+function parseLoaderResult(value, name) {
+	if (isElementData(value)) return value;
+	if (isIconData(value)) return value;
+	if (isIconSet(value)) return readIconSet(value);
+	throw new Error(`Icon data file for ${name} is invalid.`);
+}
+function trimTrailingSlash(value) {
+	return value.replace(/\/+$/, "");
+}
+//#endregion
+export { createFileIconLoader, createIconApiLoader, createIconesIconLoader, createStaticIconLoader, defaultIconLoader, defaultIconServiceDomain, isSymbolApi, mergeIconApi, resolveIconApi };

package/dist/manifest.d.ts

@@ -0,0 +1,9 @@
+import { IconManifest, IconSource, ManifestEntry } from "./resource-types.js";
+//#region src/resources/manifest.d.ts
+declare function readIconManifest(value: unknown, prefix?: string): IconManifest;
+declare function manifestEntries(manifest: IconManifest): ManifestEntry[];
+declare function createIconManifest(prefix: string): IconManifest;
+declare function addManifestEntry(manifest: IconManifest, entry: ManifestEntry): void;
+declare function serializeManifest(manifest: IconManifest, variantOrder?: readonly string[]): string;
+//#endregion
+export { type IconManifest, type IconSource, type ManifestEntry, addManifestEntry, createIconManifest, manifestEntries, readIconManifest, serializeManifest };

package/dist/manifest.js

@@ -0,0 +1,87 @@
+//#region src/resources/manifest.ts
+const segment = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function readIconManifest(value, prefix) {
+	if (!object(value) || value.version !== 1 || typeof value.prefix !== "string" || !segment.test(value.prefix) || prefix !== void 0 && value.prefix !== prefix || !object(value.variants)) throw new TypeError(`Invalid icon manifest: ${prefix ?? "unknown"}`);
+	const names = /* @__PURE__ */ new Set();
+	if (value.variantAliases !== void 0) {
+		if (!object(value.variantAliases) || Object.entries(value.variantAliases).some(([variant, alias]) => !["outline", "solid"].includes(variant) || typeof alias !== "string" || !segment.test(alias)) || new Set(Object.values(value.variantAliases)).size !== Object.keys(value.variantAliases).length) throw new TypeError("Invalid manifest variant aliases.");
+	}
+	for (const [variant, categories] of Object.entries(value.variants)) {
+		if (!segment.test(variant) || !object(categories)) throw new TypeError("Invalid manifest variant.");
+		for (const [category, files] of Object.entries(categories)) {
+			if (!segment.test(category) || !object(files) || !Array.isArray(files.json) || !Array.isArray(files.svg)) throw new TypeError("Invalid manifest category.");
+			const json = files.json;
+			const svg = files.svg;
+			if (json.length !== svg.length) throw new TypeError("Manifest JSON/SVG inventory must match.");
+			const symbols = new Set(svg);
+			for (const file of json) {
+				if (typeof file !== "string" || !file.endsWith(".json") || !segment.test(file.slice(0, -5))) throw new TypeError("Manifest filenames must be flat icon slugs.");
+				const slug = file.slice(0, -5);
+				if (names.has(slug)) throw new TypeError(`Duplicate manifest icon: ${value.prefix}:${slug}`);
+				if (!symbols.delete(slug + ".svg")) throw new TypeError(`Missing manifest symbol: ${slug}`);
+				names.add(slug);
+			}
+			if (symbols.size) throw new TypeError("Invalid manifest symbol inventory.");
+		}
+	}
+	if (value.aliases !== void 0) {
+		if (!object(value.aliases)) throw new TypeError("Invalid manifest aliases.");
+		for (const [alias, rule] of Object.entries(value.aliases)) if (!segment.test(alias) || alias === value.prefix || !object(rule) || typeof rule.suffix !== "string" || rule.suffix !== "" && !/^-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(rule.suffix)) throw new TypeError("Invalid manifest alias rule.");
+	}
+	if (value.sources !== void 0 && (!object(value.sources) || Object.entries(value.sources).some(([key, source]) => !segment.test(key) || !object(source) || typeof source.url !== "string"))) throw new TypeError("Invalid manifest sources.");
+	return value;
+}
+function manifestEntries(manifest) {
+	return Object.entries(manifest.variants).flatMap(([variant, categories]) => Object.entries(categories).flatMap(([category, files]) => files.json.map((file) => ({
+		prefix: manifest.prefix,
+		slug: file.slice(0, -5),
+		variant,
+		...Object.hasOwn(manifest.variantAliases ?? {}, variant) ? { variantAlias: manifest.variantAliases[variant] } : {},
+		category
+	}))));
+}
+function createIconManifest(prefix) {
+	return {
+		version: 1,
+		prefix,
+		variants: Object.create(null)
+	};
+}
+function addManifestEntry(manifest, entry) {
+	if (manifest.prefix !== entry.prefix || ![
+		entry.prefix,
+		entry.slug,
+		entry.variant,
+		entry.category
+	].every((part) => segment.test(part)) || entry.variantAlias !== void 0 && (!["outline", "solid"].includes(entry.variant) || !segment.test(entry.variantAlias))) throw new TypeError("Invalid manifest entry.");
+	if (entry.variantAlias !== void 0) manifest.variantAliases = {
+		...manifest.variantAliases,
+		[entry.variant]: entry.variantAlias
+	};
+	for (const categories of Object.values(manifest.variants)) for (const files of Object.values(categories)) {
+		files.json = files.json.filter((file) => file !== entry.slug + ".json");
+		files.svg = files.svg.filter((file) => file !== entry.slug + ".svg");
+	}
+	const categories = Object.hasOwn(manifest.variants, entry.variant) ? manifest.variants[entry.variant] : manifest.variants[entry.variant] = Object.create(null);
+	const files = Object.hasOwn(categories, entry.category) ? categories[entry.category] : categories[entry.category] = {
+		json: [],
+		svg: []
+	};
+	files.json.push(entry.slug + ".json");
+	files.svg.push(entry.slug + ".svg");
+}
+function serializeManifest(manifest, variantOrder = []) {
+	const order = variantOrder;
+	const variants = Object.fromEntries(Object.entries(manifest.variants).sort(([a], [b]) => (order.indexOf(a) < 0 ? 99 : order.indexOf(a)) - (order.indexOf(b) < 0 ? 99 : order.indexOf(b)) || a.localeCompare(b)).map(([variant, categories]) => [variant, Object.fromEntries(Object.entries(categories).filter(([, files]) => files.json.length).sort(([a], [b]) => a.localeCompare(b)).map(([category, files]) => [category, {
+		json: [...files.json].sort(),
+		svg: [...files.svg].sort()
+	}]))]).filter(([, categories]) => Object.keys(categories).length));
+	return JSON.stringify(readIconManifest({
+		...manifest,
+		variants,
+		...manifest.variantAliases ? { variantAliases: Object.fromEntries(Object.entries(manifest.variantAliases).sort(([a], [b]) => a.localeCompare(b))) } : {}
+	}), null, 2) + "\n";
+}
+//#endregion
+export { addManifestEntry, createIconManifest, manifestEntries, readIconManifest, serializeManifest };

package/dist/presentation.d.ts

@@ -0,0 +1,94 @@
+import { Data, IconLoadState, IconLoader, Name } from "./types.js";
+import { n as IconSetOptions, t as IconSetMap } from "./set-options-C2BMGh-r.js";
+import { n as DefaultSizeName, t as CSSSize } from "./sizes-CMxyEIpX.js";
+//#region src/runtime/presentation.d.ts
+type IconSize = DefaultSizeName | CSSSize | number;
+type IconDefaultSize<Size extends string | number = IconSize> = IconSetOptions<Size>;
+type IconSizePresets<Preset extends string = string> = Readonly<Partial<Record<Preset, string | number>>>;
+type IconSizeValues<Preset extends string = string> = IconSetOptions<IconSizePresets<Preset>>;
+type IconSourceProps = {
+  name: Name;
+  data?: never;
+  icon?: never;
+} | {
+  data: Data;
+  name?: Name;
+  icon?: never;
+} | {
+  icon: Name | Data;
+  name?: never;
+  data?: never;
+};
+type IconPresentation<Size extends string | number = IconSize> = {
+  size?: Size;
+  width?: string | number;
+  height?: string | number;
+  color?: string;
+  fill?: string;
+  strokeWidth?: number;
+  absoluteStrokeWidth?: boolean;
+  rotate?: number;
+  hFlip?: boolean;
+  vFlip?: boolean;
+  altIcon?: Name | Data;
+  altName?: Name;
+  /** Inline alternative artwork; takes priority over altName. */
+  altData?: Data;
+  showAlt?: boolean;
+  /** An explicit per-icon loader takes priority over collected static names. */
+  loader?: IconLoader;
+  "aria-label"?: string;
+  "aria-hidden"?: boolean | "true" | "false";
+  role?: string;
+};
+type IconOptions<Size extends string | number = IconSize> = IconSourceProps & IconPresentation<Size>;
+type IconAppearance<Size extends string | number = IconSize> = {
+  /** Presets shared by all sets, or per-set presets merged over `default`. */
+  sizeValues?: IconSizeValues;
+  /** A shared size, or set-specific sizes with an optional `default` fallback. */
+  defaultSize?: IconDefaultSize<Size>;
+  strokeWidth?: IconSetOptions<number>;
+  absoluteStrokeWidth?: IconSetOptions<boolean>;
+};
+declare const defaultIconAppearance: {
+  readonly sizeValues: {
+    readonly xs: 12;
+    readonly sm: 16;
+    readonly md: 20;
+    readonly lg: 24;
+    readonly xl: 28;
+  };
+  readonly defaultSize: "md";
+  readonly strokeWidth: 1.5;
+  readonly absoluteStrokeWidth: false;
+};
+/** Child maps merge by set; a scalar replaces every inherited size. */
+declare function mergeIconDefaultSize<Size extends string | number>(parent: IconDefaultSize<Size> | undefined, next: IconDefaultSize<Size> | undefined): IconDefaultSize<Size> | undefined;
+/** Preset dictionaries merge by key, both globally and within each set. */
+declare function mergeIconSizeValues(parent: IconSizeValues | undefined, next: IconSizeValues | undefined): IconSizeValues | undefined;
+declare function mergeIconAppearance<Size extends string | number>(parent: IconAppearance<Size>, next: IconAppearance<Size>): IconAppearance<Size>;
+/** Runtime prop names used to keep component-only options off the SVG element. */
+declare const iconOptionKeys: readonly ["name", "data", "icon", "size", "width", "height", "color", "fill", "strokeWidth", "absoluteStrokeWidth", "rotate", "hFlip", "vFlip", "altIcon", "altName", "altData", "showAlt", "loader", "aria-label", "aria-hidden", "role"];
+type IconSelectionProps = IconSourceProps & Pick<IconPresentation, "altIcon" | "altName" | "altData" | "showAlt">;
+/** Keep selection pure: rendering the already-selected source must not warn again. */
+declare function selectIconSource(props: IconSelectionProps): {
+  source: Data | Name;
+  name: Name | undefined;
+};
+/** Validate new data references; report each conflict once until resolved, per instance. */
+declare function createIconSourceValidator(): (props: IconSelectionProps) => void;
+type IconRenderResult = {
+  attributes: Record<string, string | number | boolean | undefined>;
+  body: string;
+  style: Record<string, string | number | undefined>;
+  available: boolean;
+};
+/**
+ * Pure SVG rendering shared by framework adapters.
+ * `instanceId` must be stable across server and client hydration.
+ */
+declare function renderIcon(state: IconLoadState, props: IconOptions<string | number>, config?: IconAppearance<string | number>, instanceId?: string): IconRenderResult;
+/** Serialize only style values; framework adapters still escape the HTML attribute. */
+declare function iconStyleText(style: IconRenderResult["style"]): string;
+//#endregion
+export { IconAppearance, IconDefaultSize, IconOptions, IconPresentation, IconRenderResult, type IconSetMap, type IconSetOptions, IconSize, IconSizePresets, IconSizeValues, IconSourceProps, createIconSourceValidator, defaultIconAppearance, iconOptionKeys, iconStyleText, mergeIconAppearance, mergeIconDefaultSize, mergeIconSizeValues, renderIcon, selectIconSource };

package/dist/presentation.js

@@ -0,0 +1,189 @@
+import { isIconData } from "./icon-data.js";
+import { n as elementDataToIcon, r as renderSvgData } from "./data-N59s4mFY.js";
+import { isElementData } from "./elements.js";
+import { parseIconName } from "./data.js";
+import { mergeSetOptions, ownValue, resolveSetOption } from "./set-options.js";
+import { configurableStrokeBody, getIconViewBox, replaceSvgIds, withIconViewBox } from "./svg.js";
+//#region src/runtime/presentation.ts
+const defaultIconAppearance = {
+	sizeValues: {
+		xs: 12,
+		sm: 16,
+		md: 20,
+		lg: 24,
+		xl: 28
+	},
+	defaultSize: "md",
+	strokeWidth: 1.5,
+	absoluteStrokeWidth: false
+};
+/** Child maps merge by set; a scalar replaces every inherited size. */
+function mergeIconDefaultSize(parent, next) {
+	return mergeSetOptions(parent, next);
+}
+function sourceSet(source) {
+	return typeof source === "string" ? parseIconName(source)?.prefix : void 0;
+}
+function isSizeValuesMap(values) {
+	return Object.values(values).some((value) => typeof value === "object" && value !== null);
+}
+/** Preset dictionaries merge by key, both globally and within each set. */
+function mergeIconSizeValues(parent, next) {
+	if (next === void 0) return parent;
+	if (!parent) return next;
+	if (!isSizeValuesMap(parent) && !isSizeValuesMap(next)) return {
+		...parent,
+		...next
+	};
+	const inherited = isSizeValuesMap(parent) ? parent : { default: parent };
+	const overrides = isSizeValuesMap(next) ? next : { default: next };
+	const result = { ...inherited };
+	for (const [set, values] of Object.entries(overrides)) if (values !== void 0) Object.defineProperty(result, set, {
+		value: {
+			...ownValue(inherited, set),
+			...values
+		},
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	return result;
+}
+function mergeIconAppearance(parent, next) {
+	return {
+		sizeValues: mergeIconSizeValues(parent.sizeValues, next.sizeValues),
+		defaultSize: mergeIconDefaultSize(parent.defaultSize, next.defaultSize),
+		strokeWidth: mergeSetOptions(parent.strokeWidth, next.strokeWidth),
+		absoluteStrokeWidth: mergeSetOptions(parent.absoluteStrokeWidth, next.absoluteStrokeWidth)
+	};
+}
+/** Resolve a size preset from either shared map or per-set defaults. */
+function resolveSizeValue(values, size, set) {
+	if (!values) return void 0;
+	if (!isSizeValuesMap(values)) return ownValue(values, size);
+	return ownValue(ownValue(values, set), size) ?? ownValue(ownValue(values, "default"), size);
+}
+/** Runtime prop names used to keep component-only options off the SVG element. */
+const iconOptionKeys = [
+	"name",
+	"data",
+	"icon",
+	"size",
+	"width",
+	"height",
+	"color",
+	"fill",
+	"strokeWidth",
+	"absoluteStrokeWidth",
+	"rotate",
+	"hFlip",
+	"vFlip",
+	"altIcon",
+	"altName",
+	"altData",
+	"showAlt",
+	"loader",
+	"aria-label",
+	"aria-hidden",
+	"role"
+];
+/** Keep selection pure: rendering the already-selected source must not warn again. */
+function selectIconSource(props) {
+	const alternative = props.altData ?? props.altIcon ?? props.altName;
+	if (props.showAlt && alternative != null) return {
+		source: alternative,
+		name: props.altData != null ? props.altName : void 0
+	};
+	return {
+		source: props.data ?? props.icon ?? props.name ?? "",
+		name: props.data != null ? props.name : void 0
+	};
+}
+function validateInlineData(value, prop) {
+	if (value != null && !Array.isArray(value) && !isIconData(value)) throw new TypeError(`[icones] "${prop}" must contain a single icon's data. Register collections with "sources" and select an icon with "${prop === "data" ? "name" : "altName"}".`);
+}
+/** Validate new data references; report each conflict once until resolved, per instance. */
+function createIconSourceValidator() {
+	let primaryConflict = false;
+	let alternativeConflict = false;
+	let previousData;
+	let previousAltData;
+	return (props) => {
+		if (props.data !== previousData) validateInlineData(props.data, "data");
+		if (props.altData !== previousAltData) validateInlineData(props.altData, "altData");
+		previousData = props.data;
+		previousAltData = props.altData;
+		const primary = props.name != null && props.data != null;
+		const alternative = props.altName != null && props.altData != null;
+		if (primary && !primaryConflict) console.error("[icones] \"name\" and \"data\" were both provided. \"data\" takes priority; pass only one of them.");
+		if (alternative && !alternativeConflict) console.error("[icones] \"altName\" and \"altData\" were both provided. \"altData\" takes priority; pass only one of them.");
+		primaryConflict = primary;
+		alternativeConflict = alternative;
+	};
+}
+function numericLength(value) {
+	return typeof value === "number" ? value : /^\d+(\.\d+)?(px)?$/.test(value) ? Number.parseFloat(value) : NaN;
+}
+/**
+* Pure SVG rendering shared by framework adapters.
+* `instanceId` must be stable across server and client hydration.
+*/
+function renderIcon(state, props, config = defaultIconAppearance, instanceId = "icon") {
+	const { source, name } = selectIconSource(props);
+	const set = sourceSet(source);
+	const sourceName = typeof source === "string" ? source : void 0;
+	const size = props.size ?? resolveSetOption(config.defaultSize, set) ?? defaultIconAppearance.defaultSize;
+	const sizeValue = typeof size === "number" ? size : resolveSizeValue(config.sizeValues, size, set) ?? ownValue(defaultIconAppearance.sizeValues, size) ?? size;
+	const width = props.size === void 0 ? props.width ?? sizeValue : sizeValue;
+	const height = props.size === void 0 ? props.height ?? sizeValue : sizeValue;
+	const rawData = state.data;
+	const tuples = isElementData(rawData);
+	let data = tuples ? elementDataToIcon([...rawData.filter(([, attrs]) => attrs.opacity !== void 0), ...rawData.filter(([, attrs]) => attrs.opacity === void 0)], props.fill ?? state.fill ?? "none") : rawData;
+	if (data) data = withIconViewBox(data, sourceName);
+	if (state.href) {
+		const [left, top, w, h] = (state.viewBox ?? getIconViewBox(sourceName)).split(" ").map(Number);
+		data = {
+			left,
+			top,
+			width: w,
+			height: h,
+			body: `<use href="${state.href.replaceAll("&", "&amp;").replaceAll("\"", "&quot;")}" width="${w}" height="${h}"/>`
+		};
+	}
+	const rendered = data ? renderSvgData(data, {
+		...props.rotate === void 0 ? {} : { rotate: props.rotate },
+		...props.hFlip === void 0 ? {} : { hFlip: props.hFlip },
+		...props.vFlip === void 0 ? {} : { vFlip: props.vFlip }
+	}) : void 0;
+	const viewBox = rendered?.viewBox ?? getIconViewBox(sourceName);
+	const [, , boxWidth, boxHeight] = viewBox.split(" ").map(Number);
+	const scale = Math.min(numericLength(width) / boxWidth, numericLength(height) / boxHeight);
+	const stroke = props.strokeWidth ?? resolveSetOption(config.strokeWidth, set) ?? defaultIconAppearance.strokeWidth;
+	const strokeWidth = (props.absoluteStrokeWidth ?? resolveSetOption(config.absoluteStrokeWidth, set) ?? defaultIconAppearance.absoluteStrokeWidth) && scale > 0 ? stroke / scale : stroke * Math.max(boxWidth, boxHeight) / 24;
+	return {
+		available: !!rendered,
+		attributes: {
+			xmlns: "http://www.w3.org/2000/svg",
+			"xmlns:xlink": "http://www.w3.org/1999/xlink",
+			width,
+			height,
+			viewBox,
+			fill: props.fill ?? state.fill ?? (tuples ? "none" : "currentColor"),
+			color: props.color ?? "currentColor",
+			"stroke-width": strokeWidth,
+			"aria-label": props["aria-label"],
+			"aria-hidden": props["aria-hidden"] ?? (props["aria-label"] !== void 0 || props.role !== void 0 ? void 0 : true),
+			role: props.role,
+			"data-icon": typeof source === "string" ? source : name,
+			"data-state": state.status
+		},
+		body: rendered ? replaceSvgIds(configurableStrokeBody(rendered.body), "icon-" + instanceId.replace(/[^a-zA-Z0-9_-]/g, "") + "-") : "",
+		style: { "--icones-stroke-width": strokeWidth }
+	};
+}
+/** Serialize only style values; framework adapters still escape the HTML attribute. */
+function iconStyleText(style) {
+	return Object.entries(style).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`).join(";");
+}
+//#endregion
+export { createIconSourceValidator, defaultIconAppearance, iconOptionKeys, iconStyleText, mergeIconAppearance, mergeIconDefaultSize, mergeIconSizeValues, renderIcon, selectIconSource };

package/dist/registry.d.ts

@@ -0,0 +1,25 @@
+import { t as isElementData } from "./elements-DLSCanEZ.js";
+import { i as IconSet, o as isIconData, s as isIconSet } from "./icon-data-HGvJGwoB.js";
+import { Data, IconLoadState, IconLoader } from "./types.js";
+import { n as resolveIconSetData, t as parseIconName } from "./sources-CXcG9DjB.js";
+import { IconStore } from "./store.js";
+//#region src/runtime/registry.d.ts
+/** Global source registry used by default imports and explicit registrations. */
+declare const registeredSources: Record<string, Data | IconSet>;
+declare const registryStore: IconStore;
+/** Resolve bare icon names to provider-qualified names when registered with a set prefix. */
+declare function registeredName(name: string): string;
+/** Register a single icon payload into the shared registry cache. */
+declare function addIconData(name: string, data: Data): void;
+/** Register a full icon set and invalidate matching cached keys for hot updates. */
+declare function addIconSet(data: IconSet): void;
+/** Read resolved icon data from registry cache; return null when not found. */
+declare function resolveIconData(name: string): Data | null;
+declare function getIconLoadState(name: string): IconLoadState;
+declare function subscribeIconData(name: string, listener: () => void): () => void;
+/** Load an icon through a custom loader, while preserving registry-level invalidation. */
+declare function loadIconData(name: string, loader: IconLoader): Promise<Data | null>;
+/** Clear one icon or flush all registry sources and set metadata. */
+declare function clearIconData(name?: string): void;
+//#endregion
+export { addIconData, addIconSet, clearIconData, getIconLoadState, isElementData, isIconData, isIconSet, loadIconData, parseIconName, registeredName, registeredSources, registryStore, resolveIconData, resolveIconSetData, subscribeIconData };

package/dist/registry.js

@@ -0,0 +1,66 @@
+import { isIconData, isIconSet } from "./icon-data.js";
+import { isElementData } from "./elements.js";
+import { parseIconName, resolveIconSetData } from "./data.js";
+import { iconLoader } from "./runtime.js";
+import { createIconStore } from "./store.js";
+//#region src/runtime/registry.ts
+/** Global source registry used by default imports and explicit registrations. */
+const registeredSources = Object.create(null);
+const registryStore = createIconStore({
+	sources: registeredSources,
+	api: iconLoader
+});
+const sets = /* @__PURE__ */ new Map();
+/** Resolve bare icon names to provider-qualified names when registered with a set prefix. */
+function registeredName(name) {
+	if (Object.hasOwn(registeredSources, name) || name.includes(":")) return name;
+	const prefix = [...sets.values()].filter((set) => !set.provider).map((set) => set.prefix).sort((a, b) => b.length - a.length).find((prefix) => name.startsWith(prefix + "-"));
+	return prefix ? prefix + ":" + name.slice(prefix.length + 1) : name;
+}
+/** Register a single icon payload into the shared registry cache. */
+function addIconData(name, data) {
+	if (!isIconData(data) && !isElementData(data)) throw new TypeError(`Icon ${name} must contain an SVG body.`);
+	registeredSources[name] = data;
+	registryStore.invalidate(name);
+}
+/** Register a full icon set and invalidate matching cached keys for hot updates. */
+function addIconSet(data) {
+	if (!isIconSet(data)) throw new TypeError("Icon set must contain a prefix and icons map.");
+	sets.set(`${data.provider ?? ""}:${data.prefix}`, data);
+	if (!data.provider) registeredSources[data.prefix] = data;
+	else for (const slug of [...Object.keys(data.icons), ...Object.keys(data.aliases ?? {})]) registeredSources[`@${data.provider}:${data.prefix}:${slug}`] = data;
+	registryStore.invalidate((name) => {
+		const parsed = parseIconName(name);
+		const direct = registeredSources[name];
+		return parsed?.prefix === data.prefix && parsed.provider === (data.provider ?? "") && (!direct || isIconSet(direct));
+	});
+}
+/** Read resolved icon data from registry cache; return null when not found. */
+function resolveIconData(name) {
+	return getIconLoadState(name).data ?? null;
+}
+function getIconLoadState(name) {
+	return registryStore.getState(registeredName(name));
+}
+function subscribeIconData(name, listener) {
+	return registryStore.subscribe(registeredName(name), listener);
+}
+/** Load an icon through a custom loader, while preserving registry-level invalidation. */
+function loadIconData(name, loader) {
+	const key = registeredName(name);
+	return registryStore.load(key, { loader: (_key, _parsed, request) => loader(name, parseIconName(name), request) });
+}
+/** Clear one icon or flush all registry sources and set metadata. */
+function clearIconData(name) {
+	if (name !== void 0) {
+		const key = registeredName(name);
+		delete registeredSources[name];
+		registryStore.invalidate(key);
+		return;
+	}
+	for (const key of Object.keys(registeredSources)) delete registeredSources[key];
+	sets.clear();
+	registryStore.invalidate();
+}
+//#endregion
+export { addIconData, addIconSet, clearIconData, getIconLoadState, isElementData, isIconData, isIconSet, loadIconData, parseIconName, registeredName, registeredSources, registryStore, resolveIconData, resolveIconSetData, subscribeIconData };

package/dist/resource-types.d.ts

@@ -0,0 +1,68 @@
+//#region src/resources/types.d.ts
+type IconSource = {
+  url: string;
+  revision?: string;
+  importedAt?: string;
+  distributionNotice?: string;
+  [key: string]: unknown;
+};
+type IconManifest = {
+  version: 1;
+  prefix: string;
+  /** Style → category → flat filenames, relative to data/ and symbols/. */
+  variants: Record<string, Record<string, {
+    json: string[];
+    svg: string[];
+  }>>;
+  /** Canonical style → upstream display name; never changes icon slugs or sorting. */
+  variantAliases?: Partial<Record<"outline" | "solid", string>>;
+  /** Upstream provenance, keyed by the original source prefix. */
+  sources?: Record<string, IconSource>;
+  /** Optional legacy namespace rules; no per-icon path/alias table. */
+  aliases?: Record<string, {
+    suffix: string;
+  }>;
+};
+type ManifestEntry = {
+  prefix: string;
+  slug: string;
+  variant: string;
+  variantAlias?: string;
+  category: string;
+};
+/** Shared resource metadata, independent of HTTP envelopes and gallery routes. */
+type CatalogIcon = {
+  name: string;
+  prefix: string;
+  category: string;
+  variant?: string;
+  /** Upstream style name for display only; queries use variant. */
+  variantAlias?: string;
+};
+type CatalogFacet = {
+  id: string;
+  count: number;
+  alias?: string;
+};
+type CatalogQuery = {
+  set?: string;
+  category?: string;
+  variant?: string;
+  q?: string;
+  offset?: number;
+  limit?: number;
+  /** Optional exact-name suffix filters, not renderer variants. */
+  suffix?: string;
+  excludeSuffix?: string;
+};
+type CatalogResult = {
+  icons: CatalogIcon[];
+  sets: CatalogFacet[];
+  categories: CatalogFacet[];
+  variants?: CatalogFacet[];
+  total: number;
+  offset: number;
+  nextOffset: number | null;
+};
+//#endregion
+export { CatalogFacet, CatalogIcon, CatalogQuery, CatalogResult, IconManifest, IconSource, ManifestEntry };

package/dist/runtime.d.ts

@@ -0,0 +1,7 @@
+import { IconLoader, RuntimeIcon } from "./types.js";
+//#region src/runtime/compiled.d.ts
+declare const iconLoader: IconLoader;
+declare function registerStatic(name: string, icon: RuntimeIcon): void;
+declare function resolve(name: string): RuntimeIcon | undefined;
+//#endregion
+export { iconLoader, registerStatic, resolve };