@riebeckite/plugin-excalibrain 0.0.1

package/dist/index.js

@@ -0,0 +1,785 @@
+// index.ts
+import {
+  createClientEntry,
+  createStyleAsset,
+  definePlugin,
+  isPublished
+} from "@riebeckite/core";
+
+// src/ontology.ts
+var DEFAULT_ONTOLOGY = {
+  parents: ["parent", "parents", "up", "u", "north", "origin", "inception"],
+  children: [
+    "children",
+    "child",
+    "down",
+    "d",
+    "south",
+    "leads to",
+    "contributes to"
+  ],
+  leftFriends: [
+    "friends",
+    "friend",
+    "similar",
+    "supports",
+    "alternatives",
+    "advantages"
+  ],
+  rightFriends: ["opposes", "disadvantages", "missing", "cons"],
+  previous: ["previous", "prev", "west", "w", "before"],
+  next: ["next", "n", "east", "e", "after"],
+  hidden: ["hidden"]
+};
+var FIELD_ROLE_ORDER = [
+  "parents",
+  "children",
+  "leftFriends",
+  "rightFriends",
+  "previous",
+  "next",
+  "hidden"
+];
+var FIELD_TO_NODE_ROLE = {
+  parents: "parent",
+  children: "child",
+  leftFriends: "leftFriend",
+  rightFriends: "rightFriend",
+  previous: "previous",
+  next: "next"
+};
+function normalizeFieldName(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function resolveOntology(overrides = {}) {
+  const merged = {
+    ...DEFAULT_ONTOLOGY,
+    ...overrides
+  };
+  const fieldRole = /* @__PURE__ */ new Map();
+  for (const role of FIELD_ROLE_ORDER) {
+    for (const field of merged[role] ?? []) {
+      const normalized = normalizeFieldName(field);
+      if (normalized && !fieldRole.has(normalized)) {
+        fieldRole.set(normalized, role);
+      }
+    }
+  }
+  return { fieldRole };
+}
+function fieldRoleOf(field, ontology) {
+  return ontology.fieldRole.get(normalizeFieldName(field)) ?? null;
+}
+function collectDefinedRelations(input) {
+  const relations = [];
+  const inlineFields = extractInlineFields(input.markdown);
+  for (const role of FIELD_ROLE_ORDER) {
+    if (role === "hidden") continue;
+    const nodeRole = FIELD_TO_NODE_ROLE[role];
+    for (const [field, value] of Object.entries(input.frontmatter)) {
+      if (fieldRoleOf(field, input.ontology) !== role) continue;
+      for (const target of extractTargets(value)) {
+        relations.push({ role: nodeRole, target });
+      }
+    }
+    for (const [field, value] of inlineFields) {
+      if (fieldRoleOf(field, input.ontology) !== role) continue;
+      for (const target of extractTargets(value)) {
+        relations.push({ role: nodeRole, target });
+      }
+    }
+  }
+  return relations;
+}
+function isNoteHidden(input) {
+  for (const field of Object.keys(input.frontmatter)) {
+    if (fieldRoleOf(field, input.ontology) === "hidden") return true;
+  }
+  for (const [field] of extractInlineFields(input.markdown)) {
+    if (fieldRoleOf(field, input.ontology) === "hidden") return true;
+  }
+  return false;
+}
+var WIKILINK_PATTERN = /\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+function extractWikilinkTargets(value) {
+  WIKILINK_PATTERN.lastIndex = 0;
+  const targets = [];
+  for (let match = WIKILINK_PATTERN.exec(value); match !== null; match = WIKILINK_PATTERN.exec(value)) {
+    const target = match[1]?.trim();
+    if (target) targets.push(target);
+  }
+  return targets;
+}
+function extractTargets(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => extractTargets(item));
+  }
+  if (typeof value !== "string") return [];
+  const links = extractWikilinkTargets(value);
+  if (links.length > 0) return links;
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  if (/^(true|false|null|~|\d+(?:\.\d+)?)$/i.test(trimmed)) return [];
+  return [trimmed];
+}
+var INLINE_BRACKET_FIELD = /\[([A-Za-z][A-Za-z0-9 _-]*)::\s*([^\]]+)\]/g;
+var INLINE_LINE_FIELD = /^[ \t>*+-]*([A-Za-z][A-Za-z0-9 _-]*)::[ \t]*(.+)$/gm;
+var FENCED_CODE = /```[\s\S]*?```|~~~[\s\S]*?~~~/g;
+function extractInlineFields(markdown) {
+  const body = stripFrontmatter(markdown).replace(FENCED_CODE, "");
+  const fields = [];
+  for (let match = INLINE_BRACKET_FIELD.exec(body); match !== null; match = INLINE_BRACKET_FIELD.exec(body)) {
+    fields.push([match[1] ?? "", (match[2] ?? "").trim()]);
+  }
+  for (let match = INLINE_LINE_FIELD.exec(body); match !== null; match = INLINE_LINE_FIELD.exec(body)) {
+    fields.push([match[1] ?? "", (match[2] ?? "").trim()]);
+  }
+  return fields;
+}
+function stripFrontmatter(markdown) {
+  if (!markdown.startsWith("---")) return markdown;
+  const end = markdown.indexOf("\n---", 3);
+  if (end === -1) return markdown;
+  const closing = markdown.indexOf("\n", end + 1);
+  return closing === -1 ? "" : markdown.slice(closing + 1);
+}
+
+// src/options.ts
+function resolveExcaliBrainOptions(options = {}) {
+  return {
+    render: options.render ?? "build",
+    auto: options.auto ?? true,
+    heading: options.heading ?? true,
+    headingText: options.headingText ?? "ExcaliBrain",
+    className: options.className ?? "rb-excalibrain",
+    maxPerRegion: options.maxPerRegion ?? 8,
+    infer: options.infer ?? true,
+    siblings: options.siblings ?? true,
+    ontology: resolveOntology(options.ontology),
+    showHidden: options.showHidden ?? false,
+    width: options.width ?? 720,
+    height: options.height ?? 480,
+    language: options.language ?? "excalibrain"
+  };
+}
+function validateExcaliBrainOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  if (options.render !== void 0 && !isRenderMode(options.render)) {
+    issues.push({
+      path: "render",
+      message: 'Expected "build", "client", or "both".'
+    });
+  }
+  for (const key of ["auto", "heading", "infer", "siblings", "showHidden"]) {
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+      issues.push({ path: key, message: "Expected a boolean." });
+    }
+  }
+  for (const key of ["headingText", "className", "language"]) {
+    if (options[key] !== void 0 && (typeof options[key] !== "string" || options[key].trim() === "")) {
+      issues.push({ path: key, message: "Expected a non-empty string." });
+    }
+  }
+  if (options.maxPerRegion !== void 0 && (!Number.isInteger(options.maxPerRegion) || options.maxPerRegion < 0)) {
+    issues.push({
+      path: "maxPerRegion",
+      message: "Expected a non-negative integer."
+    });
+  }
+  for (const key of ["width", "height"]) {
+    if (options[key] !== void 0 && (!Number.isFinite(options[key]) || options[key] <= 0)) {
+      issues.push({ path: key, message: "Expected a positive number." });
+    }
+  }
+  if (options.ontology !== void 0 && !isOntology(options.ontology)) {
+    issues.push({
+      path: "ontology",
+      message: "Expected an object of field-name arrays."
+    });
+  }
+  return issues;
+}
+function isRenderMode(value) {
+  return value === "build" || value === "client" || value === "both";
+}
+function isOntology(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every(
+    (fields) => fields === void 0 || Array.isArray(fields) && fields.every((field) => typeof field === "string")
+  );
+}
+
+// src/graph.ts
+function buildExcaliBrainGraph(input) {
+  const options = resolveExcaliBrainOptions(input.options);
+  const { slug, manifest } = input;
+  const centerEntry = manifest.bySlug.get(slug) ?? null;
+  const center = {
+    id: slug,
+    slug,
+    title: resolveTitle(centerEntry, input.frontmatter, slug),
+    permalink: centerEntry?.permalink ?? null,
+    virtual: false,
+    role: "center",
+    relationType: "defined"
+  };
+  if (!options.showHidden && isNoteHidden({
+    frontmatter: input.frontmatter,
+    markdown: input.markdown,
+    ontology: options.ontology
+  })) {
+    return { center, nodes: [], links: [] };
+  }
+  const relations = /* @__PURE__ */ new Map();
+  const add = (target, role, relationType) => {
+    if (role === "center") return;
+    const node = resolveNode(target, slug, manifest);
+    if (!node) return;
+    const existing = relations.get(node.id);
+    if (existing) {
+      if (existing.relationType === "inferred" && relationType === "defined") {
+        existing.role = role;
+        existing.relationType = "defined";
+        existing.node.role = role;
+        existing.node.relationType = "defined";
+      }
+      return;
+    }
+    node.role = role;
+    node.relationType = relationType;
+    relations.set(node.id, { node, role, relationType });
+  };
+  for (const relation of collectDefinedRelations({
+    frontmatter: input.frontmatter,
+    markdown: input.markdown,
+    ontology: options.ontology
+  })) {
+    add(relation.target, relation.role, "defined");
+  }
+  const outgoing = noteLinkSlugs(
+    manifest.outgoingLinks.get(slug) ?? [],
+    slug
+  );
+  const incoming = unique(
+    (manifest.incomingLinks.get(slug) ?? []).filter(
+      (candidate) => candidate !== slug
+    )
+  );
+  const outgoingSet = new Set(outgoing);
+  const mutual = incoming.filter((candidate) => outgoingSet.has(candidate));
+  const mutualSet = new Set(mutual);
+  if (options.infer) {
+    for (const target of outgoing) {
+      if (!mutualSet.has(target)) add(target, "child", "inferred");
+    }
+    for (const target of incoming) {
+      if (!mutualSet.has(target)) add(target, "parent", "inferred");
+    }
+    for (const target of mutual) add(target, "leftFriend", "inferred");
+  }
+  if (options.siblings) {
+    const parents = [...relations.values()].filter(
+      (relation) => relation.role === "parent"
+    );
+    for (const parent of parents) {
+      const parentSlug = parent.node.slug;
+      if (!parentSlug) continue;
+      const siblings = noteLinkSlugs(
+        manifest.outgoingLinks.get(parentSlug) ?? [],
+        slug
+      );
+      for (const siblingSlug of siblings) {
+        add(siblingSlug, "sibling", "inferred");
+      }
+    }
+  }
+  const nodes = [...relations.values()].map((relation) => relation.node);
+  const links = [...relations.values()].map(
+    (relation) => ({
+      from: slug,
+      to: relation.node.id,
+      role: relation.role,
+      relationType: relation.relationType
+    })
+  );
+  return { center, nodes, links };
+}
+function resolveNode(target, selfSlug, manifest) {
+  const raw = target.trim();
+  if (!raw) return null;
+  const targetSlug = resolveSlug(raw, manifest);
+  if (targetSlug && targetSlug !== selfSlug) {
+    const entry = manifest.bySlug.get(targetSlug);
+    if (entry) {
+      return {
+        id: targetSlug,
+        slug: targetSlug,
+        title: entry.title,
+        permalink: entry.permalink,
+        virtual: false,
+        role: "parent",
+        relationType: "defined"
+      };
+    }
+  }
+  return {
+    id: `virtual:${raw.toLowerCase()}`,
+    slug: null,
+    title: raw,
+    permalink: null,
+    virtual: true,
+    role: "parent",
+    relationType: "defined"
+  };
+}
+function resolveSlug(target, manifest) {
+  const direct = manifest.bySlug.get(target);
+  if (direct) return direct.slug;
+  const indexed = manifest.contentIndex.get(target.toLowerCase());
+  if (indexed) return indexed;
+  const permalink = manifest.byPermalink.get(target);
+  if (permalink) return permalink.slug;
+  return null;
+}
+function noteLinkSlugs(links, selfSlug) {
+  return unique(
+    links.filter(
+      (link) => link.kind === "note" && link.slug !== null && link.slug !== selfSlug
+    ).map((link) => link.slug)
+  );
+}
+function resolveTitle(entry, frontmatter, slug) {
+  if (entry?.title) return entry.title;
+  const title = frontmatter.title;
+  return typeof title === "string" && title.trim() ? title : slug;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/layout.ts
+var EXCALIBRAIN_REGION_ORDER = [
+  "parents",
+  "children",
+  "left-friends",
+  "right-friends",
+  "previous",
+  "next",
+  "siblings"
+];
+var ROLE_ORDER = [
+  "parent",
+  "child",
+  "leftFriend",
+  "rightFriend",
+  "previous",
+  "next",
+  "sibling"
+];
+var ROLE_REGION = {
+  parent: "parents",
+  child: "children",
+  leftFriend: "left-friends",
+  rightFriend: "right-friends",
+  previous: "previous",
+  next: "next",
+  sibling: "siblings",
+  center: "center"
+};
+var ROLE_ANCHOR = {
+  parent: { angle: -90, radius: "near" },
+  child: { angle: 90, radius: "near" },
+  leftFriend: { angle: 180, radius: "near" },
+  rightFriend: { angle: 0, radius: "near" },
+  previous: { angle: 180, radius: "far" },
+  next: { angle: 0, radius: "far" },
+  sibling: { angle: 0, radius: "far" }
+};
+var SIBLING_ANGLES = [-135, -45, 135, 45];
+var NODE_HEIGHT = 36;
+var CENTER_HEIGHT = 40;
+var MAX_NODE_WIDTH = 150;
+var MAX_CENTER_WIDTH = 180;
+function layoutExcaliBrain(graph, options = {}) {
+  const resolved = resolveExcaliBrainOptions(options);
+  const width = resolved.width;
+  const height = resolved.height;
+  const cx = width / 2;
+  const cy = height / 2;
+  const minDimension = Math.min(width, height);
+  const nearRadius = minDimension * 0.3;
+  const farRadius = Math.max(
+    nearRadius,
+    Math.min(nearRadius * 1.5, minDimension / 2 - 28)
+  );
+  const positioned = [
+    positionCenter(graph.center, cx, cy, width, height)
+  ];
+  const groups = /* @__PURE__ */ new Map();
+  for (const role of ROLE_ORDER) groups.set(role, []);
+  for (const node of graph.nodes) {
+    if (node.role === "center") continue;
+    groups.get(node.role)?.push(node);
+  }
+  const maxPerRegion = Math.max(0, Math.trunc(resolved.maxPerRegion));
+  for (const role of ROLE_ORDER) {
+    const group = [...groups.get(role) ?? []].sort(compareNodes).slice(0, maxPerRegion);
+    if (group.length === 0) continue;
+    if (role === "sibling") {
+      const buckets = [[], [], [], []];
+      group.forEach((node, index) => {
+        buckets[index % SIBLING_ANGLES.length]?.push(node);
+      });
+      buckets.forEach((bucket, anchorIndex) => {
+        bucket.forEach((node, index) => {
+          const angle = spreadAngle(
+            SIBLING_ANGLES[anchorIndex] ?? -135,
+            index,
+            bucket.length
+          );
+          positioned.push(
+            positionNode(node, angle, farRadius * 0.92, cx, cy, width, height)
+          );
+        });
+      });
+      continue;
+    }
+    const anchor = ROLE_ANCHOR[role];
+    const radius = anchor.radius === "far" ? farRadius : nearRadius;
+    group.forEach((node, index) => {
+      const angle = spreadAngle(anchor.angle, index, group.length);
+      positioned.push(
+        positionNode(node, angle, radius, cx, cy, width, height)
+      );
+    });
+  }
+  const ids = new Set(positioned.map((node) => node.id));
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const link of graph.links) {
+    if (!ids.has(link.from) || !ids.has(link.to)) continue;
+    const key = `${link.from}\0${link.to}\0${link.role}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    links.push({
+      from: link.from,
+      to: link.to,
+      role: link.role,
+      relationType: link.relationType
+    });
+  }
+  return { width, height, nodes: positioned, links };
+}
+function positionCenter(center, cx, cy, width, height) {
+  const boxWidth = Math.min(
+    MAX_CENTER_WIDTH,
+    Math.max(72, Math.round(center.title.length * 7 + 24))
+  );
+  return {
+    id: center.id,
+    role: "center",
+    region: "center",
+    relationType: center.relationType,
+    title: center.title,
+    slug: center.slug,
+    permalink: center.permalink,
+    virtual: center.virtual,
+    x: clamp(Math.round(cx - boxWidth / 2), 4, width - boxWidth - 4),
+    y: clamp(Math.round(cy - CENTER_HEIGHT / 2), 4, height - CENTER_HEIGHT - 4),
+    width: boxWidth,
+    height: CENTER_HEIGHT
+  };
+}
+function positionNode(node, angle, radius, cx, cy, width, height) {
+  const point = polar(cx, cy, angle, radius);
+  const boxWidth = Math.min(
+    MAX_NODE_WIDTH,
+    Math.max(56, Math.round(node.title.length * 6.6 + 20))
+  );
+  return {
+    id: node.id,
+    role: node.role,
+    region: ROLE_REGION[node.role],
+    relationType: node.relationType,
+    title: node.title,
+    slug: node.slug,
+    permalink: node.permalink,
+    virtual: node.virtual,
+    x: clamp(Math.round(point.x - boxWidth / 2), 4, width - boxWidth - 4),
+    y: clamp(
+      Math.round(point.y - NODE_HEIGHT / 2),
+      4,
+      height - NODE_HEIGHT - 4
+    ),
+    width: boxWidth,
+    height: NODE_HEIGHT
+  };
+}
+function polar(cx, cy, angleDegrees, radius) {
+  const radians = angleDegrees * Math.PI / 180;
+  return {
+    x: cx + radius * Math.cos(radians),
+    y: cy + radius * Math.sin(radians)
+  };
+}
+function spreadAngle(anchor, index, count) {
+  if (count <= 1) return anchor;
+  const step = Math.min(16, 64 / count);
+  return anchor + (index - (count - 1) / 2) * step;
+}
+function compareNodes(a, b) {
+  const left = a.title.toLowerCase();
+  const right = b.title.toLowerCase();
+  if (left < right) return -1;
+  if (left > right) return 1;
+  if (a.id < b.id) return -1;
+  if (a.id > b.id) return 1;
+  return 0;
+}
+function clamp(value, min, max) {
+  const upper = Math.max(min, max);
+  return Math.min(Math.max(value, min), upper);
+}
+
+// src/placeholder.ts
+var EXCALIBRAIN_PLACEHOLDER_ATTRIBUTE = "data-rb-excalibrain";
+function createExcaliBrainPlaceholder() {
+  return `<div ${EXCALIBRAIN_PLACEHOLDER_ATTRIBUTE}=""></div>`;
+}
+function createExcaliBrainPlaceholderPattern() {
+  return new RegExp(
+    `<div\\b[^>]*\\b${EXCALIBRAIN_PLACEHOLDER_ATTRIBUTE}(?:="[^"]*")?[^>]*>\\s*</div>`,
+    "g"
+  );
+}
+function hasExcaliBrainPlaceholder(html) {
+  return html.includes(EXCALIBRAIN_PLACEHOLDER_ATTRIBUTE);
+}
+function replaceExcaliBrainPlaceholders(html, replacement) {
+  return html.replace(createExcaliBrainPlaceholderPattern(), replacement);
+}
+
+// src/render.ts
+var ROLE_ATTRIBUTE = {
+  parent: "parent",
+  child: "child",
+  leftFriend: "left-friend",
+  rightFriend: "right-friend",
+  previous: "previous",
+  next: "next",
+  sibling: "sibling",
+  center: "center"
+};
+function renderExcaliBrainSvg(graph, layout, options = {}) {
+  const className = options.className ?? "rb-excalibrain";
+  const byId = new Map(layout.nodes.map((node) => [node.id, node]));
+  const parts = [];
+  parts.push(
+    `<svg class="${className}__svg" viewBox="0 0 ${layout.width} ${layout.height}" role="img" aria-label="${escapeAttribute(`${graph.center.title} ExcaliBrain`)}" xmlns="http://www.w3.org/2000/svg" width="${layout.width}" height="${layout.height}">`
+  );
+  const links = layout.links.map((link) => renderLink(link, byId, className)).join("");
+  parts.push(`<g class="${className}__links">${links}</g>`);
+  for (const region of EXCALIBRAIN_REGION_ORDER) {
+    const regionNodes = layout.nodes.filter((node) => node.region === region);
+    if (regionNodes.length === 0) continue;
+    const nodes = regionNodes.map((node) => renderNode(node, className)).join("");
+    parts.push(
+      `<g class="${className}__region" data-region="${region}">${nodes}</g>`
+    );
+  }
+  const center = layout.nodes.find((node) => node.role === "center");
+  if (center) parts.push(renderNode(center, className));
+  parts.push("</svg>");
+  return parts.join("");
+}
+function renderExcaliBrainSection(input) {
+  const options = input.options ?? {};
+  const renderMode = input.render ?? "build";
+  const className = options.className ?? "rb-excalibrain";
+  const heading = options.heading !== false;
+  const headingText = options.headingText ?? "ExcaliBrain";
+  const centerSlug = input.graph.center.slug ?? input.graph.center.id;
+  const renderAtBuild = renderMode === "build" || renderMode === "both";
+  const renderAtClient = renderMode === "client" || renderMode === "both";
+  const svg = renderAtBuild ? renderExcaliBrainSvg(input.graph, input.layout, options) : "";
+  const payload = renderAtClient ? ` data-excalibrain-payload="${escapeAttribute(
+    JSON.stringify({
+      graph: input.graph,
+      layout: input.layout,
+      className
+    })
+  )}"` : "";
+  return [
+    `<section class="${className}" data-excalibrain data-excalibrain-render="${renderMode}" data-excalibrain-center="${escapeAttribute(centerSlug)}">`,
+    heading ? `<h2 class="${className}__heading">${escapeHtml(headingText)}</h2>` : "",
+    `<div class="${className}__canvas"${payload}>${svg}</div>`,
+    "</section>"
+  ].join("");
+}
+function renderNode(node, className) {
+  const box = `<rect class="${className}__node-box" x="${node.x}" y="${node.y}" width="${node.width}" height="${node.height}" rx="4" />`;
+  const label = `<text class="${className}__node-label" x="${round(
+    node.x + node.width / 2
+  )}" y="${round(node.y + node.height / 2)}" text-anchor="middle" dominant-baseline="middle">${escapeHtml(node.title)}</text>`;
+  const inner = `${box}${label}`;
+  const content = node.permalink ? `<a class="${className}__node-link" href="${escapeAttribute(node.permalink)}">${inner}</a>` : inner;
+  const attributes = [
+    `class="${className}__node"`,
+    `data-node-role="${ROLE_ATTRIBUTE[node.role]}"`,
+    `data-node-slug="${escapeAttribute(node.slug ?? node.title)}"`,
+    node.virtual ? 'data-node-virtual="true"' : "",
+    `data-relation-type="${node.relationType}"`
+  ].filter(Boolean);
+  return `<g ${attributes.join(" ")}>${content}</g>`;
+}
+function renderLink(link, byId, className) {
+  const from = byId.get(link.from);
+  const to = byId.get(link.to);
+  if (!from || !to) return "";
+  const d = `M ${round(from.x + from.width / 2)} ${round(from.y + from.height / 2)} L ${round(to.x + to.width / 2)} ${round(to.y + to.height / 2)}`;
+  return `<path class="${className}__link" data-link-role="${ROLE_ATTRIBUTE[link.role]}" data-relation-type="${link.relationType}" d="${d}" />`;
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeHtml(value).replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/rehype.ts
+function rehypeExcaliBrain(options = {}) {
+  const language = options.language ?? "excalibrain";
+  return (tree) => {
+    replaceBlocks(tree, language);
+  };
+}
+function replaceBlocks(node, language) {
+  const children = getChildren(node);
+  if (!children) return;
+  for (let index = 0; index < children.length; index += 1) {
+    const child = children[index];
+    if (child === void 0) continue;
+    if (isExcaliBrainBlock(child, language)) {
+      children[index] = {
+        type: "raw",
+        value: createExcaliBrainPlaceholder()
+      };
+      continue;
+    }
+    replaceBlocks(child, language);
+  }
+}
+function isExcaliBrainBlock(node, language) {
+  const element = asElement(node);
+  if (element?.tagName !== "pre") return false;
+  const code = getChildren(element)?.find(
+    (child) => asElement(child)?.tagName === "code"
+  );
+  if (!code) return false;
+  return classList(code).includes(`language-${language}`);
+}
+function asElement(node) {
+  return node.type === "element" ? node : null;
+}
+function getChildren(node) {
+  const children = node.children;
+  return Array.isArray(children) ? children : null;
+}
+function classList(node) {
+  const value = node.properties?.className;
+  if (Array.isArray(value)) return value.map(String);
+  if (typeof value === "string") return value.split(/\s+/);
+  return [];
+}
+
+// index.ts
+var SECTION_ATTRIBUTE = "data-excalibrain";
+function createExcaliBrainRuntime(options) {
+  const notes = /* @__PURE__ */ new Map();
+  const resolved = resolveExcaliBrainOptions(options);
+  return {
+    track(slug, markdown, content) {
+      notes.set(slug, { markdown, content });
+    },
+    resolve(manifest, config) {
+      for (const entry of manifest.entries) {
+        if (config && !isPublished(config, entry.frontmatter)) continue;
+        const note = notes.get(entry.slug);
+        const markdown = note?.markdown ?? "";
+        const graph = buildExcaliBrainGraph({
+          slug: entry.slug,
+          frontmatter: entry.frontmatter,
+          markdown,
+          manifest,
+          options
+        });
+        const layout = layoutExcaliBrain(graph, options);
+        const hasNeighbour = graph.nodes.length > 0;
+        const hasFence = hasExcaliBrainPlaceholder(entry.html);
+        if (!hasFence && !(resolved.auto && hasNeighbour)) continue;
+        if (!hasFence && entry.html.includes(SECTION_ATTRIBUTE)) continue;
+        const section = renderExcaliBrainSection({
+          graph,
+          layout,
+          options,
+          render: resolved.render
+        });
+        if (hasFence) {
+          entry.html = replaceExcaliBrainPlaceholders(entry.html, section);
+          if (note) {
+            note.content.html = replaceExcaliBrainPlaceholders(
+              note.content.html,
+              section
+            );
+          }
+        } else {
+          entry.html = `${entry.html}${section}`;
+          if (note) note.content.html = `${note.content.html}${section}`;
+        }
+      }
+    }
+  };
+}
+function excaliBrain(options = {}) {
+  const runtime = createExcaliBrainRuntime(options);
+  const language = options.language ?? "excalibrain";
+  return definePlugin({
+    name: "excalibrain",
+    order: -10,
+    options,
+    validateOptions: validateExcaliBrainOptions,
+    extendHtmlPipeline: (pipeline) => {
+      pipeline.use(rehypeExcaliBrain, { language });
+    },
+    onPostParsed: (context) => {
+      runtime.track(context.slug, context.markdown, context.content);
+    },
+    onManifestCreated: (context) => {
+      runtime.resolve(context.manifest, context.config);
+    },
+    assets: [createStyleAsset("excalibrain")],
+    clientEntries: [createClientEntry("excalibrain", "initExcaliBrain")]
+  });
+}
+var excaliBrainPlugin = excaliBrain;
+export {
+  DEFAULT_ONTOLOGY,
+  buildExcaliBrainGraph,
+  collectDefinedRelations,
+  excaliBrain,
+  excaliBrainPlugin,
+  isNoteHidden,
+  layoutExcaliBrain,
+  normalizeFieldName,
+  renderExcaliBrainSection,
+  renderExcaliBrainSvg,
+  resolveExcaliBrainOptions,
+  resolveOntology,
+  validateExcaliBrainOptions
+};