@bendyline/squisq 2.11.15 → 2.11.17

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

@@ -2,14 +2,14 @@ import {
   assertMarkdownDocumentWithinLimits,
   parseMarkdown,
   toMdast
-} from "./chunk-HUXK7EOT.js";
+} from "./chunk-PGWYC3S2.js";
 import {
   formatFrontmatterYaml,
   getChildren,
   splitFrontmatterBlock,
   stringifyHtmlNodes,
   walkMarkdownTree
-} from "./chunk-X7BNDUNI.js";
+} from "./chunk-Q6ELOAOQ.js";
 
 // src/markdown/stringify.ts
 import { unified } from "unified";
@@ -21,17 +21,41 @@ var defaultProcessor;
 var DQ_RUN = `"(?:[^"\\\\]|\\\\.)*"`;
 var SQ_RUN = `'(?:[^'\\\\]|\\\\.)*'`;
 var ESCAPED_TEMPLATE_SPAN_RE = new RegExp(
-  `\\{\\\\\\[((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^\\]\\\\])*)\\]\\}`,
+  `\\{\\\\\\[((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^\\]\\\\"'])*)\\]\\}`,
   "g"
 );
 var HEADING_LINE_RE = /^#{1,6} .*$/gm;
 var TRAILING_ESCAPED_PANDOC_SPAN_RE = new RegExp(
-  `\\{(?!\\\\?\\[)((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^}\\\\])*)\\}(?=\\s*(?:\\{\\[.*)?$)`
+  `\\{(?!\\\\?\\[)((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^}\\\\"'])*)\\}(?=\\s*(?:\\{\\[.*)?$)`
 );
 var UNESCAPE_PUNCT_RE = /\\([\\[\]:#.,+=/?;@%$(){}'"-])/g;
 function unescapeMarkdownPunct(text) {
   return text.replace(UNESCAPE_PUNCT_RE, "$1");
 }
+function literalTextUnsafe(options) {
+  return [
+    // GFM's writer only guards lowercase protocol endings, while its parser
+    // recognizes uppercase ones. Escape the colon before the domain dot can
+    // become a literal backslash inside an automatically recognized URL.
+    ...options?.gfm === false ? [] : [
+      {
+        character: ":",
+        before: "[PS]",
+        after: "\\/",
+        inConstruct: "phrasing",
+        notInConstruct: [
+          "autolink",
+          "link",
+          "image",
+          "label"
+        ]
+      }
+    ],
+    { character: "\\", after: "[ 	]", inConstruct: "phrasing" },
+    ...options?.math === false ? [] : [{ character: "$", inConstruct: "phrasing" }],
+    ...options?.directive === false ? [] : [{ character: ":", after: "[A-Za-z]", inConstruct: "phrasing" }]
+  ];
+}
 var PREFERRED_MASK_SENTINEL = "\0";
 function pickMaskSentinel(text) {
   const present = new Set(text);
@@ -154,7 +178,8 @@ function stringifyMarkdown(doc, options) {
         strong: "*",
         rule: "-",
         fence: "`",
-        setext: false
+        setext: false,
+        unsafe: literalTextUnsafe()
       });
     }
     processor = defaultProcessor;
@@ -176,7 +201,8 @@ function stringifyMarkdown(doc, options) {
       strong: options?.strong ?? "*",
       rule: options?.rule ?? "-",
       fence: options?.fence ?? "`",
-      setext: options?.setext ?? false
+      setext: options?.setext ?? false,
+      unsafe: literalTextUnsafe(options)
     });
   }
   const result = processor.stringify(mdastTree);
