@iconify/css-solid 1.0.0

package/dist/id-T2WpjqBw.js

@@ -0,0 +1,42 @@
+/**
+* Regular expression for finding ids
+*/
+const regex = /\sid="(\S+)"/g;
+/**
+* Counters
+*/
+const counters = /* @__PURE__ */ new Map();
+/**
+* Get unique new ID
+*/
+function nextID(id) {
+	id = id.replace(/[0-9]+$/, "") || "a";
+	const count = counters.get(id) || 0;
+	counters.set(id, count + 1);
+	return count ? `${id}${count}` : id;
+}
+/**
+* Replace IDs in SVG output with unique IDs
+*/
+function replaceIDs(body) {
+	const ids = [];
+	let match;
+	while (match = regex.exec(body)) ids.push(match[1]);
+	if (!ids.length) return body;
+	const suffix = "suffix" + (Math.random() * 16777216 | Date.now()).toString(16);
+	ids.forEach((id) => {
+		const newID = nextID(id);
+		const escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		body = body.replace(new RegExp("([#;\"])(" + escapedID + ")([\")]|\\.[a-z])", "g"), "$1" + newID + suffix + "$3");
+	});
+	body = body.replace(new RegExp(suffix, "g"), "");
+	return body;
+}
+/**
+* Clear ID cache
+*/
+function clearIDCache() {
+	counters.clear();
+}
+
+export { replaceIDs as n, clearIDCache as t };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { CSSIconComponentProps, CSSIconComponentViewbox, CSSIconElementProps } from "./props.js";
+import { t as IconifyIconName } from "./name-DNHxp3hA.js";
+import { JSX } from "solid-js";
+/**
+ * Basic icon component, without fallback
+ *
+ * Can be used when you do not need a fallback icon
+ */
+declare function Icon(props: CSSIconElementProps): JSX.Element;
+export { type CSSIconComponentProps, type CSSIconComponentViewbox, type CSSIconElementProps, Icon, type IconifyIconName };

package/dist/index.js

@@ -0,0 +1,83 @@
+import { t as renderContent } from "./content-CDW-lEJw.js";
+import { t as getSizeProps } from "./size-B1gNk5pj.js";
+import { r as setProviderLoader } from "./loaders-DBdOeKSg.js";
+import "./parse-BHmkG8X9.js";
+import { t as createIconifyAPILoader } from "./create-Dw3RUxi7.js";
+import "./storage-B47thT4x.js";
+import "./queue-Bmgy8iLP.js";
+import { t as subscribeToIconData } from "./subscribe-B6af4-2Z.js";
+import { t as renderCSS } from "./status-AnfUd3wQ.js";
+import { createEffect, createMemo, createSignal, splitProps } from "solid-js";
+import { mergeProps, spread, template } from "solid-js/web";
+
+let policy;
+/**
+* Attempt to create policy
+*/
+function createPolicy() {
+	try {
+		policy = window.trustedTypes.createPolicy("iconify", { createHTML: (s) => s });
+	} catch (err) {
+		policy = null;
+	}
+}
+/**
+* Clean up value for innerHTML assignment
+*
+* This code doesn't actually clean up anything.
+* It is intended be used with Iconify icon data, which has already been validated
+*/
+function cleanUpInnerHTML(html) {
+	if (policy === void 0) createPolicy();
+	return policy ? policy.createHTML(html) : html;
+}
+
+setProviderLoader("", createIconifyAPILoader([
+	"https://api.iconify.design",
+	"https://api.simplesvg.com",
+	"https://api.unisvg.com"
+]));
+
+const _tmpl$ = /* @__PURE__ */ template(`<svg xmlns=http://www.w3.org/2000/svg>`);
+/**
+* Basic icon component, without fallback
+*
+* Can be used when you do not need a fallback icon
+*/
+function Icon(props) {
+	const [local, others] = splitProps(props, [
+		"content",
+		"fallback",
+		"width",
+		"height",
+		"viewBox"
+	]);
+	const [iconData, setIconData] = createSignal(null);
+	const [subscriberState, setSubscriber] = createSignal(null);
+	const renderedContent = createMemo(() => renderContent(local.content || ""));
+	const fallbackToRender = createMemo(() => renderCSS && local.content ? "" : local.fallback || "");
+	createEffect(() => {
+		const subscriber = subscribeToIconData(fallbackToRender(), setIconData);
+		setIconData(subscriber.data);
+		setSubscriber(subscriber);
+		return subscriber.unsubscribe;
+	}, []);
+	createEffect(() => {
+		subscriberState()?.change(fallbackToRender());
+	}, [fallbackToRender]);
+	const fallbackIcon = createMemo(() => {
+		const data = iconData();
+		return data ? renderContent(data) : "";
+	});
+	const size = createMemo(() => getSizeProps(local.width, local.height, local.viewBox));
+	const finalContent = createMemo(() => cleanUpInnerHTML(fallbackIcon() || renderedContent()));
+	return (() => {
+		const _el$ = _tmpl$();
+		spread(_el$, mergeProps(size, others, { get innerHTML() {
+			return finalContent();
+		} }), true, false);
+		return _el$;
+	})();
+}
+
+export { Icon };

