@bendyline/squisq 2.0.1 → 2.2.0

package/dist/chunk-BCCXTMN5.js

@@ -0,0 +1,699 @@
+// 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/utils.ts
+function getChildren(node) {
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children;
+  }
+  return [];
+}
+function walkMarkdownTree(node, visitor, parent) {
+  const skip = visitor(node, parent);
+  if (skip === true) return;
+  const children = getChildren(node);
+  for (const child of children) {
+    walkMarkdownTree(child, visitor, node);
+  }
+}
+function findNodesByType(root, type) {
+  const results = [];
+  walkMarkdownTree(root, (node) => {
+    if (node.type === type) {
+      results.push(node);
+    }
+  });
+  return results;
+}
+function extractPlainText(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  const children = getChildren(node);
+  const separator = node.type === "list" || node.type === "listItem" ? "\n" : "";
+  return children.map(extractPlainText).join(separator);
+}
+function countNodes(node) {
+  let count = 1;
+  const children = getChildren(node);
+  for (const child of children) {
+    count += countNodes(child);
+  }
+  return count;
+}
+var YAML_TRUE = /* @__PURE__ */ new Set(["true", "True", "TRUE"]);
+var YAML_FALSE = /* @__PURE__ */ new Set(["false", "False", "FALSE"]);
+var YAML_NULL = /* @__PURE__ */ new Set(["null", "Null", "NULL", "~"]);
+var YAML_CANONICAL_NUMBER_RE = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:e[+-][0-9]+)?$/;
+function isCanonicalNumber(text) {
+  return YAML_CANONICAL_NUMBER_RE.test(text) && String(Number(text)) === text;
+}
+function assignKey(map, key, value) {
+  Object.defineProperty(map, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function isSkippableLine(line) {
+  const trimmed = line.trim();
+  return trimmed === "" || trimmed.startsWith("#");
+}
+function nextSignificant(cur) {
+  let j = cur.i;
+  while (j < cur.lines.length && isSkippableLine(cur.lines[j])) j++;
+  return j;
+}
+function isSequenceItem(content) {
+  return content === "-" || content.startsWith("- ");
+}
+function readQuotedScalar(text) {
+  const quote = text[0];
+  if (quote === '"') {
+    for (let i = 1; i < text.length; i++) {
+      if (text[i] === "\\") {
+        i++;
+        continue;
+      }
+      if (text[i] !== '"') continue;
+      const raw = text.slice(0, i + 1);
+      try {
+        return { value: JSON.parse(raw), rest: text.slice(i + 1) };
+      } catch {
+        return { value: raw.slice(1, -1), rest: text.slice(i + 1) };
+      }
+    }
+    return null;
+  }
+  if (quote === "'") {
+    let value = "";
+    for (let i = 1; i < text.length; i++) {
+      if (text[i] !== "'") {
+        value += text[i];
+        continue;
+      }
+      if (text[i + 1] === "'") {
+        value += "'";
+        i++;
+        continue;
+      }
+      return { value, rest: text.slice(i + 1) };
+    }
+    return null;
+  }
+  return null;
+}
+function splitMappingKey(content) {
+  if (content.startsWith("{") || content.startsWith("[")) return null;
+  if (content.startsWith('"') || content.startsWith("'")) {
+    const quoted = readQuotedScalar(content);
+    if (!quoted) return null;
+    const after = quoted.rest;
+    if (after === ":" || after.startsWith(": ") || after.startsWith(":	")) {
+      return { key: quoted.value, rest: after.slice(1).trim() };
+    }
+    return null;
+  }
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] !== ":") continue;
+    const next = content[i + 1];
+    if (next !== void 0 && next !== " " && next !== "	") continue;
+    const key = content.slice(0, i).trim();
+    if (!key) return null;
+    return { key, rest: content.slice(i + 1).trim() };
+  }
+  const colon = content.indexOf(":");
+  if (colon > 0 && content[colon + 1] !== "/") {
+    const key = content.slice(0, colon).trim();
+    if (key && !key.includes(" ")) return { key, rest: content.slice(colon + 1).trim() };
+  }
+  return null;
+}
+function foldBlockLines(lines) {
+  const parts = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === "") {
+      parts.push("\n");
+      i++;
+      continue;
+    }
+    if (/^\s/.test(line)) {
+      parts.push((parts.length > 0 ? "\n" : "") + line);
+      i++;
+      continue;
+    }
+    parts.push(line);
+    i++;
+    while (i < lines.length && lines[i] !== "" && !/^\s/.test(lines[i])) {
+      parts.push(` ${lines[i]}`);
+      i++;
+    }
+  }
+  return parts.join("");
+}
+function parseBlockScalar(cur, keyIndent, folded, chomp) {
+  const blockLines = [];
+  let j = cur.i;
+  for (; j < cur.lines.length; j++) {
+    const line = cur.lines[j];
+    if (line.trim() === "") {
+      blockLines.push("");
+      continue;
+    }
+    if (indentOf(line) <= keyIndent) break;
+    blockLines.push(line);
+  }
+  cur.i = j;
+  if (chomp !== "+") {
+    while (blockLines.length > 0 && blockLines[blockLines.length - 1] === "") blockLines.pop();
+  }
+  let commonIndent = Infinity;
+  for (const line of blockLines) {
+    if (line === "") continue;
+    commonIndent = Math.min(commonIndent, indentOf(line));
+  }
+  if (!isFinite(commonIndent)) commonIndent = 0;
+  const dedented = blockLines.map((line) => line === "" ? "" : line.slice(commonIndent));
+  return folded ? foldBlockLines(dedented) : dedented.join("\n");
+}
+function scalarFromText(text) {
+  if (text === "" || YAML_NULL.has(text)) return null;
+  if (YAML_TRUE.has(text)) return true;
+  if (YAML_FALSE.has(text)) return false;
+  if (isCanonicalNumber(text)) return Number(text);
+  return text;
+}
+function collectPlainContinuation(cur, keyIndent, first) {
+  const parts = [first];
+  while (cur.i < cur.lines.length) {
+    const line = cur.lines[cur.i];
+    if (isSkippableLine(line)) break;
+    if (indentOf(line) <= keyIndent) break;
+    parts.push(line.trim());
+    cur.i++;
+  }
+  return parts.join(" ");
+}
+function parseValue(cur, keyIndent, inline) {
+  const blockScalar = /^([|>])([0-9]*)([+-]?)$/.exec(inline);
+  if (blockScalar) {
+    return parseBlockScalar(cur, keyIndent, blockScalar[1] === ">", blockScalar[3]);
+  }
+  if (inline === "") return parseNodeBelowKey(cur, keyIndent);
+  if (inline.startsWith('"') || inline.startsWith("'")) {
+    const quoted = readQuotedScalar(inline);
+    if (quoted && quoted.rest.trim() === "") return quoted.value;
+    const quote = inline[0];
+    if (inline.length >= 2 && inline.endsWith(quote)) {
+      const body = inline.slice(1, -1);
+      return quote === "'" ? body.replace(/''/g, "'") : body;
+    }
+    return inline;
+  }
+  if (inline === "[]") return [];
+  if (inline === "{}") return {};
+  if (inline.startsWith("{") || inline.startsWith("[")) return inline;
+  return scalarFromText(collectPlainContinuation(cur, keyIndent, inline));
+}
+function parseNodeBelowKey(cur, keyIndent) {
+  const j = nextSignificant(cur);
+  if (j >= cur.lines.length) return null;
+  const line = cur.lines[j];
+  const ind = indentOf(line);
+  const content = line.slice(ind);
+  if (isSequenceItem(content) && ind >= keyIndent) {
+    cur.i = j;
+    return parseSequence(cur, ind);
+  }
+  if (ind > keyIndent) {
+    cur.i = j;
+    if (splitMappingKey(content)) return parseMapping(cur, ind);
+    cur.i = j + 1;
+    return scalarFromText(collectPlainContinuation(cur, keyIndent, content.trim()));
+  }
+  return null;
+}
+function parseNodeBelowDash(cur, dashIndent) {
+  const j = nextSignificant(cur);
+  if (j >= cur.lines.length) return null;
+  const line = cur.lines[j];
+  const ind = indentOf(line);
+  if (ind <= dashIndent) return null;
+  const content = line.slice(ind);
+  cur.i = j;
+  if (isSequenceItem(content)) return parseSequence(cur, ind);
+  if (splitMappingKey(content)) return parseMapping(cur, ind);
+  cur.i = j + 1;
+  return scalarFromText(collectPlainContinuation(cur, dashIndent, content.trim()));
+}
+function parseSequence(cur, indent) {
+  const items = [];
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) {
+      cur.i = j;
+      break;
+    }
+    const line = cur.lines[j];
+    const ind = indentOf(line);
+    if (ind !== indent) break;
+    const content = line.slice(ind);
+    if (!isSequenceItem(content)) break;
+    const afterDash = content.slice(1);
+    const itemText = afterDash.trimStart();
+    if (itemText === "") {
+      cur.i = j + 1;
+      items.push(parseNodeBelowDash(cur, ind));
+      continue;
+    }
+    const itemCol = ind + 1 + (afterDash.length - itemText.length);
+    const entry = splitMappingKey(itemText);
+    if (entry) {
+      cur.lines[j] = " ".repeat(itemCol) + itemText;
+      cur.i = j;
+      items.push(parseMapping(cur, itemCol));
+      continue;
+    }
+    cur.i = j + 1;
+    items.push(parseValue(cur, ind, itemText));
+  }
+  return items;
+}
+function parseMapping(cur, indent) {
+  const map = {};
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) {
+      cur.i = j;
+      break;
+    }
+    const line = cur.lines[j];
+    const ind = indentOf(line);
+    if (ind !== indent) break;
+    const content = line.slice(ind);
+    if (isSequenceItem(content)) break;
+    const entry = splitMappingKey(content);
+    if (!entry) break;
+    cur.i = j + 1;
+    assignKey(map, entry.key, parseValue(cur, indent, entry.rest));
+  }
+  return map;
+}
+function parseFrontmatter(yaml) {
+  if (!yaml || !yaml.trim()) return null;
+  const cur = { lines: yaml.replace(/\r\n?/g, "\n").split("\n"), i: 0 };
+  const result = {};
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) break;
+    cur.i = j;
+    const map = parseMapping(cur, indentOf(cur.lines[j]));
+    for (const [key, value] of Object.entries(map)) assignKey(result, key, value);
+    if (cur.i <= j) cur.i = j + 1;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function formatBlockScalar(value) {
+  const body = value.split("\n").map((line) => line === "" ? "" : `  ${line}`).join("\n");
+  return `|-
+${body}`;
+}
+var FRONTMATTER_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n)?/;
+function formatFrontmatterValue(value) {
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (/[\r\n]/.test(value)) return formatBlockScalar(value.replace(/\r\n?/g, "\n"));
+  if (value !== "[]" && value !== "{}" && /^[{[]/.test(value)) return value;
+  const needsQuote = /^\s|\s$/.test(value) || /^[!&*?|>%@`~]/.test(value) || /[:#]/.test(value) || value === "" || value === "[]" || value === "{}" || YAML_TRUE.has(value) || YAML_FALSE.has(value) || YAML_NULL.has(value) || value !== "" && !Number.isNaN(Number(value)) || /^["']/.test(value) && /["']$/.test(value);
+  if (!needsQuote) return value;
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+function formatFrontmatterKey(key) {
+  return /^[A-Za-z0-9_](?:[A-Za-z0-9 _.-]*[A-Za-z0-9_.-])?$/.test(key) ? key : formatFrontmatterValue(key);
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isOmittedValue(value) {
+  return value === void 0 || typeof value === "function" || typeof value === "symbol";
+}
+function toScalar(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) return value.toISOString();
+  return String(value);
+}
+function pushScalar(out, pad, prefix, value) {
+  const formatted = formatFrontmatterValue(toScalar(value));
+  if (!formatted.includes("\n")) {
+    out.push(`${pad}${prefix}${formatted}`);
+    return;
+  }
+  const [head, ...body] = formatted.split("\n");
+  out.push(`${pad}${prefix}${head}`);
+  for (const line of body) out.push(line === "" ? "" : `${pad}${line}`);
+}
+function emitSequence(items, indent, out) {
+  const pad = " ".repeat(indent);
+  for (const item of items) {
+    if (item === null || isOmittedValue(item)) {
+      out.push(`${pad}- null`);
+      continue;
+    }
+    if (Array.isArray(item)) {
+      if (item.length === 0) {
+        out.push(`${pad}- []`);
+        continue;
+      }
+      out.push(`${pad}-`);
+      emitSequence(item, indent + 2, out);
+      continue;
+    }
+    if (isPlainRecord(item)) {
+      const sub = [];
+      emitMapping(item, indent + 2, sub);
+      if (sub.length === 0) {
+        out.push(`${pad}- {}`);
+        continue;
+      }
+      sub[0] = `${pad}- ${sub[0].slice(indent + 2)}`;
+      out.push(...sub);
+      continue;
+    }
+    pushScalar(out, pad, "- ", item);
+  }
+}
+function emitMapping(map, indent, out) {
+  const pad = " ".repeat(indent);
+  for (const [rawKey, value] of Object.entries(map)) {
+    if (isOmittedValue(value)) continue;
+    const key = formatFrontmatterKey(rawKey);
+    if (value === null) {
+      out.push(`${pad}${key}: null`);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        out.push(`${pad}${key}: []`);
+        continue;
+      }
+      out.push(`${pad}${key}:`);
+      emitSequence(value, indent + 2, out);
+      continue;
+    }
+    if (isPlainRecord(value)) {
+      const sub = [];
+      emitMapping(value, indent + 2, sub);
+      if (sub.length === 0) {
+        out.push(`${pad}${key}: {}`);
+        continue;
+      }
+      out.push(`${pad}${key}:`);
+      out.push(...sub);
+      continue;
+    }
+    pushScalar(out, pad, `${key}: `, value);
+  }
+}
+function formatFrontmatterYaml(frontmatter) {
+  const out = [];
+  emitMapping(frontmatter, 0, out);
+  return out.join("\n");
+}
+function setFrontmatterValues(source, updates) {
+  const updateKeys = Object.keys(updates);
+  if (updateKeys.length === 0) return source;
+  const match = source.match(FRONTMATTER_BLOCK_RE);
+  const handled = /* @__PURE__ */ new Set();
+  if (match) {
+    const inner = match[1];
+    const lines = inner.split(/\r?\n/);
+    const newLines = [];
+    const firstSignificant = lines.find((line) => !isSkippableLine(line));
+    const rootIndent = firstSignificant === void 0 ? 0 : indentOf(firstSignificant);
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+      const ind = indentOf(line);
+      const entry = isSkippableLine(line) || ind !== rootIndent ? null : splitMappingKey(line.slice(ind));
+      if (!entry) {
+        newLines.push(line);
+        i++;
+        continue;
+      }
+      let end = i + 1;
+      while (end < lines.length) {
+        if (lines[end].trim() === "") {
+          let probe = end;
+          while (probe < lines.length && lines[probe].trim() === "") probe++;
+          if (probe < lines.length && indentOf(lines[probe]) > rootIndent) {
+            end = probe;
+            continue;
+          }
+          break;
+        }
+        if (indentOf(lines[end]) <= rootIndent) break;
+        end++;
+      }
+      if (!Object.prototype.hasOwnProperty.call(updates, entry.key)) {
+        for (let k = i; k < end; k++) newLines.push(lines[k]);
+        i = end;
+        continue;
+      }
+      handled.add(entry.key);
+      const next = updates[entry.key];
+      if (next !== null && next !== void 0) {
+        pushScalar(newLines, " ".repeat(rootIndent), `${formatFrontmatterKey(entry.key)}: `, next);
+      }
+      i = end;
+    }
+    for (const key of updateKeys) {
+      if (handled.has(key)) continue;
+      const next = updates[key];
+      if (next === null || next === void 0) continue;
+      pushScalar(newLines, "", `${formatFrontmatterKey(key)}: `, next);
+    }
+    const nonEmpty = newLines.filter((l) => l.trim().length > 0);
+    const rest = source.slice(match[0].length);
+    if (nonEmpty.length === 0) return rest;
+    return `---
+${newLines.join("\n")}
+---
+${rest}`;
+  }
+  const fresh = [];
+  for (const key of updateKeys) {
+    const next = updates[key];
+    if (next === null || next === void 0) continue;
+    pushScalar(fresh, "", `${formatFrontmatterKey(key)}: `, next);
+  }
+  if (fresh.length === 0) return source;
+  return `---
+${fresh.join("\n")}
+---
+${source}`;
+}
+function createDocument(...children) {
+  return {
+    type: "document",
+    children
+  };
+}
+function inferDocumentTitle(doc) {
+  const fmTitle = doc.frontmatter?.title;
+  if (typeof fmTitle === "string") {
+    const trimmed = fmTitle.trim();
+    if (trimmed) return trimmed;
+  }
+  let best = null;
+  for (const node of doc.children) {
+    if (node.type !== "heading") continue;
+    const text = extractPlainText(node).trim();
+    if (!text) continue;
+    if (best === null || node.depth < best.depth) {
+      best = { depth: node.depth, text };
+      if (best.depth === 1) break;
+    }
+  }
+  return best?.text;
+}
+function readFrontmatterThemeId(frontmatter) {
+  if (!frontmatter) return void 0;
+  const keys = ["squisq-theme", "themeId", "theme"];
+  for (const key of keys) {
+    const raw = frontmatter[key];
+    if (typeof raw === "string") {
+      const trimmed = raw.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return void 0;
+}
+function plainTextFromInlineHtml(html) {
+  const BLOCK = /* @__PURE__ */ new Set([
+    "p",
+    "div",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "blockquote",
+    "pre"
+  ]);
+  const walk = (nodes) => nodes.map((n) => {
+    if (n.type === "htmlText") return n.value;
+    if (n.type !== "htmlElement") return "";
+    const tag = n.tagName.toLowerCase();
+    if (tag === "br") return "\n";
+    const inner = walk(n.children);
+    return BLOCK.has(tag) ? `${inner}
+` : inner;
+  }).join("");
+  return walk(parseHtmlToNodes(html)).replace(/\u00A0/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+export {
+  parseHtmlToNodes,
+  stringifyHtmlNodes,
+  getChildren,
+  walkMarkdownTree,
+  findNodesByType,
+  extractPlainText,
+  countNodes,
+  parseFrontmatter,
+  formatBlockScalar,
+  formatFrontmatterValue,
+  formatFrontmatterYaml,
+  setFrontmatterValues,
+  createDocument,
+  inferDocumentTitle,
+  readFrontmatterThemeId,
+  plainTextFromInlineHtml
+};