@riebeckite/plugin-icons 0.0.0-stage → 0.0.33

package/dist/index.js

@@ -0,0 +1,1735 @@
+// index.ts
+import {
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/remark.ts
+var SKIP = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "html",
+  "link",
+  "linkReference",
+  "image",
+  "imageReference",
+  "definition",
+  "yaml",
+  "math",
+  "inlineMath",
+  "mathBlock",
+  "wikiLink",
+  "wikilink"
+]);
+function remarkIcons(options) {
+  const identifier = options.identifier || ":";
+  const escaped = escapeRegExp(identifier);
+  const pattern = new RegExp(
+    `${escaped}((?:[\\p{L}\\p{N}_-]{1,64}):\\d{17,18}|[\\p{L}\\p{N}_-]{1,64})${escaped}`,
+    "gu"
+  );
+  return (tree, file) => {
+    walk(tree, false, file, pattern, options.resolve);
+  };
+}
+function walk(parent, skip, file, pattern, resolve) {
+  const children = parent.children;
+  for (let index = 0; index < children.length; index += 1) {
+    const child = children[index];
+    if (!child) continue;
+    if (child.type === "text" && !skip) {
+      const replacement = transformText(child, file, pattern, resolve);
+      if (replacement) {
+        children.splice(index, 1, ...replacement);
+        index += replacement.length - 1;
+      }
+      continue;
+    }
+    if ("children" in child) {
+      walk(
+        child,
+        skip || SKIP.has(child.type),
+        file,
+        pattern,
+        resolve
+      );
+    }
+  }
+}
+function transformText(node, file, pattern, resolve) {
+  const value = node.value;
+  if (!value) return void 0;
+  const matches = [...value.matchAll(pattern)];
+  if (matches.length === 0) return void 0;
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  const raw = start !== void 0 && end !== void 0 ? String(file.value).slice(start, end) : void 0;
+  const sourceMap = raw === void 0 ? void 0 : buildSourceMap(raw, value);
+  const parts = [];
+  let cursor = 0;
+  let changed = false;
+  for (const match of matches) {
+    const name = match[1];
+    const offset = match.index;
+    if (!name || offset === void 0 || name.includes(":")) continue;
+    if (raw !== void 0 && sourceMap !== void 0 && isEscaped(raw, sourceMap[offset])) {
+      continue;
+    }
+    const icon = resolve(name);
+    if (!icon) continue;
+    if (offset > cursor) {
+      parts.push({ type: "text", value: value.slice(cursor, offset) });
+    }
+    parts.push({ type: "html", value: icon.html });
+    cursor = offset + match[0].length;
+    changed = true;
+  }
+  if (!changed) return void 0;
+  if (cursor < value.length) {
+    parts.push({ type: "text", value: value.slice(cursor) });
+  }
+  return parts;
+}
+function buildSourceMap(raw, value) {
+  const map = [];
+  let rawIndex = 0;
+  let valueIndex = 0;
+  while (valueIndex < value.length) {
+    if (rawIndex >= raw.length) return void 0;
+    if (raw[rawIndex] === "\\" && raw[rawIndex + 1] === value[valueIndex]) {
+      map.push(rawIndex + 1);
+      rawIndex += 2;
+      valueIndex += 1;
+      continue;
+    }
+    if (raw[rawIndex] === value[valueIndex]) {
+      map.push(rawIndex);
+      rawIndex += 1;
+      valueIndex += 1;
+      continue;
+    }
+    return void 0;
+  }
+  return map;
+}
+function isEscaped(raw, index) {
+  if (index === void 0 || index === 0) return false;
+  let count = 0;
+  for (let cursor = index - 1; cursor >= 0 && raw[cursor] === "\\"; cursor -= 1) {
+    count += 1;
+  }
+  return count % 2 === 1;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/color.ts
+var NAMED_COLORS = /* @__PURE__ */ new Set([
+  "aqua",
+  "black",
+  "blue",
+  "brown",
+  "crimson",
+  "currentcolor",
+  "cyan",
+  "darkblue",
+  "darkgreen",
+  "darkorange",
+  "darkred",
+  "fuchsia",
+  "gold",
+  "gray",
+  "green",
+  "grey",
+  "indigo",
+  "lime",
+  "magenta",
+  "maroon",
+  "navy",
+  "olive",
+  "orange",
+  "pink",
+  "purple",
+  "red",
+  "silver",
+  "teal",
+  "transparent",
+  "violet",
+  "white",
+  "yellow"
+]);
+var ICONIC_COLORS = {
+  red: "var(--rr-icon-red)",
+  orange: "var(--rr-icon-orange)",
+  yellow: "var(--rr-icon-yellow)",
+  green: "var(--rr-icon-green)",
+  cyan: "var(--rr-icon-cyan)",
+  blue: "var(--rr-icon-blue)",
+  purple: "var(--rr-icon-purple)",
+  pink: "var(--rr-icon-pink)",
+  gray: "var(--rr-icon-gray)"
+};
+function normalizeColor(value, options = {}) {
+  if (typeof value !== "string") return void 0;
+  const color = value.trim();
+  if (!color || color.length > 64) return void 0;
+  if (options.iconicNames) {
+    const named = ICONIC_COLORS[color.toLowerCase()];
+    if (named) return named;
+  }
+  if (/^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color)) {
+    return color.toLowerCase();
+  }
+  if (/^[0-9a-f]{1,6}$/i.test(color)) {
+    return `#${color.toLowerCase().padStart(6, "0")}`;
+  }
+  if (/^(?:rgb|rgba|hsl|hsla)\(\s*[-+.%\d\s,/a-z]+\)$/i.test(color) && !/url/i.test(color)) {
+    return color;
+  }
+  if (NAMED_COLORS.has(color.toLowerCase())) return color.toLowerCase();
+  return void 0;
+}
+
+// src/emoji.ts
+var EMOJIS = {
+  "100": "💯",
+  airplane: "✈️",
+  apple: "🍎",
+  arrow_down: "⬇️",
+  arrow_left: "⬅️",
+  arrow_right: "➡️",
+  arrow_up: "⬆️",
+  baby: "👶",
+  ball: "⚽",
+  balloon: "🎈",
+  beer: "🍺",
+  bell: "🔔",
+  bike: "🚲",
+  bird: "🐦",
+  blossom: "🌼",
+  blue_book: "📘",
+  blue_heart: "💙",
+  bomb: "💣",
+  book: "📖",
+  bookmark: "🔖",
+  books: "📚",
+  brain: "🧠",
+  bug: "🐛",
+  bulb: "💡",
+  cake: "🍰",
+  calendar: "📅",
+  camera: "📷",
+  car: "🚗",
+  cat: "🐱",
+  chart_with_upwards_trend: "📈",
+  checkered_flag: "🏁",
+  clap: "👏",
+  clock: "🕒",
+  cloud: "☁️",
+  code: "💻",
+  coffee: "☕",
+  computer: "💻",
+  construction: "🚧",
+  crystal_ball: "🔮",
+  dog: "🐶",
+  dollar: "💵",
+  droplet: "💧",
+  earth_asia: "🌏",
+  email: "✉️",
+  exclamation: "❗",
+  eyes: "👀",
+  fire: "🔥",
+  fish: "🐟",
+  folder: "📁",
+  gear: "⚙️",
+  gift: "🎁",
+  globe_with_meridians: "🌐",
+  hammer: "🔨",
+  heart: "❤️",
+  hourglass: "⌛",
+  house: "🏠",
+  information_source: "ℹ️",
+  key: "🔑",
+  label: "🏷️",
+  laptop: "💻",
+  large_blue_circle: "🔵",
+  leaf: "🍃",
+  link: "🔗",
+  lock: "🔒",
+  mag: "🔍",
+  memo: "📝",
+  moneybag: "💰",
+  moon: "🌙",
+  muscle: "💪",
+  music: "🎵",
+  new: "🆕",
+  notebook: "📓",
+  open_book: "📖",
+  package: "📦",
+  page_facing_up: "📄",
+  pencil2: "✏️",
+  pizza: "🍕",
+  point_right: "👉",
+  pray: "🙏",
+  question: "❓",
+  recycle: "♻️",
+  rocket: "🚀",
+  seedling: "🌱",
+  shield: "🛡️",
+  smile: "😄",
+  sparkles: "✨",
+  star: "⭐",
+  sunny: "☀️",
+  tada: "🎉",
+  tea: "🍵",
+  thumbsdown: "👎",
+  thumbsup: "👍",
+  tree: "🌳",
+  trophy: "🏆",
+  umbrella: "☔",
+  unicorn: "🦄",
+  warning: "⚠️",
+  wave: "👋",
+  white_check_mark: "✅",
+  wine: "🍷",
+  wrench: "🔧",
+  x: "❌",
+  zap: "⚡"
+};
+function lookupEmoji(name) {
+  return EMOJIS[name.trim().toLowerCase().replace(/-/g, "_")];
+}
+function isEmoji(value) {
+  return /^\p{Extended_Pictographic}(?:\uFE0F|\u200D\p{Extended_Pictographic}|[\u{1F3FB}-\u{1F3FF}])*$/u.test(
+    value.trim()
+  );
+}
+
+// src/iconic.ts
+var BOOLEAN_OPERATORS = /* @__PURE__ */ new Set(["isTrue", "isFalse"]);
+var ARRAY_OPERATORS = /* @__PURE__ */ new Set([
+  "includes",
+  "allAre",
+  "allContain",
+  "allStartWith",
+  "allEndWith",
+  "allMatch",
+  "anyContain",
+  "anyStartWith",
+  "anyEndWith",
+  "anyMatch",
+  "noneContain",
+  "noneStartWith",
+  "noneEndWith",
+  "noneMatch",
+  "countIs",
+  "countIsLess",
+  "countIsMore"
+]);
+var NUMBER_OPERATORS = /* @__PURE__ */ new Set(["equals", "isLess", "isMore", "isDivisible"]);
+var STRING_OPERATORS = /* @__PURE__ */ new Set([
+  "is",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "matches",
+  "hasValue",
+  "hasProperty"
+]);
+function resolveIconic(data, target, options) {
+  const manual = data.fileIcons[target.path];
+  const rules = target.kind === "folder" ? data.folderRules : data.fileRules;
+  const rule = rules.find(
+    (candidate) => candidate.enabled !== false && (candidate.conditions?.length ?? 0) > 0 && matchesRule(candidate, target, manual, options.report)
+  );
+  const icon = rule?.icon ?? manual?.icon;
+  const rawColor = rule?.color ?? manual?.color;
+  if (!icon && !rawColor) return void 0;
+  const color = options.colors ? normalizeColor(rawColor, { iconicNames: true }) : void 0;
+  return {
+    ...icon ? { icon } : {},
+    ...color ? { color } : {},
+    ...rule ? { rule: rule.name ?? rule.id } : {}
+  };
+}
+function resolveIconicReference(icon) {
+  if (isEmoji(icon)) return `emoji:${icon}`;
+  if (/^lucide-/.test(icon)) return `lucide:${icon.slice(7)}`;
+  if (icon.includes(":")) {
+    const [namespace, ...rest] = icon.split(":");
+    if (namespace === "lucide" || namespace === "emoji") {
+      return `${namespace}:${rest.join(":")}`;
+    }
+  }
+  return `lucide:${icon}`;
+}
+function matchesRule(rule, target, manual, report) {
+  let unsupported = false;
+  const results = [];
+  for (const condition of rule.conditions ?? []) {
+    const result = evaluateCondition(condition, target, manual);
+    if (result === void 0) {
+      unsupported = true;
+      results.push(false);
+    } else {
+      results.push(result);
+    }
+  }
+  if (unsupported) {
+    report(rule, "uses a condition that cannot be evaluated in a static build");
+  }
+  const match = rule.match ?? "all";
+  if (match === "any") return results.some(Boolean);
+  if (match === "none") return !results.some(Boolean);
+  return results.length > 0 && results.every(Boolean);
+}
+function evaluateCondition(condition, target, manual) {
+  const source = condition.source?.trim();
+  const operator = condition.operator?.trim();
+  if (!source || !operator) return false;
+  const negate = operator.startsWith("!");
+  const op = negate ? operator.slice(1) : operator;
+  const rawValue = condition.value ?? "";
+  const resolved = readSource(source, target, manual);
+  if (resolved === void 0) return void 0;
+  const result = applyOperator(resolved, op, rawValue);
+  if (result === void 0) return void 0;
+  return negate ? !result : result;
+}
+function readSource(source, target, manual) {
+  if (source === "clock" || source === "headings" || source === "bookmarks") {
+    return void 0;
+  }
+  if (source === "created" || source === "modified") {
+    const value = source === "created" ? target.created : target.modified;
+    return value ? { kind: "date", value } : void 0;
+  }
+  if (source.startsWith("property:")) {
+    const key = source.slice("property:".length).trim().toLowerCase();
+    const frontmatter = target.frontmatter ?? {};
+    const found = Object.entries(frontmatter).find(
+      ([candidate]) => candidate.toLowerCase() === key
+    );
+    return {
+      kind: "property",
+      value: found?.[1],
+      exists: found !== void 0
+    };
+  }
+  const path3 = target.path;
+  switch (source) {
+    case "icon":
+      return { kind: "string", value: manual?.icon ?? "" };
+    case "color":
+      return { kind: "string", value: manual?.color ?? "" };
+    case "name": {
+      const name = path3.split("/").pop() ?? path3;
+      return {
+        kind: "string",
+        value: name.replace(/\.[^.]+$/, "")
+      };
+    }
+    case "filename":
+      return { kind: "string", value: path3.split("/").pop() ?? path3 };
+    case "extension": {
+      const name = path3.split("/").pop() ?? path3;
+      const dot = name.lastIndexOf(".");
+      return { kind: "string", value: dot > 0 ? name.slice(dot + 1) : "" };
+    }
+    case "tree":
+      return { kind: "string", value: path3.split("/").slice(0, -1).join("/") };
+    case "path":
+      return { kind: "string", value: path3 };
+    case "tags":
+      return { kind: "array", value: target.tags ?? [] };
+    case "links":
+      return { kind: "array", value: target.links ?? [] };
+    case "embeds":
+      return { kind: "array", value: target.embeds ?? [] };
+    default:
+      return void 0;
+  }
+}
+function applyOperator(source, operator, expected) {
+  if (BOOLEAN_OPERATORS.has(operator)) {
+    if (source.kind !== "boolean" && source.kind !== "property")
+      return void 0;
+    const value = source.kind === "boolean" ? source.value : toBoolean(source.value);
+    return operator === "isTrue" ? value : !value;
+  }
+  if (operator === "hasProperty") {
+    return source.kind === "property" ? source.exists : void 0;
+  }
+  if (source.kind === "property") {
+    if (Array.isArray(source.value)) {
+      return applyToArray(
+        source.value.map((item) => String(item)),
+        operator,
+        expected
+      );
+    }
+    if (typeof source.value === "number") {
+      return applyToNumber(source.value, operator, expected);
+    }
+    if (typeof source.value === "boolean") {
+      return applyToBoolean(source.value, operator, expected);
+    }
+    return applyToString(String(source.value ?? ""), operator, expected);
+  }
+  if (source.kind === "array") {
+    return applyToArray(source.value, operator, expected);
+  }
+  if (source.kind === "date") {
+    return applyToDate(source.value, operator, expected);
+  }
+  if (source.kind === "boolean") {
+    return applyToBoolean(source.value, operator, expected);
+  }
+  return applyToString(source.value, operator, expected);
+}
+function applyToString(value, operator, expected) {
+  switch (operator) {
+    case "is":
+      return value === expected;
+    case "contains":
+      return value.includes(expected);
+    case "startsWith":
+      return value.startsWith(expected);
+    case "endsWith":
+      return value.endsWith(expected);
+    case "matches":
+      return safeRegex(expected).test(value);
+    case "hasValue":
+      return value.length > 0;
+    default:
+      return ARRAY_OPERATORS.has(operator) || NUMBER_OPERATORS.has(operator) ? false : void 0;
+  }
+}
+function applyToArray(value, operator, expected) {
+  if (!ARRAY_OPERATORS.has(operator)) {
+    if (STRING_OPERATORS.has(operator))
+      return applyToString(value.join(","), operator, expected);
+    return void 0;
+  }
+  switch (operator) {
+    case "includes":
+      return value.includes(expected);
+    case "allAre":
+      return value.length > 0 && value.every((item) => item === expected);
+    case "allContain":
+      return value.length > 0 && value.every((item) => item.includes(expected));
+    case "allStartWith":
+      return value.length > 0 && value.every((item) => item.startsWith(expected));
+    case "allEndWith":
+      return value.length > 0 && value.every((item) => item.endsWith(expected));
+    case "allMatch": {
+      const regex = safeRegex(expected);
+      return value.length > 0 && value.every((item) => regex.test(item));
+    }
+    case "anyContain":
+      return value.some((item) => item.includes(expected));
+    case "anyStartWith":
+      return value.some((item) => item.startsWith(expected));
+    case "anyEndWith":
+      return value.some((item) => item.endsWith(expected));
+    case "anyMatch": {
+      const regex = safeRegex(expected);
+      return value.some((item) => regex.test(item));
+    }
+    case "noneContain":
+      return !value.some((item) => item.includes(expected));
+    case "noneStartWith":
+      return !value.some((item) => item.startsWith(expected));
+    case "noneEndWith":
+      return !value.some((item) => item.endsWith(expected));
+    case "noneMatch": {
+      const regex = safeRegex(expected);
+      return !value.some((item) => regex.test(item));
+    }
+    case "countIs":
+      return value.length === Number(expected);
+    case "countIsLess":
+      return value.length < Number(expected);
+    case "countIsMore":
+      return value.length > Number(expected);
+    default:
+      return void 0;
+  }
+}
+function applyToNumber(value, operator, expected) {
+  const number = Number(expected);
+  if (!Number.isFinite(number)) return false;
+  switch (operator) {
+    case "is":
+    case "equals":
+      return value === number;
+    case "isLess":
+      return value < number;
+    case "isMore":
+      return value > number;
+    case "isDivisible":
+      return number !== 0 && value % number === 0;
+    default:
+      return void 0;
+  }
+}
+function applyToBoolean(value, operator, expected) {
+  if (operator !== "is") return void 0;
+  return value === (expected === "true");
+}
+function applyToDate(value, operator, expected) {
+  if (!["is", "isLess", "isMore", "equals"].includes(operator)) {
+    return void 0;
+  }
+  const date = new Date(expected);
+  if (Number.isNaN(date.getTime())) return false;
+  const time = value.getTime();
+  if (operator === "isLess") return time < date.getTime();
+  if (operator === "isMore") return time > date.getTime();
+  return time === date.getTime();
+}
+function safeRegex(pattern) {
+  try {
+    return new RegExp(pattern.length > 512 ? "" : pattern);
+  } catch {
+    return /$a/;
+  }
+}
+function toBoolean(value) {
+  return value === true || value === "true";
+}
+
+// src/settings.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import {
+  fingerprintExternalValue
+} from "@riebeckite/core";
+var ICONIZE_ID = "obsidian-icon-folder";
+var ICONIC_ID = "iconic";
+var MAX_SETTINGS_BYTES = 2 * 1024 * 1024;
+var MAX_SVG_BYTES = 256 * 1024;
+var DEFAULT_ICONIZE_SETTINGS = {
+  iconPacksPath: ".obsidian/icons",
+  iconColor: null,
+  iconInFrontmatterEnabled: false,
+  iconInFrontmatterFieldName: "icon",
+  iconColorInFrontmatterFieldName: "iconColor",
+  iconsInNotesEnabled: true,
+  iconInLinksEnabled: true,
+  iconIdentifier: ":",
+  lucideIconPackType: "native",
+  emojiStyle: "native",
+  rules: []
+};
+async function loadIconsSettings(options, config) {
+  const diagnostics = [];
+  const contentDirectory = config?.content.directory;
+  const vaultRoot = await resolveVaultRoot(options, contentDirectory);
+  const vaultPrefix = resolveVaultPrefix(options, vaultRoot, contentDirectory);
+  const dataRoot = vaultRoot ?? process.cwd();
+  let iconize;
+  if (options.iconize.enabled) {
+    const dataFile = await resolveDataFile({
+      explicit: options.iconize.dataFile,
+      pluginId: ICONIZE_ID,
+      root: dataRoot,
+      vaultRoot,
+      diagnostics,
+      source: "Iconize"
+    });
+    if (dataFile) {
+      const raw = await readJsonFile(dataFile, "Iconize", diagnostics);
+      if (raw !== void 0) iconize = parseIconizeData(raw, diagnostics);
+    }
+  }
+  let iconic;
+  if (options.iconic.enabled) {
+    const dataFile = await resolveDataFile({
+      explicit: options.iconic.dataFile,
+      pluginId: ICONIC_ID,
+      root: dataRoot,
+      vaultRoot,
+      diagnostics,
+      source: "Iconic"
+    });
+    if (dataFile) {
+      const raw = await readJsonFile(dataFile, "Iconic", diagnostics);
+      if (raw !== void 0) iconic = parseIconicData(raw, diagnostics);
+    }
+  }
+  const iconPacksRoot = vaultRoot ? resolvePackRoot(
+    vaultRoot,
+    options.iconize.iconPacks ?? iconize?.settings.iconPacksPath ?? DEFAULT_ICONIZE_SETTINGS.iconPacksPath
+  ) : void 0;
+  const iconPacks = iconPacksRoot ? await loadIconPacks(iconPacksRoot, diagnostics) : /* @__PURE__ */ new Map();
+  return {
+    ...iconize === void 0 ? {} : { iconize },
+    ...iconic === void 0 ? {} : { iconic },
+    iconPacks,
+    ...iconPacksRoot === void 0 ? {} : { iconPacksRoot },
+    vaultPrefix,
+    fingerprint: fingerprintExternalValue({
+      iconize: iconize ? { settings: iconize.settings, icons: [...iconize.icons] } : null,
+      iconic: iconic ?? null,
+      packs: [...iconPacks].map(([pack, files]) => [
+        pack,
+        [...files].map(([name, file]) => [name, file.size, file.modified])
+      ])
+    }),
+    diagnostics
+  };
+}
+function findIconPackFile(packs, packName, iconName) {
+  const pack = packs.get(packName.toLowerCase());
+  if (!pack) return void 0;
+  return pack.get(normalizeIconName(iconName).toLowerCase());
+}
+function normalizeIconName(name) {
+  return name.split(/[\s_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function normalizeVaultPath(value) {
+  const normalized = value.normalize("NFC").replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/{2,}/g, "/");
+  if (!normalized || normalized.includes("\0")) return void 0;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment === ".." || segment === ".")) {
+    return void 0;
+  }
+  return segments.filter(Boolean).join("/");
+}
+async function resolveVaultRoot(options, contentDirectory) {
+  if (options.vaultRoot) {
+    const explicit = path.resolve(options.vaultRoot);
+    const root = path.basename(explicit) === ".obsidian" ? path.dirname(explicit) : explicit;
+    return await isDirectory(root) ? root : void 0;
+  }
+  const starts = [contentDirectory, process.cwd()].filter(
+    (value) => typeof value === "string"
+  );
+  for (const start of starts) {
+    let current = path.resolve(start);
+    for (; ; ) {
+      if (await isDirectory(path.join(current, ".obsidian"))) return current;
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return void 0;
+}
+function resolveVaultPrefix(options, vaultRoot, contentDirectory) {
+  if (options.vaultPrefix !== void 0) {
+    return normalizeVaultPath(options.vaultPrefix) ?? "";
+  }
+  if (!vaultRoot || !contentDirectory) return "";
+  const relative = path.relative(vaultRoot, path.resolve(contentDirectory));
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return "";
+  }
+  return `${normalizeVaultPath(relative) ?? ""}/`.replace(/^\/+/, "");
+}
+async function resolveDataFile(input) {
+  const root = input.vaultRoot ?? input.root;
+  if (input.explicit) {
+    const resolved = path.resolve(input.root, input.explicit);
+    if (!isWithin(root, resolved)) {
+      input.diagnostics.push({
+        code: "icons-untrusted-settings-path",
+        severity: "warning",
+        message: `${input.source} settings path is outside the allowed root; ignoring it.`,
+        meta: { source: input.source }
+      });
+      return void 0;
+    }
+    return await isFile(resolved) ? resolved : void 0;
+  }
+  const candidate = path.join(
+    root,
+    ".obsidian",
+    "plugins",
+    input.pluginId,
+    "data.json"
+  );
+  return await isFile(candidate) ? candidate : void 0;
+}
+async function readJsonFile(filePath, source, diagnostics) {
+  const text = await readTextFile(filePath, MAX_SETTINGS_BYTES);
+  if (text === void 0) {
+    diagnostics.push({
+      code: "icons-unreadable-settings",
+      severity: "warning",
+      message: `${source} settings could not be read; continuing without them.`,
+      meta: { source }
+    });
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    diagnostics.push({
+      code: "icons-invalid-settings",
+      severity: "warning",
+      message: `${source} settings are not valid JSON; continuing without them.`,
+      meta: { source }
+    });
+    return void 0;
+  }
+}
+async function readTextFile(filePath, maxBytes) {
+  try {
+    const stat = await fs.lstat(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) return void 0;
+    if (stat.size > maxBytes) return void 0;
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function parseIconizeData(raw, diagnostics) {
+  if (!isRecord(raw)) {
+    diagnostics.push({
+      code: "icons-invalid-settings",
+      severity: "warning",
+      message: "Iconize settings are not an object; continuing without them.",
+      meta: { source: "Iconize" }
+    });
+    return { settings: DEFAULT_ICONIZE_SETTINGS, icons: /* @__PURE__ */ new Map() };
+  }
+  const rawSettings = isRecord(raw.settings) ? raw.settings : {};
+  const iconIdentifier = typeof rawSettings.iconIdentifier === "string" && rawSettings.iconIdentifier.length > 0 ? rawSettings.iconIdentifier : DEFAULT_ICONIZE_SETTINGS.iconIdentifier;
+  const settings = {
+    iconPacksPath: typeof rawSettings.iconPacksPath === "string" && rawSettings.iconPacksPath.trim() ? rawSettings.iconPacksPath : DEFAULT_ICONIZE_SETTINGS.iconPacksPath,
+    iconColor: typeof rawSettings.iconColor === "string" ? rawSettings.iconColor : null,
+    iconInFrontmatterEnabled: rawSettings.iconInFrontmatterEnabled === true,
+    iconInFrontmatterFieldName: nonEmptyString(rawSettings.iconInFrontmatterFieldName) ?? DEFAULT_ICONIZE_SETTINGS.iconInFrontmatterFieldName,
+    iconColorInFrontmatterFieldName: nonEmptyString(rawSettings.iconColorInFrontmatterFieldName) ?? DEFAULT_ICONIZE_SETTINGS.iconColorInFrontmatterFieldName,
+    iconsInNotesEnabled: rawSettings.iconsInNotesEnabled !== false,
+    iconInLinksEnabled: rawSettings.iconInLinksEnabled !== false,
+    iconIdentifier,
+    lucideIconPackType: isLucidePackType(rawSettings.lucideIconPackType) ? rawSettings.lucideIconPackType : DEFAULT_ICONIZE_SETTINGS.lucideIconPackType,
+    emojiStyle: rawSettings.emojiStyle === "twemoji" ? "twemoji" : "native",
+    rules: parseIconizeRules(rawSettings.rules)
+  };
+  const icons2 = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "settings" || key === "migrated") continue;
+    const normalized = normalizeVaultPath(key);
+    if (!normalized) continue;
+    if (typeof value === "string") {
+      if (value.trim()) icons2.set(normalized, { iconName: value.trim() });
+      continue;
+    }
+    if (!isRecord(value)) continue;
+    const iconName = value.iconName === null ? null : typeof value.iconName === "string" ? value.iconName.trim() || null : null;
+    const iconColor = typeof value.iconColor === "string" ? value.iconColor : void 0;
+    if (iconName === null && iconColor === void 0) continue;
+    icons2.set(normalized, {
+      iconName,
+      ...iconColor === void 0 ? {} : { iconColor }
+    });
+  }
+  if (settings.emojiStyle === "twemoji") {
+    diagnostics.push({
+      code: "icons-unsupported-emoji-style",
+      severity: "info",
+      message: "Iconize twemoji styling is not bundled; native emoji are used instead.",
+      meta: { source: "Iconize" }
+    });
+  }
+  return { settings, icons: icons2 };
+}
+function parseIconizeRules(value) {
+  if (!Array.isArray(value)) return [];
+  const rules = [];
+  for (const raw of value) {
+    if (!isRecord(raw)) continue;
+    const rule = nonEmptyString(raw.rule);
+    const icon = nonEmptyString(raw.icon);
+    if (!rule || !icon) continue;
+    rules.push({
+      rule,
+      icon,
+      order: typeof raw.order === "number" && Number.isFinite(raw.order) ? raw.order : rules.length,
+      ...typeof raw.color === "string" ? { color: raw.color } : {},
+      ...raw.useFilePath === true ? { useFilePath: true } : {},
+      ...raw.for === "everything" || raw.for === "files" || raw.for === "folders" ? { for: raw.for } : {}
+    });
+  }
+  return rules;
+}
+function parseIconicData(raw, diagnostics) {
+  if (!isRecord(raw)) {
+    diagnostics.push({
+      code: "icons-invalid-settings",
+      severity: "warning",
+      message: "Iconic settings are not an object; continuing without them.",
+      meta: { source: "Iconic" }
+    });
+    return {
+      fileIcons: {},
+      tagIcons: {},
+      propertyIcons: {},
+      fileRules: [],
+      folderRules: []
+    };
+  }
+  return {
+    fileIcons: parseIconicValues(raw.fileIcons),
+    tagIcons: parseIconicValues(raw.tagIcons),
+    propertyIcons: parseIconicValues(raw.propertyIcons),
+    fileRules: parseIconicRules(raw.fileRules),
+    folderRules: parseIconicRules(raw.folderRules)
+  };
+}
+function parseIconicValues(value) {
+  if (!isRecord(value)) return {};
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!isRecord(raw)) continue;
+    const normalized = key.includes("/") ? normalizeVaultPath(key) : key;
+    if (!normalized) continue;
+    const icon = nonEmptyString(raw.icon);
+    const color = nonEmptyString(raw.color);
+    if (!icon && !color) continue;
+    result[normalized] = {
+      ...icon ? { icon } : {},
+      ...color ? { color } : {}
+    };
+  }
+  return result;
+}
+function parseIconicRules(value) {
+  if (!Array.isArray(value)) return [];
+  const rules = [];
+  for (const raw of value) {
+    if (!isRecord(raw)) continue;
+    const conditions = Array.isArray(raw.conditions) ? raw.conditions.flatMap((condition) => {
+      if (!isRecord(condition)) return [];
+      return [
+        {
+          ...typeof condition.source === "string" ? { source: condition.source } : {},
+          ...typeof condition.operator === "string" ? { operator: condition.operator } : {},
+          ...typeof condition.value === "string" ? { value: condition.value } : {}
+        }
+      ];
+    }) : [];
+    const icon = nonEmptyString(raw.icon);
+    const color = nonEmptyString(raw.color);
+    rules.push({
+      ...typeof raw.id === "string" ? { id: raw.id } : {},
+      ...typeof raw.name === "string" ? { name: raw.name } : {},
+      ...icon ? { icon } : {},
+      ...color ? { color } : {},
+      ...raw.match === "any" || raw.match === "none" ? { match: raw.match } : { match: "all" },
+      conditions,
+      enabled: raw.enabled === true
+    });
+  }
+  return rules;
+}
+async function loadIconPacks(root, diagnostics) {
+  const packs = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return packs;
+  }
+  let zipCount = 0;
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".zip")) {
+      zipCount += 1;
+      continue;
+    }
+    if (!entry.isDirectory()) continue;
+    const packPath = path.join(root, entry.name);
+    const realPack = await safeRealPath(packPath);
+    if (!realPack || !isWithin(root, realPack)) continue;
+    let files;
+    try {
+      files = await fs.readdir(realPack, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const pack = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      if (!file.isFile() || !file.name.toLowerCase().endsWith(".svg")) {
+        continue;
+      }
+      const filePath = path.join(realPack, file.name);
+      const realFile = await safeRealPath(filePath);
+      if (!realFile || !isWithin(root, realFile)) continue;
+      try {
+        const stat = await fs.stat(realFile);
+        if (stat.size > MAX_SVG_BYTES) continue;
+        const iconName = normalizeIconName(
+          file.name.slice(0, -".svg".length)
+        ).toLowerCase();
+        if (!iconName) continue;
+        pack.set(iconName, {
+          name: file.name,
+          filePath: realFile,
+          size: stat.size,
+          modified: stat.mtimeMs
+        });
+      } catch {
+      }
+    }
+    if (pack.size > 0) {
+      const packName = normalizeIconName(entry.name).toLowerCase();
+      if (packName) packs.set(packName, pack);
+    }
+  }
+  if (zipCount > 0) {
+    diagnostics.push({
+      code: "icons-unsupported-zip-pack",
+      severity: "info",
+      message: "Zip-based Iconize icon packs are not read; extract them into folders under the icon packs directory.",
+      meta: { packCount: zipCount }
+    });
+  }
+  return packs;
+}
+function resolvePackRoot(vaultRoot, value) {
+  const resolved = path.resolve(vaultRoot, value);
+  return isWithin(vaultRoot, resolved) ? resolved : void 0;
+}
+function isLucidePackType(value) {
+  return value === "none" || value === "custom" || value === "native";
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithin(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+async function isDirectory(value) {
+  try {
+    const stat = await fs.lstat(value);
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function isFile(value) {
+  try {
+    const stat = await fs.lstat(value);
+    return stat.isFile() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function safeRealPath(value) {
+  try {
+    return await fs.realpath(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/iconize.ts
+function resolveIconize(data, target, options) {
+  const direct = data.icons.get(target.path);
+  if (direct?.iconName) {
+    return toResolution(direct, data, options);
+  }
+  const rule = firstMatchingRule(data.settings.rules, target);
+  if (!rule) return void 0;
+  return toResolution(
+    { iconName: rule.icon, ...rule.color ? { iconColor: rule.color } : {} },
+    data,
+    options
+  );
+}
+function parseIconReference(value, packNames) {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (isEmoji(trimmed)) return `emoji:${trimmed}`;
+  const lower = trimmed.toLowerCase();
+  const packs = [...packNames].map((name) => normalizeIconName(name)).filter(Boolean).toSorted((a, b) => b.length - a.length);
+  for (const pack of packs) {
+    if (lower.startsWith(pack.toLowerCase()) && trimmed.length > pack.length) {
+      return `pack:${pack}:${trimmed.slice(pack.length)}`;
+    }
+  }
+  if (/^Li[A-Z0-9]/.test(trimmed)) {
+    return `lucide:${toKebab(trimmed.slice(2))}`;
+  }
+  if (lower.startsWith("lucide-")) {
+    return `lucide:${lower.slice("lucide-".length)}`;
+  }
+  if (lower.startsWith("lucide:")) {
+    return `lucide:${lower.slice("lucide:".length)}`;
+  }
+  return `lucide:${toKebab(trimmed)}`;
+}
+function toKebab(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toResolution(value, data, options) {
+  if (!value.iconName) return void 0;
+  const icon = parseIconReference(value.iconName, options.packs.keys());
+  if (!icon) return void 0;
+  const color = options.colors ? normalizeColor(value.iconColor) ?? normalizeColor(data.settings.iconColor) : void 0;
+  return { icon, ...color ? { color } : {} };
+}
+function firstMatchingRule(rules, target) {
+  const sorted = rules.toSorted((a, b) => a.order - b.order);
+  for (const rule of sorted) {
+    if (rule.for === "files" && target.kind !== "file") continue;
+    if (rule.for === "folders" && target.kind !== "folder") continue;
+    const subject = rule.useFilePath ? target.path : target.path.split("/").pop() ?? target.path;
+    if (matchesRule2(rule.rule, subject)) return rule;
+  }
+  return void 0;
+}
+function matchesRule2(pattern, value) {
+  if (pattern.length > 512) return false;
+  try {
+    return new RegExp(pattern).test(value);
+  } catch {
+    return value.includes(pattern);
+  }
+}
+
+// src/render.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+import {
+  escapeHtml,
+  escapeHtmlAttribute
+} from "@riebeckite/core";
+import sanitizeHtml from "sanitize-html";
+var MAX_SVG_BYTES2 = 256 * 1024;
+var ALLOWED_TAGS = [
+  "svg",
+  "g",
+  "path",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "rect",
+  "title",
+  "desc",
+  "defs",
+  "lineargradient",
+  "radialgradient",
+  "stop"
+];
+var PRESENTATION_ATTRIBUTES = [
+  "fill",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "fill-rule",
+  "clip-rule",
+  "opacity",
+  "fill-opacity",
+  "stroke-opacity",
+  "transform",
+  "vector-effect"
+];
+var SANITIZE_OPTIONS = {
+  allowedTags: ALLOWED_TAGS,
+  allowedAttributes: {
+    svg: ["xmlns", "viewBox", "width", "height", "role", "focusable"],
+    circle: ["cx", "cy", "r"],
+    ellipse: ["cx", "cy", "rx", "ry"],
+    line: ["x1", "y1", "x2", "y2"],
+    rect: ["x", "y", "width", "height", "rx", "ry"],
+    polyline: ["points"],
+    polygon: ["points"],
+    path: ["d", "pathLength"],
+    g: ["clip-path", "mask"],
+    lineargradient: [
+      "id",
+      "gradientUnits",
+      "gradientTransform",
+      "x1",
+      "y1",
+      "x2",
+      "y2"
+    ],
+    radialgradient: [
+      "id",
+      "gradientUnits",
+      "gradientTransform",
+      "cx",
+      "cy",
+      "r",
+      "fx",
+      "fy"
+    ],
+    stop: ["offset", "stop-color", "stop-opacity"],
+    "*": PRESENTATION_ATTRIBUTES
+  },
+  allowedSchemes: [],
+  allowedSchemesByTag: {},
+  allowProtocolRelative: false,
+  disallowedTagsMode: "discard",
+  parser: {
+    lowerCaseAttributeNames: false,
+    lowerCaseTags: true
+  }
+};
+var IconRenderer = class {
+  #packs;
+  #cache = /* @__PURE__ */ new Map();
+  #lucideDirectory = resolveLucideDirectory();
+  constructor(settings) {
+    this.#packs = settings.iconPacks;
+  }
+  render(reference, options) {
+    const inner = this.#inner(reference);
+    if (inner === void 0) return void 0;
+    const kind = reference.startsWith("emoji:") ? "emoji" : reference.startsWith("text:") ? "text" : "svg";
+    const color = options.color;
+    return {
+      id: reference,
+      kind,
+      source: options.source,
+      html: `<span class="rr-icon rr-icon--${kind}" aria-hidden="true"${color === void 0 ? "" : ` style="color:${escapeHtmlAttribute(color)}"`}>${inner}</span>`,
+      ...color === void 0 ? {} : { color },
+      ...options.label === void 0 ? {} : { label: options.label }
+    };
+  }
+  #inner(reference) {
+    const cached = this.#cache.get(reference);
+    if (cached !== void 0) return cached ?? void 0;
+    let html;
+    if (reference.startsWith("emoji:")) {
+      const raw = reference.slice("emoji:".length);
+      const emoji = lookupEmoji(raw) ?? (raw.trim() ? raw : void 0);
+      if (emoji) html = escapeHtml(emoji);
+    } else if (reference.startsWith("pack:")) {
+      const [, packName, ...rest] = reference.split(":");
+      const file = packName ? findIconPackFile(this.#packs, packName, rest.join(":")) : void 0;
+      if (file) html = renderSvg(readSvg(file.filePath));
+    } else if (reference.startsWith("lucide:")) {
+      const name = reference.slice("lucide:".length);
+      if (/^[a-z0-9-]+$/.test(name) && this.#lucideDirectory) {
+        html = renderSvg(
+          readSvg(path2.join(this.#lucideDirectory, `${name}.svg`))
+        );
+      }
+    } else if (reference.startsWith("text:")) {
+      html = escapeHtml(reference.slice("text:".length));
+    }
+    this.#cache.set(reference, html ?? null);
+    return html;
+  }
+};
+function renderSvg(source) {
+  if (!source || !/<svg[\s>]/i.test(source)) return void 0;
+  const sanitized = sanitizeHtml(source, SANITIZE_OPTIONS);
+  if (!/<svg[\s>]/i.test(sanitized) || /<script|<foreignObject|<style|<use|<image|<animate|<set|\son[a-z]+\s*=|javascript:|(?:xlink:)?href\s*=|url\s*\(/i.test(
+    sanitized
+  )) {
+    return void 0;
+  }
+  return sanitized;
+}
+function readSvg(filePath) {
+  if (!filePath) return void 0;
+  try {
+    const bytes = readFileSync(filePath);
+    if (bytes.byteLength > MAX_SVG_BYTES2) return void 0;
+    return bytes.toString("utf8");
+  } catch {
+    return void 0;
+  }
+}
+function resolveLucideDirectory() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    try {
+      return path2.join(
+        path2.dirname(require2.resolve("lucide-static/package.json")),
+        "icons"
+      );
+    } catch {
+      let current = path2.dirname(require2.resolve("lucide-static"));
+      for (; ; ) {
+        if (path2.basename(current) === "lucide-static") {
+          return path2.join(current, "icons");
+        }
+        const parent = path2.dirname(current);
+        if (parent === current) return void 0;
+        current = parent;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+}
+
+// src/resolve.ts
+var DEFAULT_PRECEDENCE = [
+  "config",
+  "frontmatter",
+  "iconic",
+  "iconize"
+];
+var SOURCES = /* @__PURE__ */ new Set(["iconize", "iconic"]);
+var PRECEDENCE = /* @__PURE__ */ new Set([
+  "config",
+  "frontmatter",
+  "iconic",
+  "iconize"
+]);
+function resolveIconsOptions(options) {
+  const sources = options?.sources?.length ? [...new Set(options.sources)] : ["iconize", "iconic"];
+  const precedence = options?.precedence?.length ? [...new Set(options.precedence)] : [...DEFAULT_PRECEDENCE];
+  return {
+    sources,
+    inline: options?.inline !== false,
+    frontmatter: options?.frontmatter !== false,
+    colors: options?.colors !== false,
+    precedence,
+    overrides: options?.overrides ?? {},
+    ...options?.vaultRoot === void 0 ? {} : { vaultRoot: options.vaultRoot },
+    ...options?.vaultPrefix === void 0 ? {} : { vaultPrefix: options.vaultPrefix },
+    iconize: {
+      enabled: sources.includes("iconize") && options?.iconize?.enabled !== false,
+      ...options?.iconize?.dataFile === void 0 ? {} : { dataFile: options.iconize.dataFile },
+      ...options?.iconize?.iconPacks === void 0 ? {} : { iconPacks: options.iconize.iconPacks }
+    },
+    iconic: {
+      enabled: sources.includes("iconic") && options?.iconic?.enabled !== false,
+      ...options?.iconic?.dataFile === void 0 ? {} : { dataFile: options.iconic.dataFile }
+    }
+  };
+}
+function validateIconsOptions(options) {
+  if (options === void 0) return void 0;
+  const issues = [];
+  if (options.sources !== void 0) {
+    if (!Array.isArray(options.sources) || options.sources.length === 0) {
+      issues.push({ path: "sources", message: "must be a non-empty array." });
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      options.sources.forEach((source, index) => {
+        if (!SOURCES.has(source)) {
+          issues.push({
+            path: `sources[${index}]`,
+            message: `unknown source "${String(source)}".`
+          });
+        } else if (seen.has(source)) {
+          issues.push({
+            path: `sources[${index}]`,
+            message: `duplicate source "${source}".`
+          });
+        }
+        seen.add(source);
+      });
+    }
+  }
+  if (options.precedence !== void 0) {
+    if (!Array.isArray(options.precedence) || options.precedence.length === 0) {
+      issues.push({
+        path: "precedence",
+        message: "must be a non-empty array."
+      });
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      options.precedence.forEach((source, index) => {
+        if (!PRECEDENCE.has(source)) {
+          issues.push({
+            path: `precedence[${index}]`,
+            message: `unknown precedence "${String(source)}".`
+          });
+        } else if (seen.has(source)) {
+          issues.push({
+            path: `precedence[${index}]`,
+            message: `duplicate precedence "${source}".`
+          });
+        }
+        seen.add(source);
+      });
+    }
+  }
+  for (const key of ["inline", "frontmatter", "colors"]) {
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+      issues.push({ path: key, message: "must be a boolean." });
+    }
+  }
+  if (options.overrides !== void 0) {
+    if (!isRecord2(options.overrides)) {
+      issues.push({ path: "overrides", message: "must be an object." });
+    } else {
+      for (const [key, value] of Object.entries(options.overrides)) {
+        if (typeof value === "string") continue;
+        if (!isRecord2(value) || typeof value.icon !== "string" || value.color !== void 0 && typeof value.color !== "string") {
+          issues.push({
+            path: `overrides.${key}`,
+            message: "must be a string or an object with an icon string."
+          });
+        }
+      }
+    }
+  }
+  for (const key of ["vaultRoot", "vaultPrefix"]) {
+    if (options[key] !== void 0 && typeof options[key] !== "string") {
+      issues.push({ path: key, message: "must be a string." });
+    }
+  }
+  for (const key of ["iconize", "iconic"]) {
+    const value = options[key];
+    if (value !== void 0 && !isRecord2(value)) {
+      issues.push({ path: key, message: "must be an object." });
+    }
+  }
+  return issues.length > 0 ? issues : void 0;
+}
+function createIconResolver(input) {
+  const { settings, options } = input;
+  const renderer = new IconRenderer(settings);
+  const warnings = [];
+  const iconizeSettings = settings.iconize?.settings;
+  const identifier = iconizeSettings?.iconIdentifier ?? ":";
+  const packNames = [...settings.iconPacks.keys()];
+  const reportUnknown = (reference) => {
+    warnings.push(`Icon "${reference}" could not be rendered.`);
+  };
+  const render = (reference, source, target, color) => {
+    const icon = renderer.render(reference, {
+      source,
+      target,
+      ...color === void 0 ? {} : { color }
+    });
+    if (!icon) reportUnknown(reference);
+    return icon;
+  };
+  const fromOverride = (target) => {
+    const override = findOverride(options.overrides, target);
+    if (override === void 0) return void 0;
+    const value = typeof override === "string" ? { icon: override } : override;
+    const reference = parseIconReference(value.icon, packNames);
+    if (!reference) return void 0;
+    const color = options.colors ? normalizeColor(value.color, { iconicNames: true }) : void 0;
+    return render(reference, "config", target.path, color);
+  };
+  const fromFrontmatter = (target) => {
+    if (!options.frontmatter || target.kind !== "file" || !target.frontmatter) {
+      return void 0;
+    }
+    const iconField = iconizeSettings?.iconInFrontmatterFieldName ?? "icon";
+    const colorField = iconizeSettings?.iconColorInFrontmatterFieldName ?? "iconColor";
+    const raw = target.frontmatter[iconField];
+    const iconValue = typeof raw === "string" ? raw.trim() : "";
+    if (!iconValue) return void 0;
+    const reference = parseIconReference(iconValue, packNames);
+    if (!reference) return void 0;
+    const rawColor = target.frontmatter[colorField];
+    const color = options.colors ? normalizeColor(typeof rawColor === "string" ? rawColor : void 0, {
+      iconicNames: true
+    }) ?? normalizeColor(iconizeSettings?.iconColor) : void 0;
+    return render(reference, "frontmatter", target.path, color);
+  };
+  const fromIconic = (target) => {
+    if (!options.iconic.enabled || !settings.iconic) return void 0;
+    const resolution = resolveIconic(settings.iconic, target, {
+      colors: options.colors,
+      report: input.reportRule
+    });
+    if (!resolution?.icon) return void 0;
+    return render(
+      resolveIconicReference(resolution.icon),
+      "iconic",
+      target.path,
+      resolution.color
+    );
+  };
+  const fromIconize = (target) => {
+    if (!options.iconize.enabled || !settings.iconize) return void 0;
+    const resolution = resolveIconize(settings.iconize, target, {
+      colors: options.colors,
+      packs: settings.iconPacks
+    });
+    if (!resolution) return void 0;
+    return render(resolution.icon, "iconize", target.path, resolution.color);
+  };
+  const forTarget = (target) => {
+    for (const source of options.precedence) {
+      if (source === "config") {
+        const icon = fromOverride(target);
+        if (icon) return icon;
+      } else if (source === "frontmatter") {
+        const icon = fromFrontmatter(target);
+        if (icon) return icon;
+      } else if (source === "iconic") {
+        const icon = fromIconic(target);
+        if (icon) return icon;
+      } else if (source === "iconize") {
+        const icon = fromIconize(target);
+        if (icon) return icon;
+      }
+    }
+    return void 0;
+  };
+  return {
+    identifier,
+    forEntry(entry) {
+      return forTarget(targetForEntry(entry, settings.vaultPrefix));
+    },
+    forFolder(folder) {
+      return forTarget(iconTarget("folder", folder, settings.vaultPrefix));
+    },
+    forTag(tag) {
+      if (!options.iconic.enabled || !settings.iconic) return void 0;
+      const value = findKey(settings.iconic.tagIcons, tag.replace(/^#/, ""));
+      if (!value) return void 0;
+      return fromNamedValue(value, `tag:${tag}`, "iconic");
+    },
+    forProperty(property) {
+      if (!options.iconic.enabled || !settings.iconic) return void 0;
+      const value = findKey(settings.iconic.propertyIcons, property);
+      if (!value) return void 0;
+      return fromNamedValue(value, `property:${property}`, "iconic");
+    },
+    inline(name) {
+      if (!options.inline || iconizeSettings?.iconsInNotesEnabled === false) {
+        return void 0;
+      }
+      if (name.includes(":")) return void 0;
+      const emoji = lookupEmoji(name) ?? (isEmoji(name) ? name : void 0);
+      const color = options.colors ? normalizeColor(iconizeSettings?.iconColor) : void 0;
+      if (emoji) {
+        return render(`emoji:${emoji}`, "iconize", `inline:${name}`, color);
+      }
+      const lucideType = iconizeSettings?.lucideIconPackType ?? "native";
+      const reference = parseIconReference(name, packNames);
+      if (!reference) return void 0;
+      if (lucideType === "none" && reference.startsWith("lucide:")) {
+        return void 0;
+      }
+      return render(reference, "iconize", `inline:${name}`, color);
+    },
+    warnings() {
+      return warnings;
+    }
+  };
+  function fromNamedValue(value, target, source) {
+    if (!value.icon) return void 0;
+    const color = options.colors ? normalizeColor(value.color, { iconicNames: true }) : void 0;
+    return render(resolveIconicReference(value.icon), source, target, color);
+  }
+}
+function targetForEntry(entry, vaultPrefix) {
+  const frontmatter = entry.frontmatter;
+  const links = entry.links.map((link) => link.raw);
+  return {
+    kind: "file",
+    path: vaultPath(vaultPrefix, `${entry.slug}.md`),
+    slug: entry.slug,
+    frontmatter,
+    tags: entry.tags,
+    links,
+    embeds: entry.links.filter((link) => link.embed).map((link) => link.raw),
+    ...entry.file?.ctime ? { created: entry.file.ctime } : {},
+    ...entry.file?.mtime ? { modified: entry.file.mtime } : {}
+  };
+}
+function iconTarget(kind, value, vaultPrefix) {
+  return {
+    kind,
+    path: vaultPath(vaultPrefix, value),
+    slug: value
+  };
+}
+function vaultPath(prefix, value) {
+  return normalizeVaultPath(`${prefix}${value}`) ?? value;
+}
+function findOverride(overrides, target) {
+  const candidates = /* @__PURE__ */ new Set([
+    target.path,
+    target.slug,
+    target.path.replace(/\.md$/, "")
+  ]);
+  for (const [key, value] of Object.entries(overrides)) {
+    const normalized = normalizeVaultPath(key);
+    if (!normalized) continue;
+    if (candidates.has(normalized)) return value;
+    if (candidates.has(normalized.replace(/\.md$/, ""))) return value;
+    if (normalized.startsWith("./") && candidates.has(normalized.slice(2))) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function findKey(values, key) {
+  if (values[key] !== void 0) return values[key];
+  const lower = key.toLowerCase();
+  for (const [candidate, value] of Object.entries(values)) {
+    if (candidate.toLowerCase() === lower) return value;
+  }
+  return void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// index.ts
+var PLUGIN_NAME = "icons";
+var EXTERNAL_ID = "icons:settings";
+function icons(options = {}) {
+  const resolvedOptions = resolveIconsOptions(options);
+  let loaded;
+  let resolver;
+  const ruleDiagnostics = /* @__PURE__ */ new Map();
+  const reportRule = (rule, message) => {
+    const key = `${rule.id ?? rule.name ?? "rule"}:${message}`;
+    ruleDiagnostics.set(key, {
+      code: "icons-unsupported-rule",
+      severity: "info",
+      pluginName: PLUGIN_NAME,
+      message: `Iconic rule "${rule.name ?? rule.id ?? "unnamed"}" ${message}; it did not match.`,
+      meta: { ...rule.id ? { ruleId: rule.id } : {} }
+    });
+  };
+  return definePlugin({
+    name: PLUGIN_NAME,
+    order: 20,
+    options,
+    contentFileMetadata: true,
+    validateOptions: validateIconsOptions,
+    processedContentCache: {
+      version: "icons-v1",
+      dependencyMode: "none",
+      environmentFingerprint: () => loaded?.fingerprint
+    },
+    contentOutputDependencies: [{ type: "external", id: EXTERNAL_ID }],
+    assets: [
+      createStyleAsset(PLUGIN_NAME, "@riebeckite/plugin-icons/style.css")
+    ],
+    resolveExternalDependencies: async (context) => {
+      ruleDiagnostics.clear();
+      resolver = void 0;
+      try {
+        loaded = await loadIconsSettings(resolvedOptions, context.config);
+        resolver = createIconResolver({
+          settings: loaded,
+          options: resolvedOptions,
+          reportRule
+        });
+      } catch {
+        loaded = void 0;
+        resolver = void 0;
+        ruleDiagnostics.set("icons-load-failed", {
+          code: "icons-load-failed",
+          severity: "warning",
+          pluginName: PLUGIN_NAME,
+          message: "Obsidian icon settings could not be loaded; continuing without icons."
+        });
+      }
+      return [
+        {
+          kind: "resolved",
+          snapshot: {
+            id: EXTERNAL_ID,
+            fingerprint: loaded?.fingerprint ?? "icons-unavailable",
+            scope: { type: "all" },
+            value: { version: 1 }
+          }
+        }
+      ];
+    },
+    extendMarkdownPipeline: (pipeline) => {
+      pipeline.use(remarkIcons, {
+        identifier: resolver?.identifier ?? ":",
+        resolve: (name) => resolver?.inline(name)
+      });
+    },
+    onManifestCreated: ({ manifest }) => {
+      if (!loaded || !resolver) return;
+      for (const entry of manifest.entries) {
+        const icon = resolver.forEntry(entry);
+        if (icon) entry.icon = icon;
+      }
+      const folders = collectFolders(
+        manifest.entries,
+        manifest.folderLocations
+      );
+      const tags = /* @__PURE__ */ new Map();
+      const properties = /* @__PURE__ */ new Map();
+      const folderIcons = /* @__PURE__ */ new Map();
+      for (const folder of folders) {
+        const icon = resolver.forFolder(folder);
+        if (icon) folderIcons.set(folder, icon);
+      }
+      for (const entry of manifest.entries) {
+        for (const tag of entry.tags) {
+          if (tags.has(tag)) continue;
+          const icon = resolver.forTag(tag);
+          if (icon) tags.set(tag, icon);
+        }
+        for (const property of Object.keys(entry.frontmatter)) {
+          if (properties.has(property)) continue;
+          const icon = resolver.forProperty(property);
+          if (icon) properties.set(property, icon);
+        }
+      }
+      for (const [pathname, location] of manifest.folderLocations) {
+        const folder = location.folder ?? pathname;
+        const icon = folderIcons.get(folder) ?? resolver.forFolder(folder);
+        if (icon) location.icon = icon;
+      }
+      const registry = {
+        ...tags.size ? { tags: Object.fromEntries(tags) } : {},
+        ...properties.size ? { properties: Object.fromEntries(properties) } : {},
+        ...folderIcons.size ? { folders: Object.fromEntries(folderIcons) } : {}
+      };
+      if (Object.keys(registry).length > 0) manifest.icons = registry;
+    },
+    addDiagnostics: () => {
+      const diagnostics = [];
+      for (const diagnostic of loaded?.diagnostics ?? []) {
+        diagnostics.push({
+          code: diagnostic.code,
+          severity: diagnostic.severity,
+          pluginName: PLUGIN_NAME,
+          message: diagnostic.message,
+          ...diagnostic.meta ? { meta: { ...diagnostic.meta } } : {}
+        });
+      }
+      for (const warning of resolver?.warnings() ?? []) {
+        diagnostics.push({
+          code: "icons-unresolved-icon",
+          severity: "warning",
+          pluginName: PLUGIN_NAME,
+          message: warning
+        });
+      }
+      diagnostics.push(...ruleDiagnostics.values());
+      return diagnostics;
+    }
+  });
+}
+function collectFolders(entries, folderLocations) {
+  const folders = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const segments = entry.slug.split("/");
+    segments.pop();
+    for (let index = 1; index <= segments.length; index += 1) {
+      folders.add(segments.slice(0, index).join("/"));
+    }
+  }
+  for (const location of folderLocations.values()) {
+    if (location.folder) folders.add(location.folder);
+  }
+  return [...folders].filter(Boolean).toSorted();
+}
+export {
+  icons
+};