package/dist/loaders-DBdOeKSg.js

@@ -0,0 +1,22 @@
+const providerSpecificLoaders = Object.create(null);
+const prefixSpecificLoaders = Object.create(null);
+/**
+* Set custom loader for an icon set
+*/
+function setLoader(prefix, loader) {
+	prefixSpecificLoaders[prefix] = loader;
+}
+/**
+* Set custom loader for a provider
+*/
+function setProviderLoader(provider, loader) {
+	providerSpecificLoaders[provider] = loader;
+}
+/**
+* Get loader
+*/
+function getLoader(provider, prefix) {
+	return provider ? providerSpecificLoaders[provider] : prefixSpecificLoaders[prefix] || providerSpecificLoaders[""];
+}
+
+export { setLoader as n, setProviderLoader as r, getLoader as t };

package/dist/name-DNHxp3hA.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Icon name
+ */
+interface IconifyIconName {
+  readonly provider: string;
+  readonly prefix: string;
+  readonly name: string;
+}
+/**
+ * Icon source: icon object without name
+ */
+export { IconifyIconName as t };

package/dist/name-IUXED86s.js

@@ -0,0 +1,58 @@
+/**
+* Expression to test part of icon name.
+*
+* Used when loading icons from Iconify API due to project naming convension.
+* Ignored when using custom icon sets - convension does not apply.
+*/
+const matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/**
+* Convert string icon name to IconifyIconName object.
+*/
+const stringToIcon = (value, validate, allowSimpleName, provider = "") => {
+	const colonSeparated = value.split(":");
+	if (value.slice(0, 1) === "@") {
+		if (colonSeparated.length < 2 || colonSeparated.length > 3) return null;
+		provider = colonSeparated.shift().slice(1);
+	}
+	if (colonSeparated.length > 3 || !colonSeparated.length) return null;
+	if (colonSeparated.length > 1) {
+		const name = colonSeparated.pop();
+		const prefix = colonSeparated.pop();
+		const result = {
+			provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+			prefix,
+			name
+		};
+		return validate && !validateIconName(result) ? null : result;
+	}
+	const name = colonSeparated[0];
+	const dashSeparated = name.split("-");
+	if (dashSeparated.length > 1) {
+		const result = {
+			provider,
+			prefix: dashSeparated.shift(),
+			name: dashSeparated.join("-")
+		};
+		return validate && !validateIconName(result) ? null : result;
+	}
+	if (allowSimpleName && provider === "") {
+		const result = {
+			provider,
+			prefix: "",
+			name
+		};
+		return validate && !validateIconName(result, allowSimpleName) ? null : result;
+	}
+	return null;
+};
+/**
+* Check if icon is valid.
+*
+* This function is not part of stringToIcon because validation is not needed for most code.
+*/
+const validateIconName = (icon, allowSimpleName) => {
+	if (!icon) return false;
+	return !!((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+
+export { stringToIcon as n, matchIconName as t };

package/dist/parse-BHmkG8X9.js

@@ -0,0 +1,104 @@
+import { r as defaultIconTransformations, t as defaultExtendedIconProps } from "./defaults-Chz3Ncto.js";
+import { t as getIconStorage } from "./storage-B47thT4x.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;
+}
+
+/**
+* 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;
+}
+
+/**
+* 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;
+}
+
+/**
+* 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);
+}
+
+/**
+* Extract icons from an icon set
+*
+* Returns list of icons that were found in icon set
+*/
+function parseIconSet(data, callback) {
+	const names = [];
+	if (typeof data !== "object" || typeof data.icons !== "object") return names;
+	if (data.not_found instanceof Array) data.not_found.forEach((name) => {
+		callback(name, null);
+		names.push(name);
+	});
+	const tree = getIconsTree(data);
+	for (const name in tree) {
+		const item = tree[name];
+		if (item) {
+			callback(name, internalGetIconData(data, name, item));
+			names.push(name);
+		}
+	}
+	return names;
+}
+
+/**
+* Add icon set to storage
+*/
+function addIconSetToStorage(data, provider = "") {
+	const added = /* @__PURE__ */ new Set();
+	const storage = getIconStorage(provider, data.prefix);
+	parseIconSet(data, (name, icon) => {
+		storage.update(name, icon);
+		added.add(name);
+	});
+	return added;
+}
+
+export { addIconSetToStorage as t };

package/dist/props.d.ts

@@ -0,0 +1,17 @@
+import { JSX } from "solid-js";
+import { IconifyIcon } from "@iconify/types";
+interface CSSIconComponentViewbox {
+  left?: number;
+  top?: number;
+  width: number;
+  height: number;
+}
+interface CSSIconComponentProps {
+  width?: string;
+  height?: string;
+  viewBox: CSSIconComponentViewbox;
+  content?: string | IconifyIcon;
+  fallback?: string | IconifyIcon;
+}
+interface CSSIconElementProps extends CSSIconComponentProps, Omit<JSX.SvgSVGAttributes<SVGSVGElement>, 'viewBox' | 'width' | 'height' | 'xmlns'> {}
+export { CSSIconComponentProps, CSSIconComponentViewbox, CSSIconElementProps };

package/dist/props.js

@@ -0,0 +1 @@
+export {  };

package/dist/queue-Bmgy8iLP.js

@@ -0,0 +1,135 @@
+import { t as getLoader } from "./loaders-DBdOeKSg.js";
+import { n as stringToIcon, t as matchIconName } from "./name-IUXED86s.js";
+import { t as addIconSetToStorage } from "./parse-BHmkG8X9.js";
+import { r as triggerCallbackAsync, t as getIconStorage } from "./storage-B47thT4x.js";
+
+/**
+* Empty split icon names data
+*/
+function mergeSplitIconNames(data, addData) {
+	for (const provider in addData) {
+		const addProviderData = addData[provider];
+		const providerData = data[provider] || (data[provider] = Object.create(null));
+		for (const prefix in addProviderData) {
+			const prefixes = addProviderData[prefix];
+			if (!providerData[prefix]?.length) providerData[prefix] = prefixes.slice(0);
+			else providerData[prefix] = Array.from(new Set([...prefixes, ...providerData[prefix]]));
+		}
+	}
+}
+
+/**
+* Get list of icon names by provider and prefix
+*/
+function splitIconNames(names, oldData) {
+	const results = oldData || Object.create(null);
+	for (const iconName of names) {
+		const icon = typeof iconName === "string" ? stringToIcon(iconName) : iconName;
+		if (icon) {
+			const providerData = results[icon.provider] || (results[icon.provider] = Object.create(null));
+			const prefixData = providerData[icon.prefix] || (providerData[icon.prefix] = []);
+			if (!prefixData.includes(icon.name)) prefixData.push(icon.name);
+		}
+	}
+	return results;
+}
+
+/**
+* Split icon names into queues
+*/
+function splitForBatchLoading(icons, config) {
+	const { maxCount, maxLength } = config;
+	icons.sort((a, b) => a.localeCompare(b));
+	const results = [];
+	let list = [];
+	let currentLength = 0;
+	for (const name of icons) {
+		const itemLength = name.length + 1;
+		if (currentLength) {
+			if (maxLength && currentLength + itemLength > maxLength || maxCount && list.length >= maxCount) {
+				results.push(list);
+				list = [];
+				currentLength = 0;
+			}
+		}
+		currentLength += itemLength;
+		list.push(name);
+	}
+	if (list.length > 0) results.push(list);
+	return results;
+}
+
+let queue = Object.create(null);
+/**
+* Parse queue
+*/
+function parseQueuedIcons() {
+	const oldQueue = queue;
+	queue = Object.create(null);
+	for (const provider in oldQueue) {
+		const providerData = oldQueue[provider];
+		for (const prefix in providerData) {
+			const names = providerData[prefix];
+			if (names.length) {
+				const storage = getIconStorage(provider, prefix);
+				const loader = getLoader(provider, prefix);
+				const allowReload = loader?.allowReload ?? false;
+				const validateNames = loader?.validateNames ?? true;
+				const namesToLoad = [];
+				names.forEach((name) => {
+					if (storage.pending.has(name)) return;
+					if (storage.icons[name] || storage.missing.has(name)) {
+						if (!allowReload) return;
+					}
+					if (!loader || validateNames && !matchIconName.test(name)) {
+						storage.update(name, null);
+						return;
+					}
+					namesToLoad.push(name);
+					storage.pending.add(name);
+				});
+				if (loader && namesToLoad.length) {
+					const promises = [];
+					if ("loadIcon" in loader) for (const name of namesToLoad) promises.push(new Promise((resolve) => {
+						loader.loadIcon(name, provider, prefix).then((data) => {
+							storage.update(name, data);
+							resolve();
+						}).catch(() => {
+							storage.update(name, null);
+							resolve();
+						});
+					}));
+					else {
+						const batches = splitForBatchLoading(namesToLoad, loader);
+						for (const batch of batches) {
+							const parse = (data) => {
+								const added = data ? addIconSetToStorage(data, provider) : /* @__PURE__ */ new Set();
+								for (const name of batch) if (!added.has(name)) storage.update(name, null);
+							};
+							promises.push(new Promise((resolve) => {
+								loader.loadIcons(batch, prefix, provider).then((data) => {
+									parse(data);
+									resolve();
+								}).catch(() => {
+									parse();
+									resolve();
+								});
+							}));
+						}
+					}
+					Promise.all(promises).catch(console.error);
+				}
+			}
+		}
+	}
+}
+/**
+* Add icons to queue
+*/
+function loadIcons(iconNames, instant = false) {
+	const icons = Array.isArray(iconNames) ? splitIconNames(iconNames) : iconNames;
+	mergeSplitIconNames(queue, icons);
+	triggerCallbackAsync(parseQueuedIcons, instant);
+}
+
+export { splitIconNames as n, loadIcons as t };

package/dist/size-B1gNk5pj.js

@@ -0,0 +1,59 @@
+/**
+* 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;
+	}
+}
+
+/**
+* Convert IconViewBox to string
+*/
+function getIconViewBox(viewBox) {
+	return `${viewBox.left ?? 0} ${viewBox.top ?? 0} ${viewBox.width} ${viewBox.height}`;
+}
+
+/**
+* Get size properties for icon
+*/
+function getSizeProps(width, height, ratio) {
+	const viewBox = typeof ratio === "object" ? getIconViewBox(ratio) : void 0;
+	const ratioValue = typeof ratio === "number" ? ratio : ratio.width / ratio.height;
+	if (width && height) return {
+		width,
+		height,
+		viewBox
+	};
+	if (height) return {
+		width: calculateSize(height, ratioValue),
+		height,
+		viewBox
+	};
+	if (width) return {
+		width,
+		height: calculateSize(width, 1 / ratioValue),
+		viewBox
+	};
+	return { viewBox };
+}
+
+export { calculateSize as n, getSizeProps as t };

package/dist/status-AnfUd3wQ.js

@@ -0,0 +1,5 @@
+import { t as supportsCSS } from "./support-CYSnYd4U.js";
+
+const renderCSS = supportsCSS();
+
+export { renderCSS as t };

package/dist/storage-B47thT4x.js

@@ -0,0 +1,99 @@
+const queue = /* @__PURE__ */ new Set();
+let isPending = false;
+/**
+* Parse callback
+*/
+function parseCallback(callback) {
+	try {
+		const result = callback();
+		if (result instanceof Promise) result.catch((error) => {
+			console.error(error);
+		});
+	} catch (error) {
+		console.error(error);
+	}
+}
+/**
+* Asynchronous callback trigger
+*/
+function triggerCallbackAsync(callback, instant = false) {
+	if (instant) {
+		parseCallback(callback);
+		return;
+	}
+	queue.add(callback);
+	if (!isPending) {
+		isPending = true;
+		setTimeout(() => {
+			isPending = false;
+			const callbacks = Array.from(queue);
+			queue.clear();
+			callbacks.forEach(parseCallback);
+		});
+	}
+}
+
+/**
+* Create icon storage
+*/
+function createIconStorage() {
+	const updated = /* @__PURE__ */ new Set();
+	let updatePending = false;
+	const icons = Object.create(null);
+	const missing = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Set();
+	const subscribers = [];
+	function update(name, data) {
+		pending.delete(name);
+		if (data) {
+			if (icons[name] === data) return;
+			icons[name] = data;
+			missing.delete(name);
+		} else {
+			if (missing.has(name)) return;
+			delete icons[name];
+			missing.add(name);
+		}
+		updated.add(name);
+		if (!updatePending) {
+			updatePending = true;
+			setTimeout(() => {
+				updatePending = false;
+				subscribers.forEach((subscriber) => {
+					for (const name of subscriber.names) if (name === "*" || updated.has(name)) {
+						triggerCallbackAsync(subscriber.callback);
+						return;
+					}
+				});
+				updated.clear();
+			});
+		}
+	}
+	return {
+		icons,
+		missing,
+		pending,
+		subscribers,
+		update
+	};
+}
+
+const storage = Object.create(null);
+/**
+* Get storage for provider and prefix
+*/
+function getIconStorage(provider, prefix) {
+	const providerData = storage[provider] || (storage[provider] = Object.create(null));
+	return providerData[prefix] || (providerData[prefix] = createIconStorage());
+}
+/**
+* Iterate all available icon storage
+*/
+function iterateIconStorage(callback) {
+	for (const provider in storage) {
+		const providerData = storage[provider];
+		for (const prefix in providerData) callback(providerData[prefix], prefix, provider);
+	}
+}
+
+export { iterateIconStorage as n, triggerCallbackAsync as r, getIconStorage as t };