@@ -1204,11 +1230,22 @@ function rewriteMarkdownReferences(source, options = {}) {
 
 // src/markdown/docfxMarkdown.ts
 function normalizeDocfxMarkdown(source, options = {}) {
-  const { frontmatter, body } = splitFrontmatterBlock(source);
+  let output = normalizeDocfxMarkdownPass(source, options);
+  if (options.unknownDirectives === "preserve") {
+    for (let pass = 0; pass < 2 && output !== source && /:::/u.test(output); pass++) {
+      source = output;
+      output = normalizeDocfxMarkdownPass(source, options);
+    }
+  }
+  return output;
+}
+function normalizeDocfxMarkdownPass(source, options = {}) {
+  const { frontmatter, body: originalBody } = splitFrontmatterBlock(source);
+  const body = flattenDocfxLayout(originalBody);
   const protectedSpans = [];
-  for (const comment of body.matchAll(/<!--[\s\S]*?-->/g))
+  for (const comment of body.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
     protectedSpans.push([comment.index, comment.index + comment[0].length]);
-  walkMarkdownTree(parseMarkdown(body, { frontmatter: false }), (node) => {
+  walkMarkdownTree(parseMarkdown(body, { frontmatter: false, directive: 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]);
   });
@@ -1216,8 +1253,8 @@ function normalizeDocfxMarkdown(source, options = {}) {
     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,
+  let output = body.replace(
+    /(^[^\S\n]*(?:>\s*)?):::\s*([\w-]+)([^\n]*?)(?=\r?$)|(^[^\S\n]*>\s*)\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION|div)\b([^\]]*)\]|:::\s*(image|no-loc)\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)
@@ -1239,6 +1276,16 @@ function normalizeDocfxMarkdown(source, options = {}) {
           }).trimEnd();
           return `${prefix ?? ""}${image}`;
         }
+        case "code":
+          if (options.reference && attributes.has("source"))
+            return (prefix ?? "") + options.reference("code", attributes.get("source"), raw?.trim() ?? "Code example");
+          throw new Error("Unsupported DocFX code without a source reference resolver");
+        case "no-loc":
+          return (prefix ?? "") + escape(attributes.get("text") ?? "");
+        case "moniker":
+          return (prefix ?? "") + "**Applies to: " + escape(attributes.get("range") ?? raw?.trim() ?? "") + "**";
+        case "moniker-end":
+          return "";
         case "zone":
           return attributes.has("pivot") ? `${prefix ?? ""}**Applies to: ${escape(attributes.get("pivot"))}**
 ` : "";
