@bendyline/squisq 2.11.12 → 2.11.14

package/dist/{chunk-XZVBR5BP.js → chunk-UVQPK6A3.js}

@@ -6,7 +6,9 @@ import {
 import {
   formatFrontmatterYaml,
   getChildren,
-  splitFrontmatterBlock
+  splitFrontmatterBlock,
+  stringifyHtmlNodes,
+  walkMarkdownTree
 } from "./chunk-X7BNDUNI.js";
 
 // src/markdown/stringify.ts
@@ -391,6 +393,103 @@ function tooLarge(maxBytes) {
   );
 }
 
+// src/markdown/condenseMarkdown.ts
+function cellSource(source) {
+  let text = trimPadding(source);
+  if (text.startsWith("|")) text = text.slice(1);
+  if (text.endsWith("|")) {
+    let backslashes = 0;
+    for (let i = text.length - 2; i >= 0 && text[i] === "\\"; i--) backslashes++;
+    if (backslashes % 2 === 0) text = text.slice(0, -1);
+  }
+  return trimPadding(text);
+}
+function trimPadding(source) {
+  let start = 0;
+  let end = source.length;
+  while (start < end && (source[start] === " " || source[start] === "	")) start++;
+  while (end > start && (source[end - 1] === " " || source[end - 1] === "	")) end--;
+  return source.slice(start, end);
+}
+function tableEdits(source, table) {
+  const edits = [];
+  for (const row of table.children) {
+    const start2 = row.position?.start.offset;
+    const end2 = row.position?.end.offset;
+    if (start2 === void 0 || end2 === void 0) throw new Error("Table row has no source span");
+    let boundary = start2;
+    const cells2 = [];
+    for (const cell of row.children) {
+      const a = cell.position?.start.offset;
+      const b = cell.position?.end.offset;
+      if (a !== boundary || b === void 0 || b < a) {
+        throw new Error("Table cell spans do not cover their row");
+      }
+      cells2.push(cellSource(source.slice(a, b)));
+      boundary = b;
+    }
+    if (boundary !== end2) throw new Error("Table cell spans do not cover their row");
+    edits.push({ start: start2, end: end2, text: `| ${cells2.join(" | ")} |` });
+  }
+  const headerEnd = table.children[0]?.position?.end.offset;
+  if (headerEnd === void 0) throw new Error("Table has no header span");
+  const start = source.indexOf("\n", headerEnd) + 1;
+  const newline = source.indexOf("\n", start);
+  let end = newline === -1 ? source.length : newline;
+  if (source[end - 1] === "\r") end--;
+  const divider = source.slice(start, end);
+  const prefix = /^[ \t>]*/.exec(divider)?.[0] ?? "";
+  if (start === 0 || !/^[|:\- \t]+$/.test(divider.slice(prefix.length))) {
+    throw new Error("Table has no recognizable delimiter row");
+  }
+  const columns = table.children[0]?.children.length ?? 0;
+  const cells = Array.from({ length: columns }, (_, i) => {
+    const align = table.align?.[i];
+    return `${align === "left" || align === "center" ? ":" : ""}---${align === "right" || align === "center" ? ":" : ""}`;
+  });
+  edits.push({ start: start + prefix.length, end, text: `| ${cells.join(" | ")} |` });
+  return edits;
+}
+function condenseMarkdownSource(source) {
+  const { frontmatter, body } = splitFrontmatterBlock(source);
+  const options = { frontmatter: false, parseHtml: false };
+  const document = parseMarkdown(body, options);
+  const edits = [];
+  const visit = (node) => {
+    if (node.type === "table") {
+      edits.push(...tableEdits(body, node));
+      return;
+    }
+    if (node.type === "thematicBreak") {
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start !== void 0 && end !== void 0) {
+        const marker = body.slice(start, end).match(/[-*_]/)?.[0];
+        if (marker) edits.push({ start, end, text: marker.repeat(3) });
+      }
+    }
+    for (const child of getChildren(node)) visit(child);
+  };
+  visit(document);
+  const parts = [];
+  let boundary = 0;
+  let changed = false;
+  for (const edit of edits.sort((a, b) => a.start - b.start)) {
+    if (edit.start < boundary) throw new Error("Overlapping Markdown condensation edits");
+    parts.push(body.slice(boundary, edit.start), edit.text);
+    changed || (changed = body.slice(edit.start, edit.end) !== edit.text);
+    boundary = edit.end;
+  }
+  if (!changed) return source;
+  parts.push(body.slice(boundary));
+  const output = parts.join("");
+  const withoutPositions = (key, value) => key === "position" ? void 0 : value;
+  if (JSON.stringify(document, withoutPositions) !== JSON.stringify(parseMarkdown(output, options), withoutPositions)) {
+    throw new Error("Condensed Markdown no longer parses to an equivalent document");
+  }
+  return (frontmatter ?? "") + output;
+}
+
 // src/markdown/sourceTransforms.ts
 var DEFAULT_WRAP_WIDTH = 80;
 var MIN_WRAP_WIDTH = 20;
