@driftime/sanity-plugin-icon 0.3.0 → 0.4.1

package/dist/adapters-Bx_MyEX_.js

@@ -0,0 +1,633 @@
+import { n as isDefined, r as isRecord, t as convertCase } from "./utils-COPacfAq.js";
+import { t as findDrawingProblem } from "./nodes-DAzj56Xn.js";
+import path from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { optimize } from "svgo";
+/** Attributes of the outer SVG that size or label it rather than draw it, since the renderer sets its own. */
+const rootOnlyAttributes = /* @__PURE__ */ new Set([
+	"class",
+	"focusable",
+	"height",
+	"role",
+	"version",
+	"width"
+]);
+/**
+* Converts an SVG attribute name to its React form, such as `stroke-width` to `strokeWidth` and `xlink:href` to
+* `xlinkHref`.
+*
+* @param name - The attribute name.
+* @returns The React name.
+*/
+function toReactName(name) {
+	return name.replaceAll(/[-:](?<character>[a-z])/gu, (_match, character) => character.toUpperCase());
+}
+/**
+* Converts attributes to React naming, leaving out namespaces, classes, and data and accessibility attributes, which
+* don't draw anything.
+*
+* @param attributes - The attributes.
+* @param omitted - Further attributes to leave out.
+* @returns The converted attributes.
+*/
+function readAttributes(attributes, omitted = /* @__PURE__ */ new Set(["class"])) {
+	return Object.fromEntries(Object.entries(attributes).flatMap(([name, value]) => /^(?:xmlns|data-|aria-)/u.test(name) || omitted.has(name) ? [] : [[toReactName(name), value]]));
+}
+/**
+* Closes a `url(` left open at the end of each attribute value, which is how browsers read it.
+*
+* @param element - The element whose attributes to close.
+*/
+function closeOpenUrls(element) {
+	for (let [name, value] of Object.entries(element.attributes)) /url\([^)]*$/u.test(value) && (element.attributes[name] = `${value})`);
+}
+/**
+* Converts SVGO's parsed children into stored elements, keeping text and dropping comments.
+*
+* @param children - The parsed children.
+* @returns The elements and text.
+*/
+function readChildren(children) {
+	return children.flatMap((child) => {
+		if (child.type === "text") return isDefined(child.value.trim()) ? [child.value] : [];
+		if (child.type !== "element") return [];
+		let nested = readChildren(child.children), attributes = readAttributes(child.attributes);
+		return [isDefined(nested) ? [
+			child.name,
+			attributes,
+			nested
+		] : [child.name, attributes]];
+	});
+}
+/**
+* Reads SVGO's parsed document into a drawing, from its outer `svg` element.
+*
+* @param tree - The parsed document.
+* @returns The drawing, or undefined when the document has no `svg` element.
+*/
+function readSvgElement(tree) {
+	let element = tree.children.find((child) => child.type === "element" && child.name === "svg");
+	if (!isDefined(element)) return;
+	let width = element.attributes.width?.replace(/px$/u, "") ?? "24", height = element.attributes.height?.replace(/px$/u, "") ?? width, attributes = readAttributes(element.attributes, rootOnlyAttributes);
+	return {
+		root: {
+			...attributes,
+			viewBox: attributes.viewBox ?? `0 0 ${width} ${height}`
+		},
+		node: readChildren(element.children).filter((child) => typeof child != "string")
+	};
+}
+/**
+* Cleans and minifies an icon with SVGO, then reads the result into a drawing. Paths, numbers, and transforms are kept
+* exactly as drawn, since rounding or merging them changes how some icons look, and every identifier gets a prefix
+* unique to the icon, so two icons on one page can't clash.
+*
+* @param svg - The icon's SVG markup.
+* @returns The drawing, or undefined when the markup has no SVG.
+* @throws When the markup can't be parsed.
+*/
+function readDrawing(svg) {
+	let result = {}, declared = svg.includes("xlink:") && !svg.includes("xmlns:xlink") ? svg.replace("<svg", "<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\"") : svg;
+	return optimize(declared, {
+		multipass: !0,
+		plugins: [
+			{
+				name: "closeOpenUrls",
+				fn: () => ({ element: { enter: closeOpenUrls } })
+			},
+			{
+				name: "preset-default",
+				params: { overrides: {
+					cleanupNumericValues: !1,
+					convertPathData: !1,
+					convertTransform: !1,
+					inlineStyles: { onlyMatchedOnce: !1 },
+					mergePaths: !1
+				} }
+			},
+			"removeScripts",
+			"removeTitle",
+			{
+				name: "prefixIds",
+				params: { prefix: `i${createHash("sha256").update(svg).digest("hex").slice(0, 8)}` }
+			},
+			{
+				name: "read",
+				fn: () => ({ root: { enter(tree) {
+					result.drawing = readSvgElement(tree);
+				} } })
+			}
+		]
+	}), result.drawing;
+}
+/**
+* Reads an icon's markup into a drawing, or says why it can't be read.
+*
+* @param svg - The icon's SVG markup.
+* @returns The drawing, or why there isn't one.
+*/
+function parseDrawing(svg) {
+	try {
+		return readDrawing(svg) ?? "has no SVG";
+	} catch {
+		return "isn't valid SVG";
+	}
+}
+/**
+* Converts one icon into a stored drawing, the same way whichever library it came from.
+*
+* @param source - The icon as read from its library.
+* @returns The converted icon, or why it couldn't be converted.
+*/
+function convertIcon(source) {
+	let drawing = parseDrawing(source.svg);
+	if (typeof drawing == "string") return { problem: drawing };
+	let problem = findDrawingProblem(drawing);
+	if (isDefined(problem)) return { problem };
+	let nameWords = new Set(source.name.split("-")), keywords = [...new Set(source.keywords.map((keyword) => keyword.trim().toLowerCase()))].filter((keyword) => isDefined(keyword) && !nameWords.has(keyword));
+	return { icon: {
+		name: source.name,
+		keywords,
+		node: drawing.node,
+		root: drawing.root
+	} };
+}
+/** Root of a 24-unit stroke icon with rounded ends, shared by Lucide and Tabler's outline style. */
+const roundStrokeRoot = {
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": "2",
+	"stroke-linecap": "round",
+	"stroke-linejoin": "round"
+};
+/**
+* Converts a PascalCase export name to the kebab-case name libraries use on their websites, splitting before numbers
+* too, so `Home01` becomes `home-01`.
+*
+* @param name - The export name.
+* @returns The kebab-case name.
+*/
+function toKebabName(name) {
+	return name.replaceAll(/(?<upper>[A-Z])(?<next>[A-Z][a-z])/gu, "$<upper>-$<next>").replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, "$<lower>-$<upper>").replaceAll(/(?<letter>[a-zA-Z])(?<digit>[0-9])/gu, "$<letter>-$<digit>").toLowerCase();
+}
+/**
+* Checks whether a module is React, with its element factory.
+*
+* @param value - The module.
+* @returns True if the module is React.
+*/
+function isReact(value) {
+	return isRecord(value) && typeof value.createElement == "function";
+}
+/**
+* Checks whether a module is React's server renderer.
+*
+* @param value - The module.
+* @returns True if the module is the server renderer.
+*/
+function isServerRenderer(value) {
+	return isRecord(value) && typeof value.renderToStaticMarkup == "function";
+}
+/**
+* Checks whether a value can be rendered as a React element: a tag name, a component, or a wrapped component such as
+* one made by `memo`.
+*
+* @param value - The value.
+* @returns True if the value is an element type.
+*/
+function isElementType(value) {
+	return typeof value == "string" || typeof value == "function" || isRecord(value);
+}
+/**
+* Loads the project's React and its server renderer, so markup is written the way the project itself would write it.
+*
+* @param root - The project folder.
+* @returns React's element factory and a function that renders an element to markup, or undefined when the project
+*   has no React.
+*/
+function loadRenderer(root) {
+	let react = requireFromProject(root, "react"), server = requireFromProject(root, "react-dom/server");
+	if (isReact(react) && isServerRenderer(server)) return {
+		createElement: react.createElement,
+		render: (type, props = {}) => server.renderToStaticMarkup(react.createElement(type, props))
+	};
+}
+/**
+* Converts attributes to React props, so React writes each name the way SVG spells it.
+*
+* @param attributes - The attributes, in SVG or React naming.
+* @returns The props.
+*/
+function toProps(attributes) {
+	return Object.fromEntries(Object.entries(attributes).flatMap(([name, value]) => name === "key" ? [] : [[toReactName(name), String(value)]]));
+}
+/**
+* Writes a list of `[element, attributes]` pairs, the format several libraries ship, as SVG markup. React writes the
+* attributes, so names in either SVG or React form come out right.
+*
+* @param root - The project folder.
+* @param attributes - Attributes of the SVG around the elements.
+* @param value - The list.
+* @returns The markup, or undefined when the value isn't a list of pairs.
+*/
+function writeElementPairs(root, attributes, value) {
+	let renderer = loadRenderer(root);
+	if (!isDefined(renderer) || !Array.isArray(value)) return;
+	let { createElement: create, render } = renderer, elements = value.flatMap((pair, index) => Array.isArray(pair) && typeof pair[0] == "string" && isRecord(pair[1]) ? [create(pair[0], {
+		...toProps(pair[1]),
+		key: String(index)
+	})] : []);
+	if (elements.length === value.length) return render("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		...toProps(attributes),
+		children: elements
+	});
+}
+/**
+* Reads SVG files from a folder into icons.
+*
+* @param folder - The folder.
+* @param files - The file names to read.
+* @param describe - Gives each file's icon name and keywords.
+* @returns The icons, in the order given.
+*/
+async function readSvgIcons(folder, files, describe) {
+	return await Promise.all(files.map(async (file) => ({
+		...describe(file),
+		svg: await readFile(path.join(folder, file), "utf8")
+	})));
+}
+/**
+* Lists the SVG files in a folder.
+*
+* @param directory - The folder.
+* @returns The file names, sorted.
+*/
+async function listSvgFiles(directory) {
+	return (await readdir(directory)).filter((file) => file.endsWith(".svg")).toSorted();
+}
+/**
+* Imports a JavaScript module from inside an installed package, by path, since some packages don't allow importing
+* the file by name.
+*
+* @param directory - The package folder.
+* @param file - The module's path within the package.
+* @returns The module's exports.
+*/
+async function importPackageFile(directory, file) {
+	let loaded = await import(pathToFileURL(path.join(directory, file)).href);
+	return isRecord(loaded) ? loaded : {};
+}
+/**
+* Loads a package the way the project itself resolves it, so rendering uses the project's own copy of React.
+*
+* @param root - The project folder.
+* @param name - The package name.
+* @returns The package's exports.
+*/
+function requireFromProject(root, name) {
+	return createRequire(path.join(root, "package.json"))(name);
+}
+/**
+* Lists the plugin's own published code files.
+*
+* @returns The files' paths, sorted.
+*/
+async function listPluginFiles() {
+	return (await readdir(import.meta.dirname)).filter((file) => file.endsWith(".js")).toSorted().map((file) => path.join(import.meta.dirname, file));
+}
+/**
+* Hashes the plugin's own published code, so anything built from an older version is replaced. It uses the contents
+* rather than modification times, because packages installed from npm all carry the same fixed date.
+*
+* @returns The hash.
+*/
+async function readPluginBuild() {
+	let files = await listPluginFiles(), contents = await Promise.all(files.map(async (file) => ({
+		file,
+		content: await readFile(file)
+	}))), hash = createHash("sha256");
+	for (let { file, content } of contents) hash.update(path.basename(file)).update(content);
+	return hash.digest("hex").slice(0, 16);
+}
+/**
+* Reads and parses a JSON file.
+*
+* @param file - Path to the file.
+* @returns The parsed contents, or undefined when the file is missing or isn't JSON.
+*/
+async function readJson(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+/**
+* Lists a folder and every folder above it, nearest first.
+*
+* @param directory - The folder to start from.
+* @returns The folders.
+*/
+function listAncestors(directory) {
+	let parent = path.dirname(directory);
+	return parent === directory ? [directory] : [directory, ...listAncestors(parent)];
+}
+/**
+* Finds an installed package by walking up from the project folder through each `node_modules`, the way Node does.
+* Its `package.json` is read directly, because some icon packages don't allow importing it.
+*
+* @param root - The project folder.
+* @param name - The package name.
+* @returns The package, or undefined when it isn't installed.
+*/
+async function findPackage(root, name) {
+	let candidates = await Promise.all(listAncestors(path.resolve(root)).map(async (folder) => {
+		let directory = path.join(folder, "node_modules", name);
+		return {
+			directory,
+			manifest: await readJson(path.join(directory, "package.json"))
+		};
+	}));
+	for (let { directory, manifest } of candidates) if (isRecord(manifest) && typeof manifest.version == "string") return {
+		name: typeof manifest.name == "string" ? manifest.name : name,
+		directory,
+		version: manifest.version
+	};
+}
+/**
+* Lists the packages a project declares, from its dependencies, dev dependencies, and peer dependencies.
+*
+* @param root - The project folder.
+* @returns The declared package names.
+*/
+async function readDeclaredPackages(root) {
+	let manifest = await readJson(path.join(root, "package.json"));
+	if (!isRecord(manifest)) return /* @__PURE__ */ new Set();
+	let groups = [
+		manifest.dependencies,
+		manifest.devDependencies,
+		manifest.peerDependencies
+	];
+	return new Set(groups.flatMap((group) => isRecord(group) ? Object.keys(group) : []).filter((name) => isDefined(name)));
+}
+/**
+* Creates an adapter for a folder of the project's own SVG files. Each file becomes an icon named after the file, and an
+* optional `keywords.json` in the folder lists each icon's keywords by name.
+*
+* @param library - Identifier of the set.
+* @param folder - The folder, relative to the project.
+* @returns The adapter.
+*/
+function createCustomAdapter(library, folder) {
+	return {
+		library,
+		label: convertCase(library, "title"),
+		packageName: void 0,
+		styles: ["default"],
+		async read({ root }) {
+			let directory = path.resolve(root, folder), [files, keywords] = await Promise.all([listSvgFiles(directory), readJson(path.join(directory, "keywords.json"))]);
+			return readSvgIcons(directory, files, (file) => {
+				let name = convertCase(file.slice(0, -4), "kebab"), listed = isRecord(keywords) ? keywords[name] : void 0;
+				return {
+					name,
+					keywords: Array.isArray(listed) ? listed.map(String) : []
+				};
+			});
+		}
+	};
+}
+/**
+* Central, read by rendering the React components of its licensed style packages. Each installed
+* `@central-icons-react/` package is a style, named after the rest of its name, so several can be used at once. Each
+* icon is drawn in Central's raw mode, since its default mode draws through a mask.
+*/
+const centralAdapter = {
+	library: "central",
+	label: "Central Icon System",
+	packageName: void 0,
+	packagePrefix: "@central-icons-react/",
+	packageExample: "@central-icons-react/round-outlined-radius-2-stroke-1.5",
+	styles: [],
+	async read({ directory, root }) {
+		let renderer = loadRenderer(root);
+		if (!isDefined(renderer)) return [];
+		let [exports, index] = await Promise.all([importPackageFile(directory, "index.mjs"), readJson(path.join(directory, "icons-index.json"))]), aliases = isRecord(index) && isRecord(index.iconAliases) ? index.iconAliases : {};
+		return Object.entries(exports).flatMap(([exportName, component]) => {
+			if (!exportName.startsWith("Icon") || exportName.endsWith("Default") || !isElementType(component)) return [];
+			let svg = renderer.render(component, { mode: "raw" }), listed = aliases[exportName], keywords = typeof listed == "string" ? listed.split(",").map((keyword) => keyword.trim()) : [];
+			return [{
+				name: toKebabName(exportName.slice(4)),
+				keywords,
+				svg
+			}];
+		});
+	}
+}, centralFills = ["outlined", "filled"], centralRadii = [
+	"0",
+	"1",
+	"2",
+	"3"
+], centralStrokes = [
+	"1",
+	"1.5",
+	"2"
+], iconLibraryStyles = {
+	central: [...centralFills.flatMap((fill) => centralRadii.flatMap((radius) => centralStrokes.map((stroke) => `round-${fill}-radius-${radius}-stroke-${stroke}`))), ...centralFills.flatMap((fill) => centralStrokes.map((stroke) => `square-${fill}-radius-0-stroke-${stroke}`))],
+	heroicons: [
+		"outline",
+		"solid",
+		"mini",
+		"micro"
+	],
+	hugeicons: ["stroke-rounded"],
+	iconoir: ["regular", "solid"],
+	lucide: ["default"],
+	nucleo: /* @__PURE__ */ "arcade.core-essential-fill-24.core-essential-fill-32.core-essential-fill-48.core-essential-outline-24.core-essential-outline-32.core-essential-outline-48.core-fill-24.core-fill-32.core-fill-48.core-outline-24.core-outline-32.core-outline-48.credit-cards.flags.glass.isometric.micro-bold.micro-bold-essential.pixel.pixel-essential.sharp.sharp-essential.social-media.ui-essential-fill-12.ui-essential-fill-18.ui-essential-fill-duo-18.ui-essential-outline-12.ui-essential-outline-18.ui-essential-outline-duo-18.ui-fill-12.ui-fill-18.ui-fill-duo-18.ui-outline-12.ui-outline-18.ui-outline-duo-18".split("."),
+	phosphor: [
+		"regular",
+		"thin",
+		"light",
+		"bold",
+		"fill",
+		"duotone"
+	],
+	tabler: ["outline", "filled"]
+}, styleFolders = {
+	outline: "24/outline",
+	solid: "24/solid",
+	mini: "20/solid",
+	micro: "16/solid"
+}, heroiconsAdapter = {
+	library: "heroicons",
+	label: "Heroicons",
+	packageName: "heroicons",
+	packagePattern: /^(?:heroicons|@heroicons\/.+)$/u,
+	styles: [...iconLibraryStyles.heroicons],
+	async read({ directory, style }) {
+		let folder = path.join(directory, styleFolders[style] ?? "24/outline");
+		return readSvgIcons(folder, await listSvgFiles(folder), (file) => ({
+			name: file.slice(0, -4),
+			keywords: []
+		}));
+	}
+}, exportSuffixes = /(?:FreeIcons|Icon)$/u, hugeiconsAdapter = {
+	library: "hugeicons",
+	label: "Hugeicons",
+	packageName: "@hugeicons/core-free-icons",
+	packagePattern: /^@hugeicons\//u,
+	styles: [...iconLibraryStyles.hugeicons],
+	async read({ directory, root }) {
+		let exports = await importPackageFile(directory, "dist/esm/index.js"), namesByIcon = /* @__PURE__ */ new Map();
+		for (let [exportName, value] of Object.entries(exports)) namesByIcon.set(value, [...namesByIcon.get(value) ?? [], exportName]);
+		return [...namesByIcon].flatMap(([value, exportNames]) => {
+			let svg = writeElementPairs(root, {
+				viewBox: "0 0 24 24",
+				fill: "none"
+			}, value), [primary] = exportNames.filter((exportName) => exportName.endsWith("Icon")).toSorted();
+			return !isDefined(svg) || !isDefined(primary) ? [] : [{
+				name: toKebabName(primary.replace(exportSuffixes, "")),
+				keywords: [],
+				svg
+			}];
+		});
+	}
+}, iconoirAdapter = {
+	library: "iconoir",
+	label: "Iconoir",
+	packageName: "iconoir",
+	packagePattern: /^iconoir(?:-.+)?$/u,
+	styles: [...iconLibraryStyles.iconoir],
+	async read({ directory, style }) {
+		let folder = path.join(directory, "icons", style);
+		return readSvgIcons(folder, await listSvgFiles(folder), (file) => ({
+			name: file.slice(0, -4),
+			keywords: []
+		}));
+	}
+}, lucideAdapter = {
+	library: "lucide",
+	label: "Lucide",
+	packageName: "lucide-static",
+	packagePattern: /^(?:lucide(?:-.+)?|@lucide\/.+)$/u,
+	styles: [...iconLibraryStyles.lucide],
+	async read({ directory, root }) {
+		let [nodes, tags] = await Promise.all([readJson(path.join(directory, "icon-nodes.json")), readJson(path.join(directory, "tags.json"))]);
+		return isRecord(nodes) ? Object.entries(nodes).flatMap(([name, value]) => {
+			let svg = writeElementPairs(root, roundStrokeRoot, value);
+			return isDefined(svg) ? [{
+				name,
+				keywords: isRecord(tags) && Array.isArray(tags[name]) ? tags[name].map(String) : [],
+				svg
+			}] : [];
+		}) : [];
+	}
+};
+/**
+* Finds the style suffix every export name in a Nucleo package ends with, such as `Outline18`, so it can be removed to
+* get each icon's own name.
+*
+* @param names - The export names.
+* @returns The shared suffix, starting at a capital letter, or an empty string when there's none.
+*/
+function findStyleSuffix(names) {
+	let [first, ...rest] = names;
+	if (!isDefined(first)) return "";
+	let length = 0;
+	for (; length < first.length && rest.every((name) => name.at(-1 - length) === first.at(-1 - length));) length += 1;
+	let shared = first.slice(first.length - length), start = shared.search(/[A-Z]/u);
+	return start === -1 ? "" : shared.slice(start);
+}
+/**
+* Nucleo, read by rendering the React components of its licensed packages. Each installed `nucleo-` package is a
+* style, named after the rest of its name, such as `ui-outline-18`. It has no keywords.
+*/
+const nucleoAdapter = {
+	library: "nucleo",
+	label: "Nucleo",
+	packageName: void 0,
+	packagePrefix: "nucleo-",
+	packageExample: "nucleo-ui-outline-18",
+	styles: [],
+	async read({ directory, root }) {
+		let renderer = loadRenderer(root);
+		if (!isDefined(renderer)) return [];
+		let exports = await importPackageFile(directory, "dist/index.js"), components = Object.entries(exports).flatMap(([exportName, component]) => exportName.startsWith("Icon") && exportName !== "Icon" && isElementType(component) ? [[exportName, component]] : []), suffix = findStyleSuffix(components.map(([exportName]) => exportName));
+		return components.flatMap(([exportName, component]) => {
+			let svg = renderer.render(component);
+			return [{
+				name: toKebabName(exportName.slice(4, exportName.length - suffix.length)),
+				keywords: [],
+				svg
+			}];
+		});
+	}
+};
+/**
+* Reads Phosphor's keywords from the icon list `@phosphor-icons/core` exports.
+*
+* @param directory - The package folder.
+* @returns Keywords keyed by icon name.
+*/
+async function readPhosphorKeywords(directory) {
+	let { icons } = await importPackageFile(directory, "dist/index.mjs");
+	return Array.isArray(icons) ? new Map(icons.flatMap((icon) => isRecord(icon) && typeof icon.name == "string" && Array.isArray(icon.tags) ? [[icon.name, icon.tags.map(String)]] : [])) : /* @__PURE__ */ new Map();
+}
+/** Every library the build step knows how to read from its package. */
+const iconAdapters = [
+	centralAdapter,
+	heroiconsAdapter,
+	hugeiconsAdapter,
+	iconoirAdapter,
+	lucideAdapter,
+	nucleoAdapter,
+	{
+		library: "phosphor",
+		label: "Phosphor Icons",
+		packageName: "@phosphor-icons/core",
+		packagePattern: /^@phosphor-icons\//u,
+		styles: [...iconLibraryStyles.phosphor],
+		async read({ directory, style }) {
+			let folder = path.join(directory, "assets", style), [files, keywords] = await Promise.all([listSvgFiles(folder), readPhosphorKeywords(directory)]), suffix = style === "regular" ? ".svg" : `-${style}.svg`;
+			return readSvgIcons(folder, files.filter((file) => file.endsWith(suffix)), (file) => {
+				let name = file.slice(0, -suffix.length);
+				return {
+					name,
+					keywords: keywords.get(name) ?? []
+				};
+			});
+		}
+	},
+	{
+		library: "tabler",
+		label: "Tabler Icons",
+		packageName: "@tabler/icons",
+		packagePattern: /^@tabler\/icons(?:-.+)?$/u,
+		styles: [...iconLibraryStyles.tabler],
+		async read({ directory, style, root }) {
+			let [nodes, details] = await Promise.all([readJson(path.join(directory, `tabler-nodes-${style}.json`)), readJson(path.join(directory, "icons.json"))]);
+			if (!isRecord(nodes)) return [];
+			let attributes = style === "filled" ? {
+				viewBox: "0 0 24 24",
+				fill: "currentColor"
+			} : roundStrokeRoot;
+			return Object.entries(nodes).flatMap(([name, value]) => {
+				let svg = writeElementPairs(root, attributes, value);
+				if (!isDefined(svg)) return [];
+				let detail = isRecord(details) ? details[name] : void 0;
+				return [{
+					name,
+					keywords: isRecord(detail) && Array.isArray(detail.tags) ? detail.tags.map(String) : [],
+					svg
+				}];
+			});
+		}
+	}
+];
+export { readDeclaredPackages as a, convertIcon as c, listPluginFiles as i, createCustomAdapter as n, readJson as o, findPackage as r, readPluginBuild as s, iconAdapters as t };
+
+//# sourceMappingURL=adapters-Bx_MyEX_.js.map