@bendyline/squisq 0.1.1

package/dist/chunk-URU6QMLY.js

@@ -0,0 +1,888 @@
+import {
+  parseFrontmatter
+} from "./chunk-QWVRN6I4.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"
+};
+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(/^-/, "");
+  }
+  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(/^-/, "");
+  }
+  return prop.toLowerCase();
+}
+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);
+    }
+  }
+  return attrs;
+}
+function hastChildrenToNodes(children) {
+  const result = [];
+  for (const child of children) {
+    const node = hastNodeToHtmlNode(child);
+    if (node) result.push(node);
+  }
+  return result;
+}
+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
+      };
+    }
+    case "text":
+      return {
+        type: "htmlText",
+        value: node.value
+      };
+    case "comment":
+      return {
+        type: "htmlComment",
+        value: node.value
+      };
+    case "doctype":
+      return null;
+    default:
+      return null;
+  }
+}
+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 }];
+  }
+}
+function escapeHtmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+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}-->`;
+  }
+}
+function stringifyHtmlNodes(nodes) {
+  return nodes.map(stringifyNode).join("");
+}
+
+// src/markdown/convert.ts
+function convertPosition(pos) {
+  if (!pos) return void 0;
+  return {
+    start: {
+      line: pos.start.line,
+      column: pos.start.column,
+      ...pos.start.offset != null ? { offset: pos.start.offset } : {}
+    },
+    end: {
+      line: pos.end.line,
+      column: pos.end.column,
+      ...pos.end.offset != null ? { offset: pos.end.offset } : {}
+    }
+  };
+}
+function toMdastPosition(pos) {
+  return {
+    start: {
+      line: pos.start.line,
+      column: pos.start.column,
+      ...pos.start.offset != null ? { offset: pos.start.offset } : {}
+    },
+    end: {
+      line: pos.end.line,
+      column: pos.end.column,
+      ...pos.end.offset != null ? { offset: pos.end.offset } : {}
+    }
+  };
+}
+function posField(pos) {
+  return pos ? { position: pos } : {};
+}
+function mdastPosField(pos) {
+  return pos ? { position: toMdastPosition(pos) } : {};
+}
+function extractText(node) {
+  if (node.value != null) return node.value;
+  if (node.children) {
+    return node.children.map(extractText).join("");
+  }
+  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);
+      if (match) {
+        const inner = match[1].trim();
+        const annotation = parseAnnotationTokens(inner);
+        const stripped = child.value.slice(0, match.index).replace(/\s+$/, "");
+        if (stripped) {
+          child.value = stripped;
+        } else {
+          children.splice(i, 1);
+        }
+        return annotation;
+      }
+      break;
+    }
+    break;
+  }
+  return null;
+}
+function parseAnnotationTokens(inner) {
+  const tokens = inner.split(/\s+/);
+  const template = tokens[0];
+  const params = {};
+  for (let i = 1; i < tokens.length; i++) {
+    const eqIdx = tokens[i].indexOf("=");
+    if (eqIdx > 0) {
+      params[tokens[i].slice(0, eqIdx)] = tokens[i].slice(eqIdx + 1);
+    }
+  }
+  const result = { template };
+  if (Object.keys(params).length > 0) {
+    result.params = params;
+  }
+  return result;
+}
+function serializeTemplateAnnotation(annotation) {
+  let result = `{[${annotation.template}`;
+  if (annotation.params) {
+    for (const [key, value] of Object.entries(annotation.params)) {
+      result += ` ${key}=${value}`;
+    }
+  }
+  result += "]}";
+  return result;
+}
+function fromMdast(root, options) {
+  const doParseHtml = options?.parseHtml !== false;
+  return {
+    type: "document",
+    children: convertBlockChildren(root.children ?? [], doParseHtml),
+    ...posField(convertPosition(root.position))
+  };
+}
+function convertBlockChildren(children, parseHtml) {
+  const result = [];
+  for (const child of children) {
+    const node = convertBlockNode(child, parseHtml);
+    if (node) result.push(node);
+  }
+  return result;
+}
+function convertInlineChildren(children, parseHtml) {
+  const result = [];
+  for (const child of children) {
+    const node = convertInlineNode(child, parseHtml);
+    if (node) result.push(node);
+  }
+  return result;
+}
+function convertBlockNode(node, parseHtml) {
+  const pos = convertPosition(node.position);
+  switch (node.type) {
+    case "heading": {
+      const headingChildren = convertInlineChildren(node.children ?? [], parseHtml);
+      const annotation = extractTemplateAnnotation(headingChildren);
+      const result = {
+        type: "heading",
+        depth: node.depth ?? 1,
+        children: headingChildren,
+        ...posField(pos)
+      };
+      if (annotation) {
+        result.templateAnnotation = annotation;
+      }
+      return result;
+    }
+    case "paragraph":
+      return {
+        type: "paragraph",
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "blockquote":
+      return {
+        type: "blockquote",
+        children: convertBlockChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "list":
+      return {
+        type: "list",
+        ordered: node.ordered ?? false,
+        ...node.start != null ? { start: node.start } : {},
+        ...node.spread != null ? { spread: node.spread } : {},
+        children: (node.children ?? []).map((item) => convertListItem(item, parseHtml)),
+        ...posField(pos)
+      };
+    case "code":
+      return {
+        type: "code",
+        ...node.lang != null ? { lang: node.lang } : {},
+        ...node.meta != null ? { meta: node.meta } : {},
+        value: node.value ?? "",
+        ...posField(pos)
+      };
+    case "thematicBreak":
+      return {
+        type: "thematicBreak",
+        ...posField(pos)
+      };
+    case "table":
+      return {
+        type: "table",
+        ...node.align ? { align: node.align.map((a) => a) } : {},
+        children: (node.children ?? []).map((row, i) => convertTableRow(row, i === 0, parseHtml)),
+        ...posField(pos)
+      };
+    case "html":
+      return {
+        type: "htmlBlock",
+        rawHtml: node.value ?? "",
+        htmlChildren: parseHtml ? parseHtmlToNodes(node.value ?? "") : [],
+        ...posField(pos)
+      };
+    case "math":
+      return {
+        type: "math",
+        value: node.value ?? "",
+        ...node.meta != null ? { meta: node.meta } : {},
+        ...posField(pos)
+      };
+    case "definition":
+      return {
+        type: "definition",
+        identifier: node.identifier ?? "",
+        ...node.label != null ? { label: node.label } : {},
+        url: node.url ?? "",
+        ...node.title != null ? { title: node.title } : {},
+        ...posField(pos)
+      };
+    case "footnoteDefinition":
+      return {
+        type: "footnoteDefinition",
+        identifier: node.identifier ?? "",
+        ...node.label != null ? { label: node.label } : {},
+        children: convertBlockChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "containerDirective": {
+      const allChildren = node.children ?? [];
+      let label;
+      let contentChildren = allChildren;
+      if (allChildren.length > 0 && allChildren[0].type === "paragraph" && allChildren[0].data?.directiveLabel === true) {
+        label = extractText(allChildren[0]);
+        contentChildren = allChildren.slice(1);
+      }
+      return {
+        type: "containerDirective",
+        name: node.name ?? "",
+        ...label ? { label } : {},
+        ...node.attributes && Object.keys(node.attributes).length > 0 ? { attributes: node.attributes } : {},
+        children: convertBlockChildren(contentChildren, parseHtml),
+        ...posField(pos)
+      };
+    }
+    case "leafDirective":
+      return {
+        type: "leafDirective",
+        name: node.name ?? "",
+        ...node.attributes && Object.keys(node.attributes).length > 0 ? { attributes: node.attributes } : {},
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "yaml":
+      return null;
+    default:
+      if (typeof console !== "undefined") {
+        console.warn(`[squisq/markdown] Unknown mdast block node type: "${node.type}"`);
+      }
+      return null;
+  }
+}
+function convertListItem(node, parseHtml) {
+  const pos = convertPosition(node.position);
+  return {
+    type: "listItem",
+    ...node.checked != null ? { checked: node.checked } : {},
+    ...node.spread != null ? { spread: node.spread } : {},
+    children: convertBlockChildren(node.children ?? [], parseHtml),
+    ...posField(pos)
+  };
+}
+function convertTableRow(node, isHeader, parseHtml) {
+  const pos = convertPosition(node.position);
+  return {
+    type: "tableRow",
+    children: (node.children ?? []).map((cell) => convertTableCell(cell, isHeader, parseHtml)),
+    ...posField(pos)
+  };
+}
+function convertTableCell(node, isHeader, parseHtml) {
+  const pos = convertPosition(node.position);
+  return {
+    type: "tableCell",
+    ...isHeader ? { isHeader: true } : {},
+    children: convertInlineChildren(node.children ?? [], parseHtml),
+    ...posField(pos)
+  };
+}
+function convertInlineNode(node, parseHtml) {
+  const pos = convertPosition(node.position);
+  switch (node.type) {
+    case "text":
+      return {
+        type: "text",
+        value: node.value ?? "",
+        ...posField(pos)
+      };
+    case "emphasis":
+      return {
+        type: "emphasis",
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "strong":
+      return {
+        type: "strong",
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "delete":
+      return {
+        type: "delete",
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "inlineCode":
+      return {
+        type: "inlineCode",
+        value: node.value ?? "",
+        ...posField(pos)
+      };
+    case "link":
+      return {
+        type: "link",
+        url: node.url ?? "",
+        ...node.title != null ? { title: node.title } : {},
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "image":
+      return {
+        type: "image",
+        url: node.url ?? "",
+        ...node.alt != null ? { alt: node.alt } : {},
+        ...node.title != null ? { title: node.title } : {},
+        ...posField(pos)
+      };
+    case "break":
+      return {
+        type: "break",
+        ...posField(pos)
+      };
+    case "html":
+      return {
+        type: "htmlInline",
+        rawHtml: node.value ?? "",
+        htmlChildren: parseHtml ? parseHtmlToNodes(node.value ?? "") : [],
+        ...posField(pos)
+      };
+    case "inlineMath":
+      return {
+        type: "inlineMath",
+        value: node.value ?? "",
+        ...posField(pos)
+      };
+    case "footnoteReference":
+      return {
+        type: "footnoteReference",
+        identifier: node.identifier ?? "",
+        ...node.label != null ? { label: node.label } : {},
+        ...posField(pos)
+      };
+    case "linkReference":
+      return {
+        type: "linkReference",
+        identifier: node.identifier ?? "",
+        ...node.label != null ? { label: node.label } : {},
+        referenceType: node.referenceType ?? "full",
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    case "imageReference":
+      return {
+        type: "imageReference",
+        identifier: node.identifier ?? "",
+        ...node.label != null ? { label: node.label } : {},
+        referenceType: node.referenceType ?? "full",
+        ...node.alt != null ? { alt: node.alt } : {},
+        ...posField(pos)
+      };
+    case "textDirective":
+      return {
+        type: "textDirective",
+        name: node.name ?? "",
+        ...node.attributes && Object.keys(node.attributes).length > 0 ? { attributes: node.attributes } : {},
+        children: convertInlineChildren(node.children ?? [], parseHtml),
+        ...posField(pos)
+      };
+    default:
+      if (typeof console !== "undefined") {
+        console.warn(`[squisq/markdown] Unknown mdast inline node type: "${node.type}"`);
+      }
+      return null;
+  }
+}
+function toMdast(doc) {
+  return {
+    type: "root",
+    children: doc.children.map((n) => blockToMdast(n)),
+    ...mdastPosField(doc.position)
+  };
+}
+function blockToMdast(node) {
+  switch (node.type) {
+    case "heading": {
+      const mdastChildren = node.children.map(inlineToMdast);
+      if (node.templateAnnotation) {
+        const suffix = serializeTemplateAnnotation(node.templateAnnotation);
+        const lastChild = mdastChildren[mdastChildren.length - 1];
+        if (lastChild && lastChild.type === "text") {
+          lastChild.value = (lastChild.value ?? "") + " " + suffix;
+        } else {
+          mdastChildren.push({ type: "text", value: " " + suffix });
+        }
+      }
+      return {
+        type: "heading",
+        depth: node.depth,
+        children: mdastChildren,
+        ...mdastPosField(node.position)
+      };
+    }
+    case "paragraph":
+      return {
+        type: "paragraph",
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "blockquote":
+      return {
+        type: "blockquote",
+        children: node.children.map(blockToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "list":
+      return {
+        type: "list",
+        ordered: node.ordered,
+        ...node.start != null ? { start: node.start } : {},
+        ...node.spread != null ? { spread: node.spread } : {},
+        children: node.children.map(listItemToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "code":
+      return {
+        type: "code",
+        ...node.lang != null ? { lang: node.lang } : {},
+        ...node.meta != null ? { meta: node.meta } : {},
+        value: node.value,
+        ...mdastPosField(node.position)
+      };
+    case "thematicBreak":
+      return {
+        type: "thematicBreak",
+        ...mdastPosField(node.position)
+      };
+    case "table":
+      return {
+        type: "table",
+        ...node.align ? { align: node.align } : {},
+        children: node.children.map(tableRowToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "htmlBlock":
+      return {
+        type: "html",
+        value: node.rawHtml,
+        ...mdastPosField(node.position)
+      };
+    case "math":
+      return {
+        type: "math",
+        value: node.value,
+        ...node.meta != null ? { meta: node.meta } : {},
+        ...mdastPosField(node.position)
+      };
+    case "definition":
+      return {
+        type: "definition",
+        identifier: node.identifier,
+        ...node.label != null ? { label: node.label } : {},
+        url: node.url,
+        ...node.title != null ? { title: node.title } : {},
+        ...mdastPosField(node.position)
+      };
+    case "footnoteDefinition":
+      return {
+        type: "footnoteDefinition",
+        identifier: node.identifier,
+        ...node.label != null ? { label: node.label } : {},
+        children: node.children.map(blockToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "containerDirective": {
+      const children = [];
+      if (node.label) {
+        children.push({
+          type: "paragraph",
+          data: { directiveLabel: true },
+          children: [{ type: "text", value: node.label }]
+        });
+      }
+      children.push(...node.children.map(blockToMdast));
+      return {
+        type: "containerDirective",
+        name: node.name,
+        ...node.attributes ? { attributes: node.attributes } : {},
+        children,
+        ...mdastPosField(node.position)
+      };
+    }
+    case "leafDirective":
+      return {
+        type: "leafDirective",
+        name: node.name,
+        ...node.attributes ? { attributes: node.attributes } : {},
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "definitionList":
+      return {
+        type: "html",
+        value: definitionListToHtml(node),
+        ...mdastPosField(node.position)
+      };
+    default:
+      return { type: "html", value: "" };
+  }
+}
+function listItemToMdast(item) {
+  return {
+    type: "listItem",
+    ...item.checked != null ? { checked: item.checked } : {},
+    ...item.spread != null ? { spread: item.spread } : {},
+    children: item.children.map(blockToMdast),
+    ...mdastPosField(item.position)
+  };
+}
+function tableRowToMdast(row) {
+  return {
+    type: "tableRow",
+    children: row.children.map(tableCellToMdast),
+    ...mdastPosField(row.position)
+  };
+}
+function tableCellToMdast(cell) {
+  return {
+    type: "tableCell",
+    children: cell.children.map(inlineToMdast),
+    ...mdastPosField(cell.position)
+  };
+}
+function inlineToMdast(node) {
+  switch (node.type) {
+    case "text":
+      return {
+        type: "text",
+        value: node.value,
+        ...mdastPosField(node.position)
+      };
+    case "emphasis":
+      return {
+        type: "emphasis",
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "strong":
+      return {
+        type: "strong",
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "delete":
+      return {
+        type: "delete",
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "inlineCode":
+      return {
+        type: "inlineCode",
+        value: node.value,
+        ...mdastPosField(node.position)
+      };
+    case "link":
+      return {
+        type: "link",
+        url: node.url,
+        ...node.title != null ? { title: node.title } : {},
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "image":
+      return {
+        type: "image",
+        url: node.url,
+        ...node.alt != null ? { alt: node.alt } : {},
+        ...node.title != null ? { title: node.title } : {},
+        ...mdastPosField(node.position)
+      };
+    case "break":
+      return {
+        type: "break",
+        ...mdastPosField(node.position)
+      };
+    case "htmlInline":
+      return {
+        type: "html",
+        value: node.rawHtml,
+        ...mdastPosField(node.position)
+      };
+    case "inlineMath":
+      return {
+        type: "inlineMath",
+        value: node.value,
+        ...mdastPosField(node.position)
+      };
+    case "footnoteReference":
+      return {
+        type: "footnoteReference",
+        identifier: node.identifier,
+        ...node.label != null ? { label: node.label } : {},
+        ...mdastPosField(node.position)
+      };
+    case "linkReference":
+      return {
+        type: "linkReference",
+        identifier: node.identifier,
+        ...node.label != null ? { label: node.label } : {},
+        referenceType: node.referenceType,
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    case "imageReference":
+      return {
+        type: "imageReference",
+        identifier: node.identifier,
+        ...node.label != null ? { label: node.label } : {},
+        referenceType: node.referenceType,
+        ...node.alt != null ? { alt: node.alt } : {},
+        ...mdastPosField(node.position)
+      };
+    case "textDirective":
+      return {
+        type: "textDirective",
+        name: node.name,
+        ...node.attributes ? { attributes: node.attributes } : {},
+        children: node.children.map(inlineToMdast),
+        ...mdastPosField(node.position)
+      };
+    default:
+      return { type: "text", value: "" };
+  }
+}
+function definitionListToHtml(list) {
+  let html = "<dl>\n";
+  for (const child of list.children) {
+    if (child.type === "definitionTerm") {
+      const text = child.children.map((c) => c.value ?? "").join("");
+      html += `  <dt>${text}</dt>
+`;
+    } else if (child.type === "definitionDescription") {
+      html += `  <dd>...</dd>
+`;
+    }
+  }
+  html += "</dl>";
+  return html;
+}
+
+// src/markdown/parse.ts
+var defaultProcessor;
+function parseMarkdown(markdown, options) {
+  const useDefaults = !options || options.gfm !== false && options.math !== false && options.directive !== false && options.frontmatter !== false;
+  let processor;
+  if (useDefaults) {
+    if (!defaultProcessor) {
+      defaultProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkDirective).use(remarkFrontmatter, ["yaml"]);
+    }
+    processor = defaultProcessor;
+  } else {
+    processor = unified().use(remarkParse);
+    if (options?.gfm !== false) {
+      processor = processor.use(remarkGfm);
+    }
+    if (options?.math !== false) {
+      processor = processor.use(remarkMath);
+    }
+    if (options?.directive !== false) {
+      processor = processor.use(remarkDirective);
+    }
+    if (options?.frontmatter !== false) {
+      processor = processor.use(remarkFrontmatter, ["yaml"]);
+    }
+  }
+  const mdastTree = processor.parse(markdown);
+  const doc = fromMdast(mdastTree, {
+    parseHtml: options?.parseHtml
+  });
+  if (options?.frontmatter !== false) {
+    const yamlNode = mdastTree.children?.find((n) => n.type === "yaml");
+    if (yamlNode?.value) {
+      const fm = parseFrontmatter(yamlNode.value);
+      if (fm && Object.keys(fm).length > 0) {
+        doc.frontmatter = fm;
+      }
+    }
+  }
+  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,
+  fromMdast,
+  toMdast,
+  parseMarkdown,
+  stringifyMarkdown
+};
+//# sourceMappingURL=chunk-URU6QMLY.js.map