@bendyline/squisq 1.4.1 → 1.5.1

package/dist/{chunk-3K5OG6KI.js → chunk-TEEEILMP.js}

@@ -1,134 +1,284 @@
+import {
+  parseFrontmatter,
+  parseHtmlToNodes
+} from "./chunk-HWVFJAAH.js";
 import {
   resolveIcon
 } from "./chunk-DBS6RIFL.js";
 import {
-  parseFrontmatter
-} from "./chunk-H3AXU4MJ.js";
+  TRANSITION_DIRECTIONS,
+  TRANSITION_TYPES,
+  normalizeTransitionDirection,
+  normalizeTransitionType
+} from "./chunk-QE7TWGVT.js";
 
-// src/markdown/parse.ts
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm from "remark-gfm";
-import remarkMath from "remark-math";
-import remarkDirective from "remark-directive";
-import remarkFrontmatter from "remark-frontmatter";
-
-// src/markdown/htmlParse.ts
-import { fromHtml } from "hast-util-from-html";
-var HAST_PROP_TO_ATTR = {
-  className: "class",
-  htmlFor: "for",
-  httpEquiv: "http-equiv",
-  acceptCharset: "accept-charset"
+// src/markdown/annotationCoercion.ts
+var KNOWN_BLOCK_META_KEYS = {
+  x: "number",
+  y: "number",
+  startTime: "time",
+  duration: "time",
+  connectsTo: "connectionList",
+  transition: "transition",
+  transitionDuration: "time",
+  transitionDirection: "transitionDirection"
 };
-var VOID_ELEMENTS = /* @__PURE__ */ new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function propertyToAttribute(prop) {
-  if (HAST_PROP_TO_ATTR[prop]) return HAST_PROP_TO_ATTR[prop];
-  if (prop.length > 4 && prop.startsWith("data") && prop[4] >= "A" && prop[4] <= "Z") {
-    return "data-" + prop.slice(4).replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^-/, "");
+var BLOCK_META_KEY_DESCRIPTORS = [
+  {
+    key: "transition",
+    description: "Block-to-block transition effect",
+    values: TRANSITION_TYPES
+  },
+  {
+    key: "transitionDuration",
+    description: "How long the transition lasts",
+    valueHint: "seconds \u2014 e.g. 0.7, 700ms"
+  },
+  {
+    key: "transitionDirection",
+    description: "Directional variant for the transition",
+    values: TRANSITION_DIRECTIONS
+  },
+  {
+    key: "startTime",
+    description: "Timeline start time of this block",
+    valueHint: "mm:ss or seconds \u2014 e.g. 01:30, 5, 1500ms"
+  },
+  {
+    key: "duration",
+    description: "How long this block lasts",
+    valueHint: "mm:ss or seconds \u2014 e.g. 45, 1500ms"
+  },
+  {
+    key: "x",
+    description: "Horizontal position on the diagram canvas",
+    valueHint: "number \u2014 e.g. 600"
+  },
+  {
+    key: "y",
+    description: "Vertical position on the diagram canvas",
+    valueHint: "number \u2014 e.g. 300"
+  },
+  {
+    key: "connectsTo",
+    description: "Diagram connections to other blocks",
+    valueHint: "comma-separated target or target:type \u2014 e.g. foo,bar:flow"
+  }
+];
+function coerceAnnotationValues(params) {
+  const blockMeta = {};
+  const metadata = {};
+  const warnings = [];
+  let transitionType = null;
+  let transitionDuration;
+  let transitionDirection;
+  for (const [key, raw] of Object.entries(params)) {
+    const kind = KNOWN_BLOCK_META_KEYS[key];
+    if (!kind) {
+      metadata[key] = raw;
+      continue;
+    }
+    if (kind === "number") {
+      const n = parseNumber(raw);
+      if (n == null) {
+        warnings.push(`Invalid number for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        blockMeta[key] = n;
+      }
+    } else if (kind === "time") {
+      const s = parseTimeSeconds(raw);
+      if (s == null) {
+        warnings.push(`Invalid time for "${key}": ${JSON.stringify(raw)}`);
+      } else if (key === "transitionDuration") {
+        transitionDuration = s;
+      } else {
+        blockMeta[key] = s;
+      }
+    } else if (kind === "connectionList") {
+      const { list, warning } = parseConnectionList(raw);
+      if (warning) warnings.push(`"${key}": ${warning}`);
+      blockMeta.connectsTo = list;
+    } else if (kind === "transition") {
+      const transition = normalizeTransitionType(raw);
+      if (transition == null) {
+        warnings.push(`Invalid transition for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        transitionType = transition;
+      }
+    } else if (kind === "transitionDirection") {
+      const direction = normalizeTransitionDirection(raw);
+      if (direction == null) {
+        warnings.push(`Invalid transition direction for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        transitionDirection = direction;
+      }
+    }
   }
-  if (prop.length > 4 && prop.startsWith("aria") && prop[4] >= "A" && prop[4] <= "Z") {
-    return "aria-" + prop.slice(4).replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^-/, "");
+  if (transitionType) {
+    blockMeta.transition = {
+      type: transitionType,
+      ...transitionDuration !== void 0 ? { duration: transitionDuration } : {},
+      ...transitionDirection !== void 0 ? { direction: transitionDirection } : {}
+    };
   }
-  return prop.toLowerCase();
+  return { blockMeta, metadata, warnings };
 }
-function convertHastProperties(properties) {
-  const attrs = {};
-  for (const [key, value] of Object.entries(properties)) {
-    if (value === false || value === void 0 || value === null) continue;
-    const attrName = propertyToAttribute(key);
-    if (value === true) {
-      attrs[attrName] = "";
-    } else if (Array.isArray(value)) {
-      attrs[attrName] = value.join(" ");
-    } else {
-      attrs[attrName] = String(value);
+function parseNumber(raw) {
+  if (raw.trim() === "") return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+var TIME_BARE_RE = /^\d+(?:\.\d+)?$/;
+var TIME_MS_RE = /^(\d+(?:\.\d+)?)ms$/;
+var TIME_MMSS_RE = /^(\d+):(\d{1,2})(?:\.(\d+))?$/;
+function parseTimeSeconds(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (TIME_BARE_RE.test(trimmed)) {
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : null;
+  }
+  const msMatch = trimmed.match(TIME_MS_RE);
+  if (msMatch) {
+    const n = Number(msMatch[1]);
+    return Number.isFinite(n) ? n / 1e3 : null;
+  }
+  const mmssMatch = trimmed.match(TIME_MMSS_RE);
+  if (mmssMatch) {
+    const mins = Number(mmssMatch[1]);
+    const secs = Number(mmssMatch[2]);
+    const frac = mmssMatch[3] ? Number(`0.${mmssMatch[3]}`) : 0;
+    if (!Number.isFinite(mins) || !Number.isFinite(secs) || !Number.isFinite(frac)) {
+      return null;
     }
+    if (secs >= 60) return null;
+    return mins * 60 + secs + frac;
   }
-  return attrs;
+  return null;
 }
-function hastChildrenToNodes(children) {
-  const result = [];
-  for (const child of children) {
-    const node = hastNodeToHtmlNode(child);
-    if (node) result.push(node);
+function parseConnectionList(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return { list: [], warning: null };
+  const list = [];
+  let droppedEmpty = false;
+  for (const part of trimmed.split(",")) {
+    const entry = part.trim();
+    if (!entry) {
+      droppedEmpty = true;
+      continue;
+    }
+    const colonIdx = entry.indexOf(":");
+    if (colonIdx < 0) {
+      list.push({ target: entry });
+    } else {
+      const target = entry.slice(0, colonIdx).trim();
+      const type = entry.slice(colonIdx + 1).trim();
+      if (!target) {
+        droppedEmpty = true;
+        continue;
+      }
+      list.push(type ? { target, type } : { target });
+    }
   }
-  return result;
+  return {
+    list,
+    warning: droppedEmpty ? "dropped empty connection entries" : null
+  };
 }
-function hastNodeToHtmlNode(node) {
-  switch (node.type) {
-    case "element": {
-      const tagName = node.tagName;
-      const properties = node.properties ?? {};
-      const children = node.children ?? [];
-      return {
-        type: "htmlElement",
-        tagName,
-        attributes: convertHastProperties(properties),
-        children: hastChildrenToNodes(children),
-        selfClosing: VOID_ELEMENTS.has(tagName) && children.length === 0
-      };
+
+// src/markdown/attrTokens.ts
+var DQ_RUN = `"(?:[^"\\\\]|\\\\.)*"`;
+var SQ_RUN = `'(?:[^'\\\\]|\\\\.)*'`;
+var TEMPLATE_STRICT_RE = new RegExp(
+  `\\s*\\{\\[((?:[^\\]"']|${DQ_RUN}|${SQ_RUN})+)\\]\\}[\\s\\]}]*$`
+);
+var TEMPLATE_LEGACY_RE = /\s*\{\[([^\]]+)\]\}[\s\]}]*$/;
+var PANDOC_STRICT_RE = new RegExp(`\\s*\\{(?!\\[)((?:[^}"']|${DQ_RUN}|${SQ_RUN})*)\\}\\s*$`);
+var PANDOC_LEGACY_RE = /\s*\{(?!\[)([^}]*)\}\s*$/;
+function matchTrailing(text, strict, legacy) {
+  const m = strict.exec(text) ?? legacy.exec(text);
+  return m ? { inner: m[1], index: m.index } : null;
+}
+function matchTrailingTemplateAnnotation(text) {
+  return matchTrailing(text, TEMPLATE_STRICT_RE, TEMPLATE_LEGACY_RE);
+}
+function matchTrailingPandocAttr(text) {
+  return matchTrailing(text, PANDOC_STRICT_RE, PANDOC_LEGACY_RE);
+}
+var WHITESPACE_RE = /\s/;
+function tokenizeAttrTokens(input) {
+  const tokens = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    while (i < n && WHITESPACE_RE.test(input[i])) i++;
+    if (i >= n) break;
+    let token = "";
+    while (i < n && !WHITESPACE_RE.test(input[i])) {
+      const ch = input[i];
+      const atValueStart = token === "" || token.endsWith("=");
+      if ((ch === '"' || ch === "'") && atValueStart) {
+        token += ch;
+        i++;
+        while (i < n && input[i] !== ch) {
+          if (input[i] === "\\" && i + 1 < n && (input[i + 1] === ch || input[i + 1] === "\\")) {
+            token += input[i] + input[i + 1];
+            i += 2;
+          } else {
+            token += input[i];
+            i++;
+          }
+        }
+        if (i < n && input[i] === ch) {
+          token += ch;
+          i++;
+        }
+      } else {
+        token += ch;
+        i++;
+      }
     }
-    case "text":
-      return {
-        type: "htmlText",
-        value: node.value
-      };
-    case "comment":
-      return {
-        type: "htmlComment",
-        value: node.value
-      };
-    case "doctype":
-      return null;
-    default:
-      return null;
+    if (token) tokens.push(token);
   }
+  return tokens;
 }
-function parseHtmlToNodes(html) {
-  if (!html || !html.trim()) return [];
-  try {
-    const tree = fromHtml(html, { fragment: true });
-    return hastChildrenToNodes(tree.children);
-  } catch {
-    return [{ type: "htmlText", value: html }];
+var DQ_UNESCAPE_RE = /\\([\\"])/g;
+var SQ_UNESCAPE_RE = /\\([\\'])/g;
+function unquoteAttrValue(raw) {
+  if (raw.length >= 2) {
+    const q = raw[0];
+    if ((q === '"' || q === "'") && raw.endsWith(q)) {
+      const body = raw.slice(1, -1);
+      return body.replace(q === '"' ? DQ_UNESCAPE_RE : SQ_UNESCAPE_RE, "$1");
+    }
   }
+  return raw;
 }
-function escapeHtmlAttr(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function splitKeyValueToken(token) {
+  const eqIdx = token.indexOf("=");
+  if (eqIdx <= 0) return null;
+  return { key: token.slice(0, eqIdx), value: unquoteAttrValue(token.slice(eqIdx + 1)) };
 }
-function stringifyNode(node) {
-  switch (node.type) {
-    case "htmlElement": {
-      const attrs = Object.entries(node.attributes).map(([k, v]) => v === "" ? k : `${k}="${escapeHtmlAttr(v)}"`).join(" ");
-      const open = attrs ? `<${node.tagName} ${attrs}>` : `<${node.tagName}>`;
-      if (node.selfClosing) return open;
-      const inner = node.children.map(stringifyNode).join("");
-      return `${open}${inner}</${node.tagName}>`;
-    }
-    case "htmlText":
-      return node.value;
-    case "htmlComment":
-      return `<!--${node.value}-->`;
+var NEEDS_QUOTING_RE = /[\s"'[\]{}]/;
+var DQ_ESCAPE_RE = /[\\"]/g;
+var SQ_ESCAPE_RE = /[\\']/g;
+function needsQuoting(value) {
+  return value === "" || NEEDS_QUOTING_RE.test(value);
+}
+function quoteAttrValue(value) {
+  if (!needsQuoting(value)) return value;
+  if (value.includes('"') && !value.includes("'")) {
+    return `'${value.replace(SQ_ESCAPE_RE, (ch) => `\\${ch}`)}'`;
   }
+  return `"${value.replace(DQ_ESCAPE_RE, (ch) => `\\${ch}`)}"`;
 }
-function stringifyHtmlNodes(nodes) {
-  return nodes.map(stringifyNode).join("");
+function serializeAnnotation(template, params) {
+  const parts = [];
+  if (template) parts.push(template);
+  for (const [key, value] of Object.entries(params ?? {})) {
+    parts.push(`${key}=${quoteAttrValue(value)}`);
+  }
+  return `{[${parts.join(" ")}]}`;
 }
 
 // src/markdown/convert.ts
@@ -174,14 +324,13 @@ function extractText(node) {
   }
   return "";
 }
-var TEMPLATE_ANNOTATION_RE = /\s*\{\[([^\]]+)\]\}[\s\]}]*$/;
 function extractTemplateAnnotation(children) {
   for (let i = children.length - 1; i >= 0; i--) {
     const child = children[i];
     if (child.type === "text") {
-      const match = child.value.match(TEMPLATE_ANNOTATION_RE);
+      const match = matchTrailingTemplateAnnotation(child.value);
       if (match) {
-        const inner = match[1].trim();
+        const inner = match.inner.trim();
         const annotation = parseAnnotationTokens(inner);
         const stripped = child.value.slice(0, match.index).replace(/\s+$/, "");
         if (stripped) {
@@ -198,15 +347,15 @@ function extractTemplateAnnotation(children) {
   return null;
 }
 function parseAnnotationTokens(inner) {
-  const tokens = inner.split(/\s+/);
+  const tokens = tokenizeAttrTokens(inner);
   const params = {};
-  const firstIsParam = tokens[0].indexOf("=") > 0;
-  const template = firstIsParam ? void 0 : tokens[0];
+  const firstIsParam = tokens.length > 0 && tokens[0].indexOf("=") > 0;
+  const template = firstIsParam || tokens.length === 0 ? void 0 : tokens[0];
   const startIdx = firstIsParam ? 0 : 1;
   for (let i = startIdx; i < tokens.length; i++) {
-    const eqIdx = tokens[i].indexOf("=");
-    if (eqIdx > 0) {
-      params[tokens[i].slice(0, eqIdx)] = tokens[i].slice(eqIdx + 1);
+    const kv = splitKeyValueToken(tokens[i]);
+    if (kv) {
+      params[kv.key] = kv.value;
     }
   }
   const result = {};
@@ -218,6 +367,95 @@ function parseAnnotationTokens(inner) {
   }
   return result;
 }
+function extractPandocAttributes(children) {
+  const trail = [];
+  for (let i = children.length - 1; i >= 0; i--) {
+    const c = children[i];
+    if (c.type === "text") {
+      trail.unshift({ val: c.value, idx: i, len: c.value.length });
+    } else if (c.type === "textDirective") {
+      const td = c;
+      const isBare = (!td.children || td.children.length === 0) && (!td.attributes || Object.keys(td.attributes).length === 0);
+      if (!isBare) break;
+      const synthesized = ":" + (td.name ?? "");
+      trail.unshift({ val: synthesized, idx: i, len: synthesized.length });
+    } else {
+      break;
+    }
+  }
+  if (trail.length === 0) return null;
+  const joined = trail.map((t) => t.val).join("");
+  const match = matchTrailingPandocAttr(joined);
+  if (!match) return null;
+  const inner = match.inner.trim();
+  const attrs = parsePandocAttrTokens(inner);
+  const matchStart = match.index;
+  let scannedLen = 0;
+  for (let ti = 0; ti < trail.length; ti++) {
+    const t = trail[ti];
+    if (scannedLen + t.len <= matchStart) {
+      scannedLen += t.len;
+      continue;
+    }
+    const firstNode = children[t.idx];
+    const keepLen = matchStart - scannedLen;
+    if (firstNode.type === "text") {
+      const trimmed = firstNode.value.slice(0, keepLen).replace(/\s+$/, "");
+      if (trimmed) {
+        firstNode.value = trimmed;
+        children.splice(t.idx + 1);
+      } else {
+        children.splice(t.idx);
+      }
+    } else {
+      children.splice(t.idx);
+    }
+    return attrs;
+  }
+  children.splice(trail[0].idx);
+  return attrs;
+}
+function parsePandocAttrTokens(inner) {
+  const tokens = tokenizeAttrTokens(inner);
+  const attrs = {};
+  const params = {};
+  const classes = [];
+  for (const token of tokens) {
+    if (token.startsWith("#") && !token.includes("=")) {
+      attrs.id = token.slice(1);
+    } else if (token.startsWith(".") && !token.includes("=")) {
+      const cls = token.slice(1);
+      if (cls) classes.push(cls);
+    } else {
+      const kv = splitKeyValueToken(token);
+      if (kv) {
+        params[kv.key] = kv.value;
+      }
+    }
+  }
+  if (classes.length > 0) attrs.classes = classes;
+  if (Object.keys(params).length > 0) {
+    attrs.params = params;
+    const { blockMeta, metadata } = coerceAnnotationValues(params);
+    if (Object.keys(blockMeta).length > 0) attrs.blockMeta = blockMeta;
+    if (Object.keys(metadata).length > 0) attrs.metadata = metadata;
+  }
+  return attrs;
+}
+function serializePandocAttributes(attrs) {
+  const parts = [];
+  if (attrs.id) parts.push(`#${attrs.id}`);
+  if (attrs.classes) {
+    for (const cls of attrs.classes) parts.push(`.${cls}`);
+  }
+  if (attrs.params) {
+    for (const [key, value] of Object.entries(attrs.params)) {
+      parts.push(`${key}=${quoteAttrValue(value)}`);
+    }
+  }
+  if (parts.length === 0) return "{}";
+  return `{${parts.join(" ")}}`;
+}
 function serializeTemplateAnnotation(annotation) {
   const parts = [];
   if (annotation.template) {
@@ -225,7 +463,7 @@ function serializeTemplateAnnotation(annotation) {
   }
   if (annotation.params) {
     for (const [key, value] of Object.entries(annotation.params)) {
-      parts.push(`${key}=${value}`);
+      parts.push(`${key}=${quoteAttrValue(value)}`);
     }
   }
   return `{[${parts.join(" ")}]}`;
@@ -373,7 +611,26 @@ function convertBlockNode(node, parseHtml) {
   switch (node.type) {
     case "heading": {
       const headingChildren = convertInlineChildren(node.children ?? [], parseHtml, false);
-      const annotation = extractTemplateAnnotation(headingChildren);
+      let annotation = null;
+      let attrs = null;
+      for (let pass = 0; pass < 4; pass++) {
+        let matched = false;
+        if (!annotation) {
+          const t = extractTemplateAnnotation(headingChildren);
+          if (t) {
+            annotation = t;
+            matched = true;
+          }
+        }
+        if (!attrs) {
+          const a = extractPandocAttributes(headingChildren);
+          if (a) {
+            attrs = a;
+            matched = true;
+          }
+        }
+        if (!matched) break;
+      }
       const finalChildren = splitInlineIcons(headingChildren);
       const result = {
         type: "heading",
@@ -384,6 +641,9 @@ function convertBlockNode(node, parseHtml) {
       if (annotation) {
         result.templateAnnotation = annotation;
       }
+      if (attrs) {
+        result.attributes = attrs;
+      }
       return result;
     }
     case "paragraph":
@@ -637,8 +897,16 @@ function blockToMdast(node) {
   switch (node.type) {
     case "heading": {
       const mdastChildren = inlineChildrenToMdast(node.children);
+      const suffixes = [];
+      if (node.attributes) {
+        const pandoc = serializePandocAttributes(node.attributes);
+        if (pandoc != null) suffixes.push(pandoc);
+      }
       if (node.templateAnnotation) {
-        const suffix = serializeTemplateAnnotation(node.templateAnnotation);
+        suffixes.push(serializeTemplateAnnotation(node.templateAnnotation));
+      }
+      if (suffixes.length > 0) {
+        const suffix = suffixes.join(" ");
         const lastChild = mdastChildren[mdastChildren.length - 1];
         if (lastChild && lastChild.type === "text") {
           lastChild.value = (lastChild.value ?? "") + " " + suffix;
@@ -932,6 +1200,12 @@ function definitionListToHtml(list) {
 }
 
 // src/markdown/parse.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
 var defaultProcessor;
 function parseMarkdown(markdown, options) {
   const useDefaults = !options || options.gfm !== false && options.math !== false && options.directive !== false && options.frontmatter !== false;
@@ -972,72 +1246,24 @@ function parseMarkdown(markdown, options) {
   return doc;
 }
 
-// src/markdown/stringify.ts
-import { unified as unified2 } from "unified";
-import remarkStringify from "remark-stringify";
-import remarkGfm2 from "remark-gfm";
-import remarkMath2 from "remark-math";
-import remarkDirective2 from "remark-directive";
-var defaultProcessor2;
-function stringifyMarkdown(doc, options) {
-  const mdastTree = toMdast(doc);
-  const useDefaults = !options || options.gfm !== false && options.math !== false && options.directive !== false && !options.bullet && !options.bulletOrdered && !options.emphasis && !options.strong && !options.rule && !options.fence && options.setext == null;
-  let processor;
-  if (useDefaults) {
-    if (!defaultProcessor2) {
-      defaultProcessor2 = unified2().use(remarkGfm2).use(remarkMath2).use(remarkDirective2).use(remarkStringify, {
-        bullet: "-",
-        bulletOrdered: ".",
-        emphasis: "*",
-        strong: "*",
-        rule: "-",
-        fence: "`",
-        setext: false
-      });
-    }
-    processor = defaultProcessor2;
-  } else {
-    processor = unified2();
-    if (options?.gfm !== false) {
-      processor = processor.use(remarkGfm2);
-    }
-    if (options?.math !== false) {
-      processor = processor.use(remarkMath2);
-    }
-    if (options?.directive !== false) {
-      processor = processor.use(remarkDirective2);
-    }
-    processor = processor.use(remarkStringify, {
-      bullet: options?.bullet ?? "-",
-      bulletOrdered: options?.bulletOrdered ?? ".",
-      emphasis: options?.emphasis ?? "*",
-      strong: options?.strong ?? "*",
-      rule: options?.rule ?? "-",
-      fence: options?.fence ?? "`",
-      setext: options?.setext ?? false
-    });
-  }
-  const result = processor.stringify(mdastTree);
-  const cleaned = result.replace(/\{\\\[([^\]]+)\]\}/g, "{[$1]}");
-  if (doc.frontmatter && Object.keys(doc.frontmatter).length > 0) {
-    const yamlLines = Object.entries(doc.frontmatter).map(
-      ([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`
-    );
-    return `---
-${yamlLines.join("\n")}
----
-
-${cleaned}`;
-  }
-  return cleaned;
-}
-
 export {
-  parseHtmlToNodes,
-  stringifyHtmlNodes,
+  KNOWN_BLOCK_META_KEYS,
+  BLOCK_META_KEY_DESCRIPTORS,
+  coerceAnnotationValues,
+  parseNumber,
+  parseTimeSeconds,
+  matchTrailingTemplateAnnotation,
+  matchTrailingPandocAttr,
+  tokenizeAttrTokens,
+  unquoteAttrValue,
+  splitKeyValueToken,
+  needsQuoting,
+  quoteAttrValue,
+  serializeAnnotation,
+  parsePandocAttrTokens,
+  serializePandocAttributes,
   fromMdast,
   toMdast,
-  parseMarkdown,
-  stringifyMarkdown
+  parseMarkdown
 };
-//# sourceMappingURL=chunk-3K5OG6KI.js.map
+//# sourceMappingURL=chunk-TEEEILMP.js.map