@@ -1250,12 +1297,100 @@ function normalizeDocfxMarkdown(source, options = {}) {
         case "column-end":
           return "";
         default:
+          if (options.unknownDirectives === "preserve") {
+            const fence = "`".repeat(
+              Math.max(1, ...Array.from(match.matchAll(/`+/g), (m) => m[0].length + 1))
+            );
+            return `${prefix ?? ""}${fence}${match.trim()}${fence}`;
+          }
           throw new Error(`Unsupported DocFX directive: ${name}`);
       }
     }
   );
+  if (options.reference) {
+    const spans = [];
+    for (const comment of output.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
+      spans.push([comment.index, comment.index + comment[0].length]);
+    walkMarkdownTree(parseMarkdown(output, { frontmatter: false, directive: false }), (node) => {
+      if ((node.type === "code" || node.type === "inlineCode") && node.position)
+        spans.push([node.position.start.offset, node.position.end.offset]);
+    });
+    output = output.replace(
+      /\[!code-[\w-]+\s*\[([^\]]*)\]\(([^)\n]+)\)\]|<xref:([^>\n]+)>/gi,
+      (match, label, target, uid, offset) => {
+        if (spans.some(([start, end]) => offset >= start && offset < end)) return match;
+        return uid ? options.reference("xref", uid, uid.split("?")[0]) : options.reference("code", target, label || "Code example");
+      }
+    );
+  }
+  if (options.unknownDirectives === "preserve" && /\[!code-|\[!INCLUDE\b|<xref:/i.test(output)) {
+    const spans = [];
+    for (const comment of output.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
+      spans.push([comment.index, comment.index + comment[0].length]);
+    walkMarkdownTree(parseMarkdown(output, { frontmatter: false, directive: false }), (node) => {
+      if ((node.type === "code" || node.type === "inlineCode") && node.position)
+        spans.push([node.position.start.offset, node.position.end.offset]);
+    });
+    output = output.replace(
+      /\[!code-[^\n]*|\[!INCLUDE[^\n]*|<xref:[^\n]*/gi,
+      (match, offset) => {
+        if (spans.some(([start, end]) => offset >= start && offset < end)) return match;
+        options.onPreservedReference?.(match);
+        const fence = String.fromCharCode(96).repeat(
+          Math.max(1, ...Array.from(match.matchAll(/\x60+/g), (m) => m[0].length + 1))
+        );
+        return fence + " " + match + " " + fence;
+      }
+    );
+  }
+  if (options.frontmatterAsCode && frontmatter) {
+    const fence = "`".repeat(
+      Math.max(3, ...Array.from(frontmatter.matchAll(/`+/g), (m) => m[0].length + 1))
+    );
+    return output + "\n\n## Original source metadata\n\n" + fence + "text\n" + frontmatter.trimEnd() + "\n" + fence + "\n";
+  }
   return (frontmatter ?? "") + output;
 }
+function flattenDocfxLayout(source) {
+  const stack = [];
+  let fence;
+  let comment = false;
+  return source.split("\n").map((line) => {
+    const column = [...stack].reverse().find((entry) => entry.kind === "column");
+    const margin = column ? column.indent + 4 : 0;
+    const indent = /^ */.exec(line)[0].length;
+    const content = line.slice(Math.min(indent, margin));
+    const boundary = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(content);
+    if (fence) {
+      if (boundary && boundary[1][0] === fence.character && boundary[1].length >= fence.length && !boundary[2].trim())
+        fence = void 0;
+      return content;
+    }
+    const commented = comment || line.includes("<!--");
+    const opening = line.lastIndexOf("<!--");
+    const closing = line.lastIndexOf("-->");
+    if (opening > closing) comment = true;
+    else if (closing >= 0) comment = false;
+    if (commented) return content;
+    if (boundary) {
+      fence = { character: boundary[1][0], length: boundary[1].length };
+      return content;
+    }
+    const marker = /^ *:::(row|column)(-end)?(?=\s|:|$)[^\n]*$/i.exec(line);
+    if (!marker || !stack.length && indent > 3) return content;
+    const kind = marker[1].toLowerCase();
+    if (marker[2]) {
+      const index = stack.map((entry) => entry.kind).lastIndexOf(kind);
+      if (index < 0) return content;
+      stack.splice(index);
+    } else {
+      if (stack.length >= 128)
+        throw new Error("DocFX layout exceeds the 128-level nesting safety limit");
+      stack.push({ kind, indent });
+    }
+    return "";
+  }).join("\n");
+}
 
 export {
   stringifyMarkdown,

package/dist/{chunk-GQWIUBJU.js → chunk-MY46W5O5.js}

@@ -7,10 +7,10 @@ import {
   buildNarrationScript,
   expectedSyllablesAt,
   wordPosAtExpectedSyllables
-} from "./chunk-Z35TG4WR.js";
+} from "./chunk-PNXBDMNS.js";
 import {
   flattenRenderableBlocks
-} from "./chunk-YPI2VJSB.js";
+} from "./chunk-L7IIFWWW.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({

package/dist/{chunk-HUXK7EOT.js → chunk-PGWYC3S2.js}

@@ -6,11 +6,11 @@ import {
   quoteAttrValue,
   splitKeyValueToken,
   tokenizeAttrTokens
-} from "./chunk-TMOHAFYE.js";
+} from "./chunk-WSFXV5BT.js";
 import {
   parseFrontmatter,
   parseHtmlToNodes
-} from "./chunk-X7BNDUNI.js";
+} from "./chunk-Q6ELOAOQ.js";
 import {
   resolveIcon
 } from "./chunk-7N4G32LG.js";
@@ -1181,6 +1181,95 @@ import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
 import remarkDirective from "remark-directive";
 import remarkFrontmatter from "remark-frontmatter";
+
+// src/markdown/dollarMath.ts
+var DOLLAR_SIGN = 36;
+var DIGIT_ZERO = 48;
+var DIGIT_NINE = 57;
+function isWhitespace(code) {
+  if (code === null) return false;
+  return code < 0 || /\s/u.test(String.fromCodePoint(code));
+}
+function isAsciiDigit(code) {
+  return code !== null && code >= DIGIT_ZERO && code <= DIGIT_NINE;
+}
+var dollarMathSpan = {
+  name: "squisqDollarMathSpan",
+  partial: true,
+  tokenize(effects, ok, nok) {
+    let previousWasWhitespace = false;
+    let closingRunLength = 0;
+    return open;
+    function open(code) {
+      effects.enter("squisqDollarMathProbe");
+      effects.consume(code);
+      return afterOpen;
+    }
+    function afterOpen(code) {
+      if (code === DOLLAR_SIGN) return succeed(code);
+      if (code === null || isWhitespace(code)) return fail(code);
+      return inside(code);
+    }
+    function inside(code) {
+      if (code === null) return fail(code);
+      if (code === DOLLAR_SIGN) {
+        closingRunLength = 0;
+        return closingRun(code);
+      }
+      previousWasWhitespace = isWhitespace(code);
+      effects.consume(code);
+      return inside;
+    }
+    function closingRun(code) {
+      if (code === DOLLAR_SIGN) {
+        closingRunLength++;
+        effects.consume(code);
+        return closingRun;
+      }
+      if (closingRunLength !== 1) {
+        previousWasWhitespace = false;
+        return inside(code);
+      }
+      if (previousWasWhitespace || isAsciiDigit(code)) return fail(code);
+      return succeed(code);
+    }
+    function succeed(code) {
+      effects.exit("squisqDollarMathProbe");
+      return ok(code);
+    }
+    function fail(code) {
+      effects.exit("squisqDollarMathProbe");
+      return nok(code);
+    }
+  }
+};
+function previousIsNotUnescapedDollar(code) {
+  return code !== DOLLAR_SIGN || this.events[this.events.length - 1]?.[1].type === "characterEscape";
+}
+var dollarTextGuard = {
+  name: "squisqDollarTextGuard",
+  add: "before",
+  previous: previousIsNotUnescapedDollar,
+  tokenize(effects, ok, nok) {
+    return start;
+    function start(code) {
+      return effects.check(dollarMathSpan, nok, literalDollar)(code);
+    }
+    function literalDollar(code) {
+      effects.enter("data");
+      effects.consume(code);
+      effects.exit("data");
+      return ok;
+    }
+  }
+};
+function remarkDollarMathRules() {
+  const data = this.data();
+  const extensions = data.micromarkExtensions ?? (data.micromarkExtensions = []);
+  extensions.push({ text: { [DOLLAR_SIGN]: dollarTextGuard } });
+}
+
+// src/markdown/parse.ts
 var defaultProcessor;
 function parseMarkdown(markdown, options) {
   options?.signal?.throwIfAborted();
@@ -1189,7 +1278,7 @@ function parseMarkdown(markdown, options) {
   let processor;
   if (useDefaults) {
     if (!defaultProcessor) {
-      defaultProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkDirective).use(remarkFrontmatter, ["yaml"]);
+      defaultProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkDollarMathRules).use(remarkDirective).use(remarkFrontmatter, ["yaml"]);
     }
     processor = defaultProcessor;
   } else {
@@ -1198,7 +1287,7 @@ function parseMarkdown(markdown, options) {
       processor = processor.use(remarkGfm);
     }
     if (options?.math !== false) {
-      processor = processor.use(remarkMath);
+      processor = processor.use(remarkMath).use(remarkDollarMathRules);
     }
     if (options?.directive !== false) {
       processor = processor.use(remarkDirective);

package/dist/{chunk-Z35TG4WR.js → chunk-PNXBDMNS.js}

@@ -1,7 +1,7 @@
 import {
   flattenRenderableBlocks,
   getBlockBodyText
-} from "./chunk-YPI2VJSB.js";
+} from "./chunk-L7IIFWWW.js";
 import {
   estimateSpokenWordCount
 } from "./chunk-GHOPHGOK.js";