@silicajs/core 0.1.0

package/dist/chunk-L565TMI5.js

@@ -0,0 +1,1045 @@
+// src/path.ts
+import path from "path";
+var NUMERIC_PREFIX_RE = /^(\d+)[\s._-]+(.+)$/;
+var UNORDERED_SEGMENT_SORT_PREFIX = "~~~~~~~~~~";
+function asFilePath(value) {
+  return normalizePath(value);
+}
+function asFullSlug(value) {
+  return normalizeSlug(value);
+}
+function asSimpleSlug(value) {
+  return simplifySlug(asFullSlug(value));
+}
+function asRelativeURL(value) {
+  return value;
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function stripNumericPrefix(segment) {
+  return segment.replace(NUMERIC_PREFIX_RE, "$2");
+}
+function hasNumericPrefix(segment) {
+  return NUMERIC_PREFIX_RE.test(segment);
+}
+function slugifySegment(segment, options = {}) {
+  const stem = segment.replace(/\.[^.]+$/, "");
+  const displaySegment = options.numericPrefixes ? stripNumericPrefix(stem) : stem;
+  return displaySegment.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function normalizeSlug(value, options = {}) {
+  const cleaned = normalizePath(value).replace(/^\.\//, "").replace(/\.(md|markdown|mdx)$/i, "");
+  const parts = cleaned.split("/").filter(Boolean).map((part) => slugifySegment(part, options));
+  return (parts.join("/") || "index").replace(/\/index\/index$/, "/index");
+}
+function slugifyFilePath(filePath, contentDir = "content", options = {}) {
+  const normalizedFile = normalizePath(filePath);
+  const normalizedContent = normalizePath(contentDir);
+  const relative = normalizedFile.startsWith(`${normalizedContent}/`) ? normalizedFile.slice(normalizedContent.length + 1) : normalizedFile;
+  return asFullSlug(normalizeSlug(relative, options));
+}
+function hasNumericPrefixInPath(filePath) {
+  return normalizePath(filePath).split("/").some((segment) => hasNumericPrefix(segment.replace(/\.[^.]+$/, "")));
+}
+function numericPrefixSortKey(filePath) {
+  return normalizePath(filePath).replace(/\.(md|markdown|mdx)$/i, "").split("/").filter(Boolean).map(numericPrefixSortSegment).join("/");
+}
+function simplifySlug(slug) {
+  const normalized = normalizeSlug(slug);
+  if (normalized === "index") return "";
+  return normalized.replace(/\/index$/, "");
+}
+function slugToHref(slug) {
+  const simple = simplifySlug(slug).toString();
+  return simple ? `/${simple}` : "/";
+}
+function hrefToSlug(href) {
+  const normalized = normalizePath(href.split("#")[0] ?? "");
+  return asFullSlug(normalized === "" ? "index" : normalized);
+}
+function pathToRoot(slug) {
+  const simple = simplifySlug(slug).toString();
+  const depth = simple ? simple.split("/").length - 1 : 0;
+  return asRelativeURL(depth === 0 ? "." : Array(depth).fill("..").join("/"));
+}
+function resolveRelative(currentSlug, target, options = {}) {
+  const currentDir = normalizePath(currentSlug).split("/").slice(0, -1).join("/");
+  return asFullSlug(
+    normalizeSlug(path.posix.join(currentDir, target), options)
+  );
+}
+function resolveWikiLink(currentSlug, target, allSlugs, strategy = "shortest", options = {}) {
+  const [rawPath] = target.split("#");
+  const normalizedTarget = normalizeSlug(rawPath ?? target, options);
+  const candidates = new Set(allSlugs.map((slug) => normalizeSlug(slug)));
+  if (strategy === "absolute" && candidates.has(normalizedTarget))
+    return asFullSlug(normalizedTarget);
+  if (strategy === "relative") {
+    const relative = resolveRelative(currentSlug, normalizedTarget, options);
+    if (candidates.has(relative)) return relative;
+  }
+  if (candidates.has(normalizedTarget)) return asFullSlug(normalizedTarget);
+  if (candidates.has(`${normalizedTarget}/index`))
+    return asFullSlug(`${normalizedTarget}/index`);
+  const byBasename = [...candidates].filter((slug) => {
+    const simplified = simplifySlug(slug).toString();
+    return simplified.split("/").at(-1) === normalizedTarget.split("/").at(-1);
+  });
+  return byBasename.length === 1 ? asFullSlug(byBasename[0]) : void 0;
+}
+function joinSegments(...segments) {
+  return normalizePath(segments.filter(Boolean).join("/"));
+}
+function numericPrefixSortSegment(segment) {
+  const stem = segment.replace(/\.[^.]+$/, "");
+  const match = NUMERIC_PREFIX_RE.exec(stem);
+  if (!match) {
+    return `${UNORDERED_SEGMENT_SORT_PREFIX}:${slugifySegment(stem)}`;
+  }
+  const order = match[1].padStart(10, "0");
+  return `${order}:${slugifySegment(match[2])}`;
+}
+
+// src/pipeline/frontmatter.ts
+var RESERVED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "aliases",
+  "alias",
+  "created",
+  "cssclass",
+  "cssclasses",
+  "date",
+  "description",
+  "draft",
+  "listed",
+  "menu_label",
+  "modified",
+  "permalink",
+  "publish",
+  "tag",
+  "tags",
+  "title"
+]);
+function getMenuLabel(frontmatter, title) {
+  if (typeof frontmatter.menu_label === "string" && frontmatter.menu_label.trim()) {
+    return frontmatter.menu_label.trim();
+  }
+  return title;
+}
+function getPageProperties(frontmatter) {
+  return Object.entries(frontmatter).filter(([key]) => !RESERVED_FRONTMATTER_KEYS.has(key.toLowerCase())).map(([key, value]) => {
+    const formatted = formatPropertyValue(value);
+    if (formatted === void 0) return void 0;
+    return {
+      key,
+      label: formatPropertyLabel(key),
+      value: formatted
+    };
+  }).filter((property) => property !== void 0).sort((a, b) => a.key.localeCompare(b.key));
+}
+function formatPropertyLabel(key) {
+  return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+}
+function formatPropertyValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => formatPropertyValue(item)).filter((item) => item !== void 0);
+    return items.length ? items.join(", ") : void 0;
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/tags.ts
+import { normalizeTag } from "@silicajs/remark-obsidian";
+function tagToHref(tag) {
+  const normalized = normalizeTag(tag);
+  if (!normalized) return "/tags";
+  const encoded = normalized.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  return `/tags/${encoded}`;
+}
+
+// src/pipeline/index.ts
+import matter from "gray-matter";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkRehype from "remark-rehype";
+import rehypeRaw from "rehype-raw";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import rehypeKatex from "rehype-katex";
+import rehypeSlug from "rehype-slug";
+import rehypeAutolinkHeadings from "rehype-autolink-headings";
+import rehypeShiki from "@shikijs/rehype";
+import rehypeReact from "rehype-react";
+import rehypeStringify from "rehype-stringify";
+import { getTags, remarkObsidian } from "@silicajs/remark-obsidian";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { visit as visit3 } from "unist-util-visit";
+
+// src/pipeline/code-block.ts
+var LANGUAGE_LABELS = {
+  bash: "Bash",
+  c: "C",
+  cpp: "C++",
+  cs: "C#",
+  css: "CSS",
+  diff: "Diff",
+  docker: "Dockerfile",
+  dockerfile: "Dockerfile",
+  go: "Go",
+  graphql: "GraphQL",
+  html: "HTML",
+  ini: "INI",
+  java: "Java",
+  javascript: "JavaScript",
+  js: "JavaScript",
+  json: "JSON",
+  jsonc: "JSON",
+  jsx: "JSX",
+  kotlin: "Kotlin",
+  less: "Less",
+  lua: "Lua",
+  markdown: "Markdown",
+  md: "Markdown",
+  mdx: "MDX",
+  objc: "Objective-C",
+  php: "PHP",
+  ps: "PowerShell",
+  ps1: "PowerShell",
+  powershell: "PowerShell",
+  py: "Python",
+  python: "Python",
+  r: "R",
+  rb: "Ruby",
+  ruby: "Ruby",
+  rs: "Rust",
+  rust: "Rust",
+  scala: "Scala",
+  scss: "SCSS",
+  sh: "Shell",
+  shell: "Shell",
+  sql: "SQL",
+  svelte: "Svelte",
+  swift: "Swift",
+  toml: "TOML",
+  ts: "TypeScript",
+  tsx: "TSX",
+  typescript: "TypeScript",
+  vue: "Vue",
+  xml: "XML",
+  yaml: "YAML",
+  yml: "YAML",
+  zig: "Zig",
+  zsh: "Zsh"
+};
+var HIDDEN_LANGUAGES = /* @__PURE__ */ new Set([
+  "",
+  "text",
+  "plain",
+  "plaintext",
+  "txt",
+  "ansi"
+]);
+function formatLanguage(lang) {
+  if (!lang) return null;
+  const lower = lang.toLowerCase();
+  if (HIDDEN_LANGUAGES.has(lower)) return null;
+  return LANGUAGE_LABELS[lower] ?? lang;
+}
+function rehypeShikiCodeBlockWrapper() {
+  return {
+    name: "silica:code-block-wrapper",
+    root(hast) {
+      const pre = hast.children.find(
+        (child) => child.type === "element" && child.tagName === "pre"
+      );
+      if (!pre) return hast;
+      const rawLang = typeof this.options.lang === "string" ? this.options.lang : void 0;
+      const label = formatLanguage(rawLang);
+      const isMermaid = rawLang?.toLowerCase() === "mermaid";
+      const wrapper = {
+        type: "element",
+        tagName: isMermaid ? "silica-mermaid" : "silica-code-block",
+        properties: {
+          ...rawLang ? { "data-language": rawLang } : {},
+          ...isMermaid ? { "data-source": toText(pre) } : {},
+          ...label ? { "data-language-label": label } : {}
+        },
+        children: [pre]
+      };
+      hast.children = [wrapper];
+      return hast;
+    }
+  };
+}
+function toText(node) {
+  return node.children.map((child) => {
+    if (child.type === "text") return child.value;
+    if (child.type === "element") return toText(child);
+    return "";
+  }).join("");
+}
+
+// src/pipeline/obsidian.ts
+import { visit } from "unist-util-visit";
+import { slug as slugifyHeading } from "github-slugger";
+function remarkSilicaObsidian(context) {
+  return async (tree, file) => {
+    const links = /* @__PURE__ */ new Set();
+    const brokenLinks = [];
+    const assetBaseUrl = context.assetBaseUrl ?? "/silica";
+    const embedPromises = [];
+    transformInlineFootnotes(tree);
+    visit(tree, (node) => {
+      if (node.type === "image" && typeof node.url === "string") {
+        node.url = rewriteAssetUrl(node.url, assetBaseUrl);
+        applyImageSize(node);
+        return;
+      }
+      if (!isWikiNode(node)) return;
+      if (node.type === "obsidianWikiEmbed" && !isAssetTarget(node.rawTarget)) {
+        embedPromises.push(resolveEmbedNode(node, context));
+      }
+      const targetPath = node.linkTarget.path || String(context.slug);
+      if (node.type === "obsidianWikiEmbed" && isAssetTarget(node.rawTarget)) {
+        return;
+      }
+      const resolved = resolveWikiLink(
+        context.slug,
+        targetPath,
+        context.allSlugs,
+        context.wikilinkStrategy ?? "shortest",
+        context.ordering
+      );
+      node.data = { ...node.data };
+      if (!resolved) {
+        node.data.silicaBroken = true;
+        brokenLinks.push({ target: node.rawTarget });
+        return;
+      }
+      node.data.silicaResolvedSlug = resolved;
+      links.add(resolved);
+    });
+    await Promise.all(embedPromises);
+    file.data.silicaObsidianLinks = [...links];
+    file.data.silicaObsidianBrokenLinks = brokenLinks;
+  };
+}
+function createSilicaObsidianHandlers(context) {
+  return {
+    obsidianWikilink(state, node) {
+      return wikilinkToHast(state, node);
+    },
+    obsidianWikiEmbed(state, node) {
+      if (node.rawTarget && isAssetTarget(node.rawTarget)) {
+        return assetEmbedToHast(context, node);
+      }
+      const embedHtml = getStringData(node, "silicaEmbedHtml");
+      if (embedHtml) {
+        return {
+          type: "element",
+          tagName: "figure",
+          properties: {
+            className: ["silica-embed", "silica-note-embed"],
+            "data-embed-kind": "note",
+            "data-embed-target": node.rawTarget
+          },
+          children: [{ type: "raw", value: embedHtml }]
+        };
+      }
+      return wikilinkToHast(state, node);
+    },
+    obsidianHighlight(state, node) {
+      return {
+        type: "element",
+        tagName: "mark",
+        properties: {},
+        children: state.all(node)
+      };
+    },
+    obsidianCallout(state, node) {
+      return {
+        type: "element",
+        tagName: "silica-callout",
+        properties: {
+          className: ["silica-callout"],
+          "data-callout": node.kind ?? "note",
+          "data-callout-title": node.title ?? titleCase(node.kind ?? "note"),
+          ...node.fold ? {
+            "data-callout-foldable": "true",
+            "data-callout-open": node.fold === "open" ? "true" : "false"
+          } : {}
+        },
+        children: state.all(node)
+      };
+    },
+    obsidianTag(state, node) {
+      return {
+        type: "element",
+        tagName: "a",
+        properties: { href: tagToHref(node.tag ?? "") },
+        children: state.all(node)
+      };
+    },
+    obsidianComment(_state, _node) {
+      return { type: "text", value: "" };
+    },
+    obsidianBlockId(_state, node) {
+      return {
+        type: "element",
+        tagName: "span",
+        properties: {
+          id: `^${node.id}`,
+          className: ["silica-block-id"],
+          "data-silica-block-id": node.id,
+          ariaHidden: "true"
+        },
+        children: []
+      };
+    }
+  };
+}
+function transformInlineFootnotes(tree) {
+  const definitions = [];
+  let nextIndex = 1;
+  visit(
+    tree,
+    "obsidianInlineFootnote",
+    (node, index, parent) => {
+      if (index === void 0 || !parent) return;
+      const identifier = `obsidian-inline-${nextIndex++}`;
+      parent.children[index] = {
+        type: "footnoteReference",
+        identifier,
+        label: identifier
+      };
+      definitions.push({
+        type: "footnoteDefinition",
+        identifier,
+        label: identifier,
+        children: [
+          {
+            type: "paragraph",
+            children: node.children.length ? node.children : [{ type: "text", value: node.value }]
+          }
+        ]
+      });
+    }
+  );
+  tree.children.push(...definitions);
+}
+function wikilinkToHast(_state, node) {
+  const label = node.alias || node.target || "";
+  const resolved = getResolvedSlug(node);
+  if (!resolved) {
+    return {
+      type: "element",
+      tagName: "span",
+      properties: { className: ["silica-broken-link"] },
+      children: [{ type: "text", value: label }]
+    };
+  }
+  return {
+    type: "element",
+    tagName: "a",
+    properties: { href: `${slugToHref(resolved)}${targetFragment(node)}` },
+    children: [{ type: "text", value: label }]
+  };
+}
+function isWikiNode(node) {
+  return (node.type === "obsidianWikilink" || node.type === "obsidianWikiEmbed") && typeof node.rawTarget === "string";
+}
+function getResolvedSlug(node) {
+  const value = node.data?.silicaResolvedSlug;
+  return typeof value === "string" ? value : void 0;
+}
+function getStringData(node, key) {
+  const value = node.data?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+async function resolveEmbedNode(node, context) {
+  if (!context.resolveEmbed) return;
+  const maxDepth = context.maxEmbedDepth ?? 3;
+  const depth = context.embedDepth ?? 0;
+  if (depth >= maxDepth) return;
+  const html = await context.resolveEmbed(node.linkTarget);
+  if (!html) return;
+  node.data = {
+    ...node.data,
+    silicaEmbedHtml: html
+  };
+}
+function assetEmbedToHast(context, node) {
+  const kind = assetKind(node.rawTarget);
+  const src = assetUrl(context.assetBaseUrl ?? "/silica", node.rawTarget);
+  const label = node.alias || node.rawTarget.split("/").at(-1) || node.rawTarget;
+  const dimensions = sizeProperties(
+    node.embedSize ?? sizeFromParams(node.linkTarget.params)
+  );
+  if (kind === "image") {
+    return {
+      type: "element",
+      tagName: "img",
+      properties: {
+        src,
+        alt: label,
+        ...dimensions
+      },
+      children: []
+    };
+  }
+  if (kind === "audio" || kind === "video") {
+    return {
+      type: "element",
+      tagName: kind,
+      properties: {
+        src,
+        controls: true,
+        ...dimensions
+      },
+      children: []
+    };
+  }
+  return {
+    type: "element",
+    tagName: "silica-embed",
+    properties: {
+      src,
+      "data-embed-kind": kind,
+      "data-embed-target": node.rawTarget,
+      ...dimensions
+    },
+    children: [{ type: "text", value: label }]
+  };
+}
+function targetFragment(node) {
+  if (node.linkTarget.blockId) {
+    return `#^${encodeURIComponent(node.linkTarget.blockId)}`;
+  }
+  if (node.linkTarget.heading) {
+    return `#${slugifyHeading(node.linkTarget.heading)}`;
+  }
+  return "";
+}
+function applyImageSize(node) {
+  const size = node.data?.obsidianEmbedSize;
+  if (!size) return;
+  node.data = {
+    ...node.data,
+    hProperties: {
+      ...node.data?.hProperties ?? {},
+      ...sizeProperties(size)
+    }
+  };
+}
+function sizeFromParams(params) {
+  const height = Number(params?.height);
+  if (!Number.isFinite(height) || height <= 0) return;
+  return { width: 0, height };
+}
+function sizeProperties(size) {
+  if (!size) return {};
+  return {
+    ...size.width > 0 ? { width: size.width } : {},
+    ...size.height ? { height: size.height } : {}
+  };
+}
+function rewriteAssetUrl(url, assetBaseUrl) {
+  if (!isAssetTarget(url)) return url;
+  if (/^(?:https?:|#|\/)/.test(url)) return url;
+  return `${assetBaseUrl}/${url.replace(/^\.?\//, "")}`;
+}
+function isAssetTarget(target) {
+  return /\.(png|jpe?g|gif|webp|svg|pdf|mp4|mov|mp3|wav|ogg|canvas)(?:[?#].*)?$/i.test(
+    target
+  );
+}
+function isImageTarget(target) {
+  return /\.(png|jpe?g|gif|webp|svg)(?:[?#].*)?$/i.test(target);
+}
+function assetKind(target) {
+  if (isImageTarget(target)) return "image";
+  if (/\.(mp3|wav|ogg)(?:[?#].*)?$/i.test(target)) return "audio";
+  if (/\.(mp4|mov)(?:[?#].*)?$/i.test(target)) return "video";
+  if (/\.pdf(?:[?#].*)?$/i.test(target)) return "pdf";
+  if (/\.canvas(?:[?#].*)?$/i.test(target)) return "canvas";
+  return "file";
+}
+function assetUrl(assetBaseUrl, target) {
+  const cleaned = stripEmbedOnlyParams(target);
+  if (/^(?:https?:|#|\/)/.test(cleaned)) return cleaned;
+  return `${assetBaseUrl}/${cleaned.replace(/^\/+/, "")}`;
+}
+function stripEmbedOnlyParams(target) {
+  const hashIndex = target.indexOf("#");
+  if (hashIndex === -1) return target;
+  const before = target.slice(0, hashIndex);
+  const fragment = target.slice(hashIndex + 1);
+  if (!fragment.includes("=")) return target;
+  const params = new URLSearchParams(fragment);
+  params.delete("height");
+  const remaining = params.toString();
+  return remaining ? `${before}#${remaining}` : before;
+}
+function titleCase(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/pipeline/plugins.ts
+import Slugger from "github-slugger";
+import { toString } from "hast-util-to-string";
+import { visit as visit2 } from "unist-util-visit";
+function rehypeCollectTocAndLinks() {
+  return (tree, file) => {
+    const toc = [];
+    const links = /* @__PURE__ */ new Set();
+    const slugger = new Slugger();
+    visit2(tree, "element", (node) => {
+      if (isHeading(node)) {
+        const text = toString(node);
+        const id = String(node.properties?.id ?? slugger.slug(text));
+        node.properties = { ...node.properties, id };
+        if (id !== "footnote-label") {
+          toc.push({ id, text, depth: Number(node.tagName?.slice(1) ?? 2) });
+        }
+      }
+      if (node.tagName === "a" && typeof node.properties?.href === "string") {
+        const href = node.properties.href;
+        if (href.startsWith("/") && !href.startsWith("/silica/")) {
+          links.add(hrefToSlug(href));
+        }
+      }
+    });
+    file.data.toc = toc;
+    file.data.links = [...links];
+  };
+}
+function rehypeCleanFootnoteHeadings() {
+  return (tree) => {
+    visit2(tree, "element", (node) => {
+      if (node.properties?.id !== "footnote-label") return;
+      const child = node.children?.[0];
+      if (child?.tagName !== "a") return;
+      node.children = child.children ?? [];
+    });
+  };
+}
+function rehypeExternalLinks() {
+  return (tree) => {
+    visit2(tree, "element", (node) => {
+      if (node.tagName !== "a" || typeof node.properties?.href !== "string")
+        return;
+      if (!/^https?:\/\//.test(node.properties.href)) return;
+      node.properties = {
+        ...node.properties,
+        rel: "noreferrer noopener",
+        target: "_blank"
+      };
+    });
+  };
+}
+function rehypeUnwrapSilicaEmbeds() {
+  return (tree) => {
+    unwrapStandaloneEmbeds(tree);
+  };
+}
+function rehypeRestoreObsidianBlockIds() {
+  return (tree) => {
+    restoreGeneratedFootnoteIds(tree);
+    visit2(tree, "element", (node) => {
+      if (node.tagName !== "span") return;
+      const blockId = getStringProperty(
+        node,
+        "dataSilicaBlockId",
+        "data-silica-block-id"
+      );
+      if (!blockId) return;
+      node.properties = { ...node.properties, id: `^${blockId}` };
+    });
+  };
+}
+function getDataArray(data, key) {
+  const value = data[key];
+  return Array.isArray(value) ? value : [];
+}
+function mergeBrokenLinks(a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const item of [...a, ...b]) {
+    const key = `${item.source}\0${item.target}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(item);
+  }
+  return merged;
+}
+function isHeading(node) {
+  return node.type === "element" && /^h[1-6]$/.test(node.tagName ?? "");
+}
+function getStringProperty(node, camelCaseKey, kebabCaseKey) {
+  const value = node.properties?.[camelCaseKey] ?? node.properties?.[kebabCaseKey];
+  return typeof value === "string" ? value : void 0;
+}
+function restoreGeneratedFootnoteIds(node, inFootnotes = false) {
+  const isFootnotes = inFootnotes || isFootnotesSection(node);
+  if (isFootnotes || isFootnoteReference(node)) {
+    normalizeGeneratedFootnoteProperties(node);
+  }
+  for (const child of node.children ?? []) {
+    restoreGeneratedFootnoteIds(child, isFootnotes);
+  }
+}
+function normalizeGeneratedFootnoteProperties(node) {
+  if (!node.properties) return;
+  normalizeProperty(node, "id");
+  normalizeProperty(node, "href");
+  normalizeProperty(node, "ariaDescribedBy");
+  normalizeProperty(node, "aria-describedby");
+}
+function normalizeProperty(node, key) {
+  const value = node.properties?.[key];
+  if (typeof value !== "string") return;
+  node.properties = {
+    ...node.properties,
+    [key]: normalizeGeneratedFootnoteReference(value)
+  };
+}
+function normalizeGeneratedFootnoteReference(value) {
+  const prefix = value.startsWith("#") ? "#" : "";
+  const id = prefix ? value.slice(1) : value;
+  if (id === "user-content-footnote-label") return `${prefix}footnote-label`;
+  if (id.startsWith("user-content-user-content-fn")) {
+    return `${prefix}${id.replace(/^user-content-/, "")}`;
+  }
+  return value;
+}
+function isFootnotesSection(node) {
+  return node.tagName === "section" && hasProperty(node, "dataFootnotes", "data-footnotes");
+}
+function isFootnoteReference(node) {
+  return node.tagName === "a" && hasProperty(node, "dataFootnoteRef", "data-footnote-ref");
+}
+function hasProperty(node, camelCaseKey, kebabCaseKey) {
+  return node.properties?.[camelCaseKey] !== void 0 || node.properties?.[kebabCaseKey] !== void 0;
+}
+function unwrapStandaloneEmbeds(parent) {
+  if (!parent.children) return;
+  parent.children = parent.children.map((child) => {
+    unwrapStandaloneEmbeds(child);
+    if (child.tagName !== "p") return child;
+    const renderedChildren = child.children?.filter(
+      (candidate) => !isWhitespaceText(candidate)
+    );
+    const onlyChild = renderedChildren?.[0];
+    if (renderedChildren?.length === 1 && isStandaloneEmbed(onlyChild)) {
+      return onlyChild;
+    }
+    return child;
+  });
+}
+function isStandaloneEmbed(node) {
+  if (node?.tagName === "silica-embed") return true;
+  if (node?.tagName !== "figure") return false;
+  const kind = node.properties?.dataEmbedKind ?? node.properties?.["data-embed-kind"];
+  return kind === "note";
+}
+function isWhitespaceText(node) {
+  return node.type === "text" && /^\s*$/.test(node.value ?? "");
+}
+
+// src/pipeline/index.ts
+var headingLinkIcon = {
+  type: "element",
+  tagName: "svg",
+  properties: {
+    ariaHidden: "true",
+    className: ["silica-heading-link-icon"],
+    fill: "none",
+    stroke: "currentColor",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: 2,
+    viewBox: "0 0 24 24"
+  },
+  children: [
+    {
+      type: "element",
+      tagName: "path",
+      properties: {
+        d: "M9 17H7A5 5 0 0 1 7 7h2"
+      },
+      children: []
+    },
+    {
+      type: "element",
+      tagName: "path",
+      properties: {
+        d: "M15 7h2a5 5 0 1 1 0 10h-2"
+      },
+      children: []
+    },
+    {
+      type: "element",
+      tagName: "line",
+      properties: {
+        x1: 8,
+        x2: 16,
+        y1: 12,
+        y2: 12
+      },
+      children: []
+    }
+  ]
+};
+var sanitizeSchema = {
+  ...defaultSchema,
+  attributes: {
+    ...defaultSchema.attributes,
+    span: [
+      ...defaultSchema.attributes?.span ?? [],
+      ["className", "silica-broken-link"],
+      ["className", "silica-block-id"],
+      ["dataSilicaBlockId"],
+      ["data-silica-block-id"],
+      ["ariaHidden"],
+      ["aria-hidden"]
+    ],
+    sup: [
+      ...defaultSchema.attributes?.sup ?? [],
+      ["className", "silica-inline-footnote"]
+    ],
+    img: [...defaultSchema.attributes?.img ?? [], ["width"], ["height"]],
+    audio: [["src"], ["controls"], ["width"], ["height"]],
+    video: [["src"], ["controls"], ["width"], ["height"]],
+    source: [["src"], ["type"]],
+    figure: [
+      ...defaultSchema.attributes?.figure ?? [],
+      ["className", "silica-embed", "silica-note-embed"],
+      ["dataEmbedKind"],
+      ["data-embed-kind"],
+      ["dataEmbedTarget"],
+      ["data-embed-target"]
+    ],
+    strong: [
+      ...defaultSchema.attributes?.strong ?? [],
+      ["className", "silica-callout-title"],
+      ["dataCallout"],
+      ["data-callout"],
+      ["dataCalloutFold"],
+      ["data-callout-fold"]
+    ],
+    "silica-callout": [
+      ["className", "silica-callout"],
+      ["dataCallout"],
+      ["data-callout"],
+      ["dataCalloutTitle"],
+      ["data-callout-title"],
+      ["dataCalloutFoldable"],
+      ["data-callout-foldable"],
+      ["dataCalloutOpen"],
+      ["data-callout-open"]
+    ],
+    "silica-embed": [
+      ["src"],
+      ["width"],
+      ["height"],
+      ["dataEmbedKind"],
+      ["data-embed-kind"],
+      ["dataEmbedTarget"],
+      ["data-embed-target"]
+    ],
+    "silica-mermaid": [
+      ["dataSource"],
+      ["data-source"],
+      ["dataLanguage"],
+      ["data-language"],
+      ["dataLanguageLabel"],
+      ["data-language-label"]
+    ],
+    mark: defaultSchema.attributes?.mark ?? []
+  },
+  tagNames: [
+    ...defaultSchema.tagNames ?? [],
+    "mark",
+    "audio",
+    "video",
+    "source",
+    "figure",
+    "silica-callout",
+    "silica-embed",
+    "silica-mermaid"
+  ]
+};
+async function renderMarkdown(raw, context) {
+  const parsed = matter(raw);
+  const inlineTags = context.tags?.inline ?? true;
+  const processor = baseProcessor(context).use(rehypeUnwrapSilicaEmbeds).use(rehypeRaw).use(rehypeSanitize, sanitizeSchema).use(rehypeRestoreObsidianBlockIds).use(rehypeUnwrapSilicaEmbeds).use(rehypeKatex);
+  if (hasCodeFence(parsed.content)) {
+    processor.use(rehypeShiki, {
+      themes: {
+        light: "github-light",
+        dark: "github-dark"
+      },
+      defaultColor: "light-dark()",
+      // Ensure unlabeled fences still flow through Shiki so they pick up the
+      // wrapper transformer below (just without a language header).
+      defaultLanguage: "text",
+      rootStyle: false,
+      transformers: [rehypeShikiCodeBlockWrapper()]
+    });
+  }
+  processor.use(rehypeSlug).use(rehypeAutolinkHeadings, {
+    behavior: "wrap",
+    content: headingLinkIcon,
+    properties: { className: ["silica-heading-link"] }
+  }).use(rehypeCleanFootnoteHeadings).use(rehypeCollectTocAndLinks).use(rehypeExternalLinks).use(rehypeReact, {
+    Fragment,
+    jsx,
+    jsxs,
+    components: context.components
+  });
+  const file = await processor.process(parsed.content);
+  const frontmatter = parsed.data;
+  const obsidianBrokenLinks = getDataArray(
+    file.data,
+    "silicaObsidianBrokenLinks"
+  ).map((link) => ({ source: String(context.slug), target: link.target }));
+  const links = unique([
+    ...getDataArray(file.data, "silicaObsidianLinks"),
+    ...getDataArray(file.data, "links")
+  ]);
+  const toc = getDataArray(file.data, "toc");
+  const plainText = extractPlainText(parsed.content);
+  return {
+    content: file.result,
+    frontmatter,
+    toc,
+    links,
+    brokenLinks: mergeBrokenLinks(obsidianBrokenLinks, []),
+    plainText,
+    title: getTitle(frontmatter, plainText),
+    description: getDescription(frontmatter, plainText),
+    tags: getTags(frontmatter, parsed.content, { inline: inlineTags })
+  };
+}
+async function renderMarkdownHtml(raw, context) {
+  const parsed = matter(raw);
+  const processor = baseProcessor(context).use(rehypeUnwrapSilicaEmbeds).use(rehypeRaw).use(rehypeSanitize, sanitizeSchema).use(rehypeRestoreObsidianBlockIds).use(rehypeUnwrapSilicaEmbeds).use(rehypeKatex);
+  if (hasCodeFence(parsed.content)) {
+    processor.use(rehypeShiki, {
+      themes: {
+        light: "github-light",
+        dark: "github-dark"
+      },
+      defaultColor: "light-dark()",
+      defaultLanguage: "text",
+      rootStyle: false,
+      transformers: [rehypeShikiCodeBlockWrapper()]
+    });
+  }
+  processor.use(rehypeExternalLinks).use(rehypeStringify);
+  const file = await processor.process(parsed.content);
+  return String(file);
+}
+async function analyzeMarkdown(raw, context) {
+  const parsed = matter(raw);
+  const inlineTags = context.tags?.inline ?? true;
+  const file = await runRemarkObsidian(parsed.content, context);
+  const plainText = extractPlainText(parsed.content);
+  const frontmatter = parsed.data;
+  const brokenLinks = getDataArray(
+    file.data,
+    "silicaObsidianBrokenLinks"
+  ).map((link) => ({ source: String(context.slug), target: link.target }));
+  return {
+    frontmatter,
+    toc: [],
+    links: getDataArray(file.data, "silicaObsidianLinks"),
+    brokenLinks,
+    plainText,
+    title: getTitle(frontmatter, plainText),
+    description: getDescription(frontmatter, plainText),
+    tags: getTags(frontmatter, parsed.content, { inline: inlineTags })
+  };
+}
+function getTitle(frontmatter, plainText) {
+  if (typeof frontmatter.title === "string" && frontmatter.title.trim())
+    return frontmatter.title.trim();
+  const heading = plainText.split("\n").map((line) => line.trim()).find(Boolean);
+  return heading?.replace(/^#+\s*/, "");
+}
+function getDescription(frontmatter, plainText) {
+  if (typeof frontmatter.description === "string" && frontmatter.description.trim()) {
+    return frontmatter.description.trim();
+  }
+  const sentence = extractPlainText(plainText).slice(0, 180).trim();
+  return sentence || void 0;
+}
+function baseProcessor(context) {
+  return unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context).use(remarkRehype, {
+    allowDangerousHtml: true,
+    handlers: createSilicaObsidianHandlers(context)
+  });
+}
+async function runRemarkObsidian(markdown, context) {
+  const processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context);
+  const tree = processor.parse(markdown);
+  const file = { data: {} };
+  await processor.run(tree, file);
+  return file;
+}
+function extractPlainText(markdown) {
+  return markdown.replace(/```[\s\S]*?```/g, "").replace(/%%[\s\S]*?%%/g, "").replace(/\^\[[^\]]+]/g, "").replace(/(?:^|\s)\^[A-Za-z0-9-]+/g, " ").replace(/`([^`]+)`/g, "$1").replace(/!\[[^\]]*]\([^)]+\)/g, "").replace(/\[([^\]]+)]\([^)]+\)/g, "$1").replace(/[#>*_\-~`]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function hasCodeFence(markdown) {
+  return /(^|\n)(```|~~~)/.test(markdown);
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+export {
+  asFilePath,
+  asFullSlug,
+  asSimpleSlug,
+  asRelativeURL,
+  normalizePath,
+  slugifySegment,
+  normalizeSlug,
+  slugifyFilePath,
+  hasNumericPrefixInPath,
+  numericPrefixSortKey,
+  simplifySlug,
+  slugToHref,
+  hrefToSlug,
+  pathToRoot,
+  resolveRelative,
+  resolveWikiLink,
+  joinSegments,
+  getMenuLabel,
+  getPageProperties,
+  formatPropertyLabel,
+  formatPropertyValue,
+  tagToHref,
+  renderMarkdown,
+  renderMarkdownHtml,
+  analyzeMarkdown,
+  getTitle,
+  getDescription
+};
+//# sourceMappingURL=chunk-L565TMI5.js.map