@@ -859,6 +958,25 @@ ${cleanedBody}` : fm;
     edits: [{ start: 0, end: source.length, text: output }]
   };
 }
+function condenseTransform(source, options) {
+  try {
+    const output = condenseMarkdownSource(source);
+    if (output === source) return noopResult(source, false);
+    return {
+      output,
+      changed: true,
+      degraded: false,
+      edits: [{ start: 0, end: source.length, text: output }]
+    };
+  } catch (err) {
+    return degrade(
+      "condense",
+      source,
+      options?.strict,
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
 var MARKDOWN_SOURCE_TRANSFORMS = Object.freeze([
   {
     id: "unwrap",
@@ -877,6 +995,12 @@ var MARKDOWN_SOURCE_TRANSFORMS = Object.freeze([
     label: "Clean up formatting",
     description: "Re-serialize through the canonical house style: bullets, emphasis, headings, table padding, spacing.",
     apply: (source, options) => cleanupTransform(source, options)
+  },
+  {
+    id: "condense",
+    label: "Condense formatting",
+    description: "Compact table padding and decorative dividers while preserving all document content.",
+    apply: (source, options) => condenseTransform(source, options)
   }
 ]);
 function applyMarkdownSourceTransform(id, source, options) {
@@ -964,6 +1088,175 @@ function detectMarkdownWrapState(source) {
   };
 }
 
+// src/markdown/contentReferences.ts
+function rewriteMarkdownReferences(source, options = {}) {
+  const { frontmatter, body } = splitFrontmatterBlock(source);
+  const document = parseMarkdown(body, { frontmatter: false });
+  const html = (nodes, insidePicture = false) => {
+    let changed = false;
+    const output2 = nodes.flatMap((node) => {
+      if (node.type !== "htmlElement") return [node];
+      if (options.images === "omit" && node.tagName === "picture") {
+        changed = true;
+        return html(node.children, true).nodes;
+      }
+      if (options.images === "omit" && (node.tagName === "img" || node.tagName === "source" && insidePicture)) {
+        changed = true;
+        const alt = node.tagName === "img" ? node.attributes.alt : void 0;
+        return alt ? [
+          {
+            type: "htmlText",
+            value: alt.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+          }
+        ] : [];
+      }
+      const child = html(node.children);
+      changed || (changed = child.changed);
+      const copy = { ...node, attributes: { ...node.attributes }, children: child.nodes };
+      const key = node.tagName === "a" ? "href" : node.tagName === "img" ? "src" : void 0;
+      if (key && node.attributes[key]) {
+        const value = options.rewriteUrl?.(node.attributes[key], key === "href" ? "link" : "image");
+        if (value !== void 0 && value !== node.attributes[key]) {
+          copy.attributes[key] = value;
+          changed = true;
+        }
+      }
+      return [copy];
+    });
+    return { nodes: output2, changed };
+  };
+  const blocks = /* @__PURE__ */ new Set([
+    "heading",
+    "paragraph",
+    "blockquote",
+    "code",
+    "thematicBreak",
+    "list",
+    "table",
+    "htmlBlock",
+    "mathBlock",
+    "definition",
+    "footnoteDefinition",
+    "containerDirective",
+    "leafDirective",
+    "definitionList"
+  ]);
+  const structural = /* @__PURE__ */ new Set([
+    "listItem",
+    "tableRow",
+    "tableCell",
+    "definitionTerm",
+    "definitionDescription"
+  ]);
+  const render = (node) => {
+    if (node.type === "document") return stringifyMarkdown(node).trimEnd();
+    return stringifyMarkdown({
+      type: "document",
+      children: blocks.has(node.type) ? [node] : [{ type: "paragraph", children: [node] }]
+    }).trimEnd();
+  };
+  const visit = (node) => {
+    const children = getChildren(node).map(visit);
+    const childChanged = children.some((child) => child.changed);
+    let clone = childChanged && "children" in node ? { ...node, children: children.map((child) => child.node) } : node;
+    let ownChange = false;
+    if ((node.type === "image" || node.type === "imageReference") && options.images === "omit") {
+      clone = { type: "text", value: node.alt ?? "" };
+      ownChange = true;
+    } else if (node.type === "htmlBlock" || node.type === "htmlInline") {
+      const transformed = html(node.htmlChildren);
+      if (transformed.changed) {
+        clone = {
+          ...node,
+          htmlChildren: transformed.nodes,
+          rawHtml: stringifyHtmlNodes(transformed.nodes)
+        };
+        ownChange = true;
+      }
+    } else if (clone.type === "link" || clone.type === "image" || clone.type === "definition") {
+      const url = options.rewriteUrl?.(clone.url, clone.type === "image" ? "image" : "link");
+      if (url !== void 0 && url !== clone.url) {
+        clone = { ...clone, url };
+        ownChange = true;
+      }
+    }
+    const changed = ownChange || childChanged;
+    const pending = ownChange || children.some((child) => child.pending);
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (pending && start !== void 0 && end !== void 0 && !structural.has(node.type)) {
+      return { node: clone, changed, pending: false, edits: [{ start, end, text: render(clone) }] };
+    }
+    return { node: clone, changed, pending, edits: children.flatMap((child) => child.edits) };
+  };
+  const result = visit(document);
+  if (result.pending) throw new Error("Reference edit has no positioned ancestor");
+  const edits = result.edits;
+  let output = body;
+  let boundary = body.length;
+  for (const e of edits.sort((a, b) => b.start - a.start)) {
+    if (e.end > boundary) throw new Error("Overlapping reference edits");
+    output = output.slice(0, e.start) + e.text + output.slice(e.end);
+    boundary = e.start;
+  }
+  return (frontmatter ?? "") + output;
+}
+
+// src/markdown/docfxMarkdown.ts
+function normalizeDocfxMarkdown(source, options = {}) {
+  const { frontmatter, body } = splitFrontmatterBlock(source);
+  const protectedSpans = [];
+  for (const comment of body.matchAll(/<!--[\s\S]*?-->/g))
+    protectedSpans.push([comment.index, comment.index + comment[0].length]);
+  walkMarkdownTree(parseMarkdown(body, { frontmatter: false }), (node) => {
+    if ((node.type === "code" || node.type === "inlineCode") && node.position?.start.offset !== void 0 && node.position.end.offset !== void 0)
+      protectedSpans.push([node.position.start.offset, node.position.end.offset]);
+  });
+  const escape = (text) => stringifyMarkdown({
+    type: "document",
+    children: [{ type: "paragraph", children: [{ type: "text", value: text }] }]
+  }).trimEnd();
+  const output = body.replace(
+    /(^[^\S\n]*(?:>\s*)?):::\s*([\w-]+)([^\n]*?)(?=\r?$)|(^[^\S\n]*>\s*)\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION|div)\b([^\]]*)\]|:::\s*(image)\b([^\n]*?):::/gim,
+    (match, prefix, name, raw, quote, admonition, _extra, inlineName, inlineRaw, offset) => {
+      if (protectedSpans.some(([start, end]) => offset >= start && offset < end)) return match;
+      if (admonition)
+        return admonition.toLowerCase() === "div" ? quote ?? "" : `${quote}**${admonition[0] + admonition.slice(1).toLowerCase()}:**`;
+      name ?? (name = inlineName);
+      raw ?? (raw = inlineRaw);
+      const attributes = /* @__PURE__ */ new Map();
+      for (const attr of (raw ?? "").matchAll(/([\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g))
+        attributes.set(attr[1], attr[2] ?? attr[3]);
+      switch (name?.toLowerCase()) {
+        case "image": {
+          const alt = attributes.get("alt-text") ?? "";
+          const url = attributes.get("source");
+          if (options.images === "omit") return `${prefix ?? ""}${escape(alt)}`;
+          if (!url) throw new Error("DocFX image has no source");
+          const image = stringifyMarkdown({
+            type: "document",
+            children: [{ type: "paragraph", children: [{ type: "image", url, alt }] }]
+          }).trimEnd();
+          return `${prefix ?? ""}${image}`;
+        }
+        case "zone":
+          return attributes.has("pivot") ? `${prefix ?? ""}**Applies to: ${escape(attributes.get("pivot"))}**
+` : "";
+        case "zone-end":
+        case "image-end":
+        case "row":
+        case "row-end":
+        case "column":
+        case "column-end":
+          return "";
+        default:
+          throw new Error(`Unsupported DocFX directive: ${name}`);
+      }
+    }
+  );
+  return (frontmatter ?? "") + output;
+}
+
 export {
   stringifyMarkdown,
   DEFAULT_RESOURCE_MAX_BYTES,
@@ -973,11 +1266,14 @@ export {
   ResourcePolicyError,
   isResourceUrlAllowed,
   fetchResourceBytes,
+  condenseMarkdownSource,
   DEFAULT_WRAP_WIDTH,
   MARKDOWN_SOURCE_TRANSFORMS,
   applyMarkdownSourceTransform,
   unwrapMarkdownSource,
   wrapMarkdownSource,
   cleanupMarkdownSource,
-  detectMarkdownWrapState
+  detectMarkdownWrapState,
+  rewriteMarkdownReferences,
+  normalizeDocfxMarkdown
 };

package/dist/{chunk-GIYWXYCK.js → chunk-XSOIWNZL.js}

@@ -348,6 +348,8 @@ function createMediaProviderFromContainer(container) {
     const generation = generations.get(relativePath) ?? 0;
     const work = (async () => {
       const data = await container.readFile(relativePath);
+      if (disposed) return relativePath;
+      if ((generations.get(relativePath) ?? 0) !== generation) return resolveUrl(relativePath);
       const entries = data ? await container.listFiles() : [];
       if (disposed) return relativePath;
       if ((generations.get(relativePath) ?? 0) !== generation) return resolveUrl(relativePath);
@@ -376,6 +378,7 @@ function createMediaProviderFromContainer(container) {
     },
     async addMedia(name, data, mimeType) {
       invalidate(name);
+      const generation = generations.get(name);
       let buffer;
       if (data instanceof Blob) {
         buffer = await data.arrayBuffer();
@@ -383,7 +386,12 @@ function createMediaProviderFromContainer(container) {
         buffer = data;
       }
       await container.writeFile(name, buffer, mimeType);
+      const canCacheUpload = generations.get(name) === generation;
       invalidate(name);
+      if (!disposed && canCacheUpload) {
+        const bytes = ArrayBuffer.isView(buffer) ? new Uint8Array(buffer).slice().buffer : buffer;
+        blobUrlCache.set(name, URL.createObjectURL(new Blob([bytes], { type: mimeType })));
+      }
       return name;
     },
     async removeMedia(relativePath) {