@bendyline/squisq 2.3.2 → 2.4.0

package/dist/chunk-ZYO3DBTA.js

@@ -0,0 +1,983 @@
+import {
+  assertMarkdownDocumentWithinLimits,
+  parseMarkdown,
+  toMdast
+} from "./chunk-D4LPP3P5.js";
+import {
+  formatFrontmatterYaml,
+  getChildren,
+  splitFrontmatterBlock
+} from "./chunk-O7JILDEF.js";
+
+// src/markdown/stringify.ts
+import { unified } from "unified";
+import remarkStringify from "remark-stringify";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkDirective from "remark-directive";
+var defaultProcessor;
+var DQ_RUN = `"(?:[^"\\\\]|\\\\.)*"`;
+var SQ_RUN = `'(?:[^'\\\\]|\\\\.)*'`;
+var ESCAPED_TEMPLATE_SPAN_RE = new RegExp(
+  `\\{\\\\\\[((?:${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*(?:\\{\\[.*)?$)`
+);
+var UNESCAPE_PUNCT_RE = /\\([\\[\]:#.,+=/?;@%$(){}'"-])/g;
+function unescapeMarkdownPunct(text) {
+  return text.replace(UNESCAPE_PUNCT_RE, "$1");
+}
+var PREFERRED_MASK_SENTINEL = "\0";
+function pickMaskSentinel(text) {
+  const present = new Set(text);
+  if (!present.has(PREFERRED_MASK_SENTINEL)) return PREFERRED_MASK_SENTINEL;
+  for (let cp = 57344; cp <= 63743; cp++) {
+    const ch = String.fromCodePoint(cp);
+    if (!present.has(ch)) return ch;
+  }
+  return null;
+}
+var FENCE_OPEN_RE = /^([ \t]*)(`{3,}|~{3,})(.*)$/;
+function findFencedRanges(text) {
+  const ranges = [];
+  let offset = 0;
+  let open = null;
+  for (const line of text.split("\n")) {
+    const lineEnd = offset + line.length;
+    if (open) {
+      const close = /^([ \t]*)(`{3,}|~{3,})[ \t]*$/.exec(line);
+      if (close && close[2][0] === open.marker && close[2].length >= open.length && close[1].length <= open.indent + 3) {
+        ranges.push([open.start, lineEnd]);
+        open = null;
+      }
+    } else {
+      const match = FENCE_OPEN_RE.exec(line);
+      if (match && !(match[2][0] === "`" && match[3].includes("`"))) {
+        open = {
+          marker: match[2][0],
+          length: match[2].length,
+          indent: match[1].length,
+          start: offset
+        };
+      }
+    }
+    offset = lineEnd + 1;
+  }
+  if (open) ranges.push([open.start, text.length]);
+  return ranges;
+}
+function isEscapedAt(text, i) {
+  let slashes = 0;
+  for (let k = i - 1; k >= 0 && text[k] === "\\"; k--) slashes++;
+  return slashes % 2 === 1;
+}
+function findInlineCodeRanges(text, from, to) {
+  const ranges = [];
+  let i = from;
+  while (i < to) {
+    if (text[i] !== "`" || isEscapedAt(text, i)) {
+      i++;
+      continue;
+    }
+    let openEnd = i;
+    while (openEnd < to && text[openEnd] === "`") openEnd++;
+    const runLength = openEnd - i;
+    let j = openEnd;
+    let closed = -1;
+    while (j < to) {
+      if (text[j] !== "`") {
+        j++;
+        continue;
+      }
+      let runEnd = j;
+      while (runEnd < to && text[runEnd] === "`") runEnd++;
+      if (runEnd - j === runLength) {
+        closed = runEnd;
+        break;
+      }
+      j = runEnd;
+    }
+    if (closed === -1) {
+      i = openEnd;
+      continue;
+    }
+    ranges.push([i, closed]);
+    i = closed;
+  }
+  return ranges;
+}
+function transformOutsideCode(text, transform) {
+  const fenced = findFencedRanges(text);
+  const ranges = [];
+  let cursor = 0;
+  for (const [start, end] of fenced) {
+    ranges.push(...findInlineCodeRanges(text, cursor, start));
+    ranges.push([start, end]);
+    cursor = end;
+  }
+  ranges.push(...findInlineCodeRanges(text, cursor, text.length));
+  if (ranges.length === 0) return transform(text);
+  const sentinel = pickMaskSentinel(text);
+  if (sentinel === null) return text;
+  const protectedText = [];
+  let masked = "";
+  let last = 0;
+  for (const [start, end] of ranges) {
+    masked += text.slice(last, start);
+    masked += `${sentinel}${protectedText.length}${sentinel}`;
+    protectedText.push(text.slice(start, end));
+    last = end;
+  }
+  masked += text.slice(last);
+  return transform(masked).replace(
+    new RegExp(`${sentinel}(\\d+)${sentinel}`, "g"),
+    (_m, index) => protectedText[Number(index)]
+  );
+}
+function stringifyMarkdown(doc, options) {
+  options?.signal?.throwIfAborted();
+  assertMarkdownDocumentWithinLimits(doc, options?.limits, options?.signal);
+  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 (!defaultProcessor) {
+      defaultProcessor = unified().use(remarkGfm).use(remarkMath).use(remarkDirective).use(remarkStringify, {
+        bullet: "-",
+        bulletOrdered: ".",
+        emphasis: "*",
+        strong: "*",
+        rule: "-",
+        fence: "`",
+        setext: false
+      });
+    }
+    processor = defaultProcessor;
+  } else {
+    processor = unified();
+    if (options?.gfm !== false) {
+      processor = processor.use(remarkGfm);
+    }
+    if (options?.math !== false) {
+      processor = processor.use(remarkMath);
+    }
+    if (options?.directive !== false) {
+      processor = processor.use(remarkDirective);
+    }
+    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 = transformOutsideCode(result, (text) => {
+    let out = text.replace(
+      ESCAPED_TEMPLATE_SPAN_RE,
+      (_m, inner) => `{[${unescapeMarkdownPunct(inner)}]}`
+    );
+    out = out.replace(
+      HEADING_LINE_RE,
+      (line) => line.replace(
+        TRAILING_ESCAPED_PANDOC_SPAN_RE,
+        (_m, inner) => `{${unescapeMarkdownPunct(inner)}}`
+      )
+    );
+    return out.replace(/\{(?!\\?\[)[^}]*\}/g, (match) => match.replace(/\\:/g, ":"));
+  });
+  if (doc.frontmatter && Object.keys(doc.frontmatter).length > 0) {
+    const yaml = formatFrontmatterYaml(doc.frontmatter);
+    if (yaml) return `---
+${yaml}
+---
+
+${cleaned}`;
+  }
+  return cleaned;
+}
+
+// src/markdown/resourcePolicy.ts
+var DEFAULT_RESOURCE_MAX_BYTES = 64 * 1024 * 1024;
+var DEFAULT_RESOURCE_TIMEOUT_MS = 15e3;
+var DEFAULT_INTERACTIVE_RESOURCE_POLICY = Object.freeze({
+  allowRemote: true,
+  allowRelative: true,
+  allowBlob: true,
+  allowData: true,
+  allowedHosts: Object.freeze([]),
+  maxBytes: DEFAULT_RESOURCE_MAX_BYTES,
+  timeoutMs: DEFAULT_RESOURCE_TIMEOUT_MS
+});
+var LOCAL_ONLY_RESOURCE_POLICY = Object.freeze({
+  allowRemote: false,
+  allowRelative: true,
+  allowBlob: true,
+  allowData: true,
+  allowedHosts: Object.freeze([]),
+  maxBytes: DEFAULT_RESOURCE_MAX_BYTES,
+  timeoutMs: DEFAULT_RESOURCE_TIMEOUT_MS
+});
+var ResourcePolicyError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "ResourcePolicyError";
+    this.code = code;
+  }
+};
+function isResourceUrlAllowed(input, policy = DEFAULT_INTERACTIVE_RESOURCE_POLICY) {
+  if (typeof input !== "string") return false;
+  const value = input.trim();
+  if (!value || hasUrlControlCharacters(value)) return false;
+  const resolved = resolvePolicy(policy);
+  if (value.startsWith("\\\\")) return false;
+  if (value.startsWith("//")) {
+    if (!resolved.allowRemote) return false;
+    return hostAllowed(parseUrl(`https:${value}`), resolved.allowedHosts);
+  }
+  const schemeMatch = /^([a-z][a-z0-9+.-]*):/i.exec(value);
+  if (!schemeMatch) return resolved.allowRelative;
+  const scheme = schemeMatch[1].toLowerCase();
+  if (scheme === "blob") return resolved.allowBlob;
+  if (scheme === "data") return resolved.allowData && isSafeMediaDataUrl(value);
+  if (scheme !== "http" && scheme !== "https") return false;
+  if (!resolved.allowRemote) return false;
+  return hostAllowed(parseUrl(value), resolved.allowedHosts);
+}
+async function fetchResourceBytes(input, options = {}) {
+  const policy = resolvePolicy(options.policy);
+  if (!isResourceUrlAllowed(input, policy)) {
+    throw new ResourcePolicyError(
+      "RESOURCE_BLOCKED",
+      `Resource URL is blocked by policy: ${input}`
+    );
+  }
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetchResourceBytes requires a fetch implementation");
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort(options.signal?.reason);
+  if (options.signal?.aborted) onAbort();
+  else options.signal?.addEventListener("abort", onAbort, { once: true });
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, policy.timeoutMs);
+  try {
+    const response = await fetchImpl(input, {
+      signal: controller.signal,
+      credentials: "omit",
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    });
+    if (!response.ok) throw new Error(`Resource request failed with HTTP ${response.status}`);
+    const finalUrl = response.url || input;
+    if (!isResourceUrlAllowed(finalUrl, policy)) {
+      throw new ResourcePolicyError(
+        "RESOURCE_BLOCKED",
+        `Resource redirect destination is blocked by policy: ${finalUrl}`
+      );
+    }
+    const contentType = response.headers?.get?.("content-type")?.split(";", 1)[0].trim() ?? "";
+    if (contentType && options.contentTypePrefixes?.length && !options.contentTypePrefixes.some((prefix) => contentType.toLowerCase().startsWith(prefix))) {
+      throw new ResourcePolicyError(
+        "RESOURCE_BLOCKED",
+        `Resource Content-Type is not allowed: ${contentType || "(missing)"}`
+      );
+    }
+    const declaredLength = Number(response.headers?.get?.("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > policy.maxBytes) {
+      throw tooLarge(policy.maxBytes);
+    }
+    const bytes = await readResponseBounded(response, policy.maxBytes, controller.signal);
+    return { bytes, contentType, finalUrl };
+  } catch (error) {
+    if (timedOut) {
+      throw new ResourcePolicyError(
+        "RESOURCE_TIMEOUT",
+        `Resource request exceeded ${policy.timeoutMs} ms`
+      );
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}
+function resolvePolicy(policy) {
+  return {
+    ...DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+    ...policy,
+    allowedHosts: policy?.allowedHosts ?? DEFAULT_INTERACTIVE_RESOURCE_POLICY.allowedHosts
+  };
+}
+function parseUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return null;
+  }
+}
+function hostAllowed(url, allowedHosts) {
+  if (!url || url.username || url.password) return false;
+  if (allowedHosts.length === 0) return true;
+  const host = url.hostname.toLowerCase().replace(/\.$/, "");
+  return allowedHosts.some((entry) => {
+    const allowed = entry.trim().toLowerCase().replace(/\.$/, "");
+    if (allowed.startsWith("*.")) {
+      const suffix = allowed.slice(2);
+      return host !== suffix && host.endsWith(`.${suffix}`);
+    }
+    return host === allowed;
+  });
+}
+function isSafeMediaDataUrl(value) {
+  return /^data:(?:image\/(?!svg\+xml)[a-z0-9.+-]+|audio\/[a-z0-9.+-]+|video\/[a-z0-9.+-]+);/i.test(
+    value
+  );
+}
+function hasUrlControlCharacters(value) {
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+async function readResponseBounded(response, maxBytes, signal) {
+  if (!response.body) {
+    const buffer = response.arrayBuffer ? await response.arrayBuffer() : await (await response.blob()).arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    if (bytes.byteLength > maxBytes) throw tooLarge(maxBytes);
+    return bytes;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw tooLarge(maxBytes);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+function tooLarge(maxBytes) {
+  return new ResourcePolicyError(
+    "RESOURCE_TOO_LARGE",
+    `Resource exceeds the ${maxBytes}-byte policy limit`
+  );
+}
+
+// src/markdown/sourceTransforms.ts
+var DEFAULT_WRAP_WIDTH = 80;
+var MIN_WRAP_WIDTH = 20;
+var MAX_WRAP_WIDTH = 500;
+var COMMON_WRAP_WIDTHS = [60, 72, 80, 100, 120];
+var WIDTH_SNAP_TOLERANCE = 8;
+var MIN_DETECTED_WRAP_WIDTH = 40;
+var SANE_PREFIX_RE = /^[ \t>]*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+)*(?:\[\^[^\]]+\]:[ \t]+)?(?:\[[ xX]\][ \t]+)?$/;
+var CONTINUATION_PREFIX_RE = /^[ \t]*(?:>[ \t]*)*/;
+var ANNOTATION_SPAN_RE = /\{\[(?:"(?:[^"\\\n]|\\[^\n])*"|'(?:[^'\\\n]|\\[^\n])*'|\\[^\n]|[^\]\\\n])*\]\}/g;
+function nodeSpan(node) {
+  const position = node.position;
+  if (!position || position.start.offset == null || position.end.offset == null) return null;
+  return { start: position.start.offset, end: position.end.offset };
+}
+function mergeSpans(spans) {
+  const sorted = [...spans].sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const span of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && span.start <= last.end) {
+      last.end = Math.max(last.end, span.end);
+    } else {
+      merged.push({ ...span });
+    }
+  }
+  return merged;
+}
+function clipSpan(span, start, end) {
+  const s = Math.max(span.start, start);
+  const e = Math.min(span.end, end);
+  return s < e ? { start: s, end: e } : null;
+}
+function collectInlineSpans(source, paragraph, info) {
+  const immovable = [];
+  const unbreakable = [];
+  const visit = (node) => {
+    const span = nodeSpan(node);
+    switch (node.type) {
+      case "break":
+        if (span) info.breakSpans.push(span);
+        return;
+      case "inlineCode":
+      case "inlineMath":
+      case "htmlInline":
+      case "image":
+        if (span) immovable.push(span);
+        return;
+      case "link": {
+        if (span) {
+          const children = getChildren(node);
+          let segStart = span.start;
+          for (const child of children) {
+            const childSpan = nodeSpan(child);
+            if (childSpan) segStart = Math.max(segStart, childSpan.end);
+          }
+          if (segStart < span.end) immovable.push({ start: segStart, end: span.end });
+        }
+        break;
+      }
+      case "mention": {
+        if (span) {
+          const start = span.start > 0 && source[span.start - 1] === "@" ? span.start - 1 : span.start;
+          unbreakable.push({ start, end: span.end });
+        }
+        return;
+      }
+      case "textDirective":
+        if (span) unbreakable.push(span);
+        return;
+      case "inlineIcon":
+        return;
+      default:
+        break;
+    }
+    for (const child of getChildren(node)) visit(child);
+  };
+  for (const child of getChildren(paragraph)) visit(child);
+  const slice = source.slice(info.start, info.end);
+  ANNOTATION_SPAN_RE.lastIndex = 0;
+  let match;
+  while ((match = ANNOTATION_SPAN_RE.exec(slice)) !== null) {
+    unbreakable.push({
+      start: info.start + match.index,
+      end: info.start + match.index + match[0].length
+    });
+  }
+  const clippedImmovable = [];
+  for (const span of immovable) {
+    const clipped = clipSpan(span, info.start, info.end);
+    if (clipped) clippedImmovable.push(clipped);
+  }
+  const clippedUnbreakable = [...clippedImmovable];
+  for (const span of unbreakable) {
+    const clipped = clipSpan(span, info.start, info.end);
+    if (clipped) clippedUnbreakable.push(clipped);
+  }
+  info.immovableSpans = mergeSpans(clippedImmovable);
+  info.unbreakableSpans = mergeSpans(clippedUnbreakable);
+}
+function analyzeParagraphs(source, doc) {
+  const paragraphs = [];
+  const walk = (node) => {
+    if (node.type === "paragraph") {
+      const span = nodeSpan(node);
+      if (span) {
+        const lineStart = source.lastIndexOf("\n", span.start - 1) + 1;
+        const firstLinePrefix = source.slice(lineStart, span.start);
+        if (SANE_PREFIX_RE.test(firstLinePrefix)) {
+          const info = {
+            node,
+            start: span.start,
+            end: span.end,
+            firstLinePrefix,
+            continuationPrefix: firstLinePrefix.replace(/[^>\t]/g, " "),
+            breakSpans: [],
+            immovableSpans: [],
+            unbreakableSpans: []
+          };
+          collectInlineSpans(source, node, info);
+          info.breakSpans.sort((a, b) => a.start - b.start);
+          paragraphs.push(info);
+        }
+      }
+      return;
+    }
+    for (const child of getChildren(node)) walk(child);
+  };
+  walk(doc);
+  return paragraphs;
+}
+function dominantEol(source) {
+  const crlf = (source.match(/\r\n/g) ?? []).length;
+  const lf = (source.match(/\n/g) ?? []).length - crlf;
+  return crlf > lf ? "\r\n" : "\n";
+}
+function spanAt(spans, offset) {
+  for (const span of spans) {
+    if (offset < span.start) return null;
+    if (offset < span.end) return span;
+  }
+  return null;
+}
+function tokenizeParagraph(source, info) {
+  const segments = [{ markerBefore: "", tokens: [] }];
+  let current = "";
+  let currentMultiline = false;
+  let i = info.start;
+  const flushToken = () => {
+    if (current.length > 0) {
+      segments[segments.length - 1].tokens.push({ text: current, multiline: currentMultiline });
+      current = "";
+      currentMultiline = false;
+    }
+  };
+  const consumeContinuationPrefix = () => {
+    const rest = source.slice(i, info.end);
+    const match = CONTINUATION_PREFIX_RE.exec(rest);
+    if (match) i += match[0].length;
+  };
+  while (i < info.end) {
+    const breakSpan = spanAt(info.breakSpans, i);
+    if (breakSpan && breakSpan.start === i) {
+      flushToken();
+      segments.push({ markerBefore: source.slice(breakSpan.start, breakSpan.end), tokens: [] });
+      i = breakSpan.end;
+      consumeContinuationPrefix();
+      continue;
+    }
+    const atom = spanAt(info.unbreakableSpans, i);
+    if (atom && atom.start === i) {
+      const bytes = source.slice(atom.start, Math.min(atom.end, info.end));
+      current += bytes;
+      if (bytes.includes("\n")) currentMultiline = true;
+      i = Math.min(atom.end, info.end);
+      continue;
+    }
+    const ch = source[i];
+    if (ch === "\n" || ch === "\r" && source[i + 1] === "\n") {
+      flushToken();
+      i += ch === "\r" ? 2 : 1;
+      consumeContinuationPrefix();
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      flushToken();
+      i += 1;
+      continue;
+    }
+    current += ch;
+    i += 1;
+  }
+  flushToken();
+  return segments;
+}
+var FORBIDDEN_LINE_START_RES = [
+  /^[-+*](?:[ \t]|$)/,
+  // bullet list
+  /^\d{1,9}[.)](?:[ \t]|$)/,
+  // ordered list (all numbers — belt and braces)
+  /^#{1,6}(?:[ \t]|$)/,
+  // ATX heading
+  /^>/,
+  // blockquote
+  /^\|/,
+  // table row
+  /^(?:`{3,}|~{3,})/,
+  // code fence
+  /^\$\$/,
+  // math flow
+  /^::/,
+  // leaf/container directive
+  /^\[\^[^\]]*\]:/,
+  // footnote definition
+  /^<[a-zA-Z!/?]/
+  // HTML block types 1–6
+];
+var FORBIDDEN_WHOLE_LINE_RES = [
+  /^=+[ \t]*$/,
+  // setext H1
+  /^-+[ \t]*$/,
+  // setext H2 / thematic break
+  /^([*_-])(?:[ \t]*\1){2,}[ \t]*$/,
+  // thematic break, spaced forms included
+  /^[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/
+  // GFM table delimiter row
+];
+function isForbiddenLineStart(line) {
+  return FORBIDDEN_LINE_START_RES.some((re) => re.test(line)) || FORBIDDEN_WHOLE_LINE_RES.some((re) => re.test(line));
+}
+function firstLineLength(token) {
+  const idx = token.text.indexOf("\n");
+  return idx === -1 ? token.text.length : idx;
+}
+function lastLineLength(token) {
+  const idx = token.text.lastIndexOf("\n");
+  return idx === -1 ? token.text.length : token.text.length - idx - 1;
+}
+function fillSegment(tokens, width, firstLinePrefixLen, continuationPrefixLen) {
+  const lines = [[]];
+  let column = firstLinePrefixLen;
+  for (const token of tokens) {
+    const line = lines[lines.length - 1];
+    const addition = (line.length > 0 ? 1 : 0) + firstLineLength(token);
+    if (line.length > 0 && column + addition > width) {
+      lines.push([token]);
+      column = continuationPrefixLen + lastLineLength(token);
+    } else {
+      line.push(token);
+      column = token.multiline ? lastLineLength(token) : column + addition;
+    }
+  }
+  for (let i = 1; i < lines.length; i++) {
+    for (; ; ) {
+      const line = lines[i];
+      if (line.length === 0) break;
+      const prev = lines[i - 1];
+      const prevLast = prev[prev.length - 1];
+      const startsForbidden = isForbiddenLineStart(line.map((t) => t.text).join(" "));
+      const prevEndsBackslash = prevLast !== void 0 && prevLast.text.endsWith("\\");
+      if (!startsForbidden && !prevEndsBackslash) break;
+      const moved = line.shift();
+      if (!moved) break;
+      prev.push(moved);
+    }
+    if (lines[i].length === 0) {
+      lines.splice(i, 1);
+      i -= 1;
+    }
+  }
+  return lines.filter((line) => line.length > 0);
+}
+function reflowParagraphSlice(source, info, width, eol) {
+  const segments = tokenizeParagraph(source, info);
+  const contPrefix = info.continuationPrefix;
+  const parts = [];
+  segments.forEach((segment, index) => {
+    if (index > 0) {
+      parts.push(segment.markerBefore, contPrefix);
+    }
+    if (width === null) {
+      parts.push(segment.tokens.map((t) => t.text).join(" "));
+    } else {
+      const firstPrefixLen = index === 0 ? info.firstLinePrefix.length : contPrefix.length;
+      const lines = fillSegment(segment.tokens, width, firstPrefixLen, contPrefix.length);
+      parts.push(
+        lines.map((line) => line.map((t) => t.text).join(" ")).join(`${eol}${contPrefix}`)
+      );
+    }
+  });
+  return parts.join("");
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/g, " ");
+}
+var STRICT_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "inlineCode",
+  "code",
+  "math",
+  "inlineMath",
+  "htmlInline",
+  "htmlBlock"
+]);
+var COLLAPSE_STRING_KEYS = /* @__PURE__ */ new Set(["label", "alt", "displayName"]);
+function normalizeForCompare(node) {
+  const out = {};
+  const record = node;
+  for (const key of Object.keys(record)) {
+    if (key === "position" || key === "children" || key === "htmlChildren") continue;
+    const value = record[key];
+    if (value === void 0) continue;
+    if (typeof value === "string" && key !== "type") {
+      if (key === "value") {
+        out[key] = STRICT_VALUE_TYPES.has(node.type) ? value : collapseWhitespace(value);
+      } else if (COLLAPSE_STRING_KEYS.has(key)) {
+        out[key] = collapseWhitespace(value);
+      } else {
+        out[key] = value;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      out[key] = JSON.parse(JSON.stringify(value));
+    } else {
+      out[key] = value;
+    }
+  }
+  const children = getChildren(node);
+  if ("children" in record) {
+    const merged = [];
+    for (const child of children) {
+      const prev = merged[merged.length - 1];
+      if (child.type === "text" && prev && prev.type === "text") {
+        merged[merged.length - 1] = { ...prev, value: `${prev.value}${child.value}` };
+      } else {
+        merged.push(child);
+      }
+    }
+    out.children = merged.map((child) => normalizeForCompare(child));
+  }
+  return out;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function documentsEquivalent(a, b) {
+  return stableStringify(normalizeForCompare(a)) === stableStringify(normalizeForCompare(b));
+}
+function noopResult(source, degraded) {
+  return { output: source, changed: false, degraded, edits: [] };
+}
+function clampWidth(width) {
+  if (width === void 0 || Number.isNaN(width)) return DEFAULT_WRAP_WIDTH;
+  return Math.min(MAX_WRAP_WIDTH, Math.max(MIN_WRAP_WIDTH, Math.floor(width)));
+}
+function degrade(id, source, strict, reason) {
+  if (strict) {
+    throw new Error(`squisq ${id} transform aborted: ${reason}`);
+  }
+  console.warn(`[squisq] ${id} transform left the document unchanged: ${reason}`);
+  return noopResult(source, true);
+}
+function reflowTransform(id, source, options) {
+  const width = id === "wrap" ? clampWidth(options?.width) : null;
+  let doc;
+  try {
+    doc = parseMarkdown(source, { parseHtml: false });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return degrade(id, source, options?.strict, `the document could not be parsed (${message})`);
+  }
+  const eol = dominantEol(source);
+  const edits = [];
+  for (const info of analyzeParagraphs(source, doc)) {
+    const oldSlice = source.slice(info.start, info.end);
+    if (id === "unwrap" && !oldSlice.includes("\n")) continue;
+    const newSlice = reflowParagraphSlice(source, info, width, eol);
+    if (newSlice !== oldSlice) {
+      edits.push({ start: info.start, end: info.end, text: newSlice });
+    }
+  }
+  if (edits.length === 0) return noopResult(source, false);
+  edits.sort((a, b) => b.start - a.start);
+  let output = source;
+  for (const edit of edits) {
+    output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+  }
+  try {
+    const reparsed = parseMarkdown(output, { parseHtml: false });
+    if (!documentsEquivalent(doc, reparsed)) {
+      return degrade(
+        id,
+        source,
+        options?.strict,
+        "the transformed markdown no longer parses to an equivalent document"
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return degrade(
+      id,
+      source,
+      options?.strict,
+      `the transformed markdown failed to reparse (${message})`
+    );
+  }
+  return { output, changed: true, degraded: false, edits };
+}
+function cleanupTransform(source, options) {
+  const { frontmatter, body } = splitFrontmatterBlock(source);
+  let output;
+  let parsedBody;
+  try {
+    parsedBody = parseMarkdown(body, { frontmatter: false, parseHtml: false });
+    const cleanedBody = stringifyMarkdown(parsedBody);
+    if (frontmatter !== null) {
+      let fm = frontmatter.replace(/\r\n?/g, "\n");
+      if (!fm.endsWith("\n")) fm += "\n";
+      output = cleanedBody.length > 0 ? `${fm}
+${cleanedBody}` : fm;
+    } else {
+      output = cleanedBody;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return degrade(
+      "cleanup",
+      source,
+      options?.strict,
+      `the document could not be re-serialized (${message})`
+    );
+  }
+  if (output === source) return noopResult(source, false);
+  try {
+    const reparsed = parseMarkdown(splitFrontmatterBlock(output).body, {
+      frontmatter: false,
+      parseHtml: false
+    });
+    if (!documentsEquivalent(parsedBody, reparsed)) {
+      return degrade(
+        "cleanup",
+        source,
+        options?.strict,
+        "the cleaned markdown no longer parses to an equivalent document"
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return degrade(
+      "cleanup",
+      source,
+      options?.strict,
+      `the cleaned markdown failed to reparse (${message})`
+    );
+  }
+  return {
+    output,
+    changed: true,
+    degraded: false,
+    edits: [{ start: 0, end: source.length, text: output }]
+  };
+}
+var MARKDOWN_SOURCE_TRANSFORMS = Object.freeze([
+  {
+    id: "unwrap",
+    label: "Unwrap paragraphs",
+    description: "Remove forced line wrapping so each paragraph is a single line (hard breaks are kept).",
+    apply: (source, options) => reflowTransform("unwrap", source, options)
+  },
+  {
+    id: "wrap",
+    label: "Wrap at width",
+    description: "Hard-wrap paragraph prose at a column width on word boundaries; code, tables, and headings are untouched.",
+    apply: (source, options) => reflowTransform("wrap", source, options)
+  },
+  {
+    id: "cleanup",
+    label: "Clean up formatting",
+    description: "Re-serialize through the canonical house style: bullets, emphasis, headings, table padding, spacing.",
+    apply: (source, options) => cleanupTransform(source, options)
+  }
+]);
+function applyMarkdownSourceTransform(id, source, options) {
+  const transform = MARKDOWN_SOURCE_TRANSFORMS.find((t) => t.id === id);
+  if (!transform) {
+    const known = MARKDOWN_SOURCE_TRANSFORMS.map((t) => t.id).join(", ");
+    throw new Error(`Unknown markdown source transform "${id}" (known: ${known})`);
+  }
+  return transform.apply(source, options);
+}
+function unwrapMarkdownSource(source, options) {
+  return reflowTransform("unwrap", source, options).output;
+}
+function wrapMarkdownSource(source, options) {
+  return reflowTransform("wrap", source, options).output;
+}
+function cleanupMarkdownSource(source, options) {
+  return cleanupTransform(source, options).output;
+}
+function detectMarkdownWrapState(source) {
+  let doc;
+  try {
+    doc = parseMarkdown(source, { parseHtml: false });
+  } catch {
+    return { kind: "no-prose", totalParagraphs: 0, wrappedParagraphs: 0, maxLineLength: 0 };
+  }
+  const paragraphs = analyzeParagraphs(source, doc);
+  if (paragraphs.length === 0) {
+    return { kind: "no-prose", totalParagraphs: 0, wrappedParagraphs: 0, maxLineLength: 0 };
+  }
+  let wrappedParagraphs = 0;
+  let maxLineLength = 0;
+  let candidateWidth = 0;
+  const approxLengths = [];
+  for (const info of paragraphs) {
+    const lineStart = info.start - info.firstLinePrefix.length;
+    const slice = source.slice(lineStart, info.end);
+    const lines = slice.split(/\r?\n/);
+    for (const line of lines) maxLineLength = Math.max(maxLineLength, line.length);
+    const evidenceLengths = [];
+    let offset = lineStart;
+    for (let i = 0; i < lines.length - 1; i++) {
+      const newlineOffset = offset + lines[i].length;
+      const isHard = spanAt(info.breakSpans, newlineOffset) !== null;
+      const isImmovable = spanAt(info.immovableSpans, newlineOffset) !== null;
+      if (!isHard && !isImmovable) evidenceLengths.push(lines[i].length);
+      offset = newlineOffset + (source[newlineOffset] === "\r" ? 2 : 1);
+    }
+    const wrapped = evidenceLengths.length > 0;
+    if (wrapped) {
+      wrappedParagraphs += 1;
+      candidateWidth = Math.max(candidateWidth, ...evidenceLengths);
+    }
+    approxLengths.push({
+      approxUnwrapped: info.firstLinePrefix.length + (info.end - info.start),
+      wrapped
+    });
+  }
+  if (wrappedParagraphs === 0) {
+    return {
+      kind: "unwrapped",
+      totalParagraphs: paragraphs.length,
+      wrappedParagraphs: 0,
+      maxLineLength
+    };
+  }
+  let width = candidateWidth;
+  for (const common of COMMON_WRAP_WIDTHS) {
+    if (candidateWidth <= common && common - candidateWidth <= WIDTH_SNAP_TOLERANCE) {
+      width = common;
+      break;
+    }
+  }
+  let needy = 0;
+  for (const p of approxLengths) {
+    if (p.wrapped || p.approxUnwrapped > width) needy += 1;
+  }
+  const kind = candidateWidth >= MIN_DETECTED_WRAP_WIDTH && wrappedParagraphs / Math.max(1, needy) >= 0.5 ? "wrapped" : "mixed";
+  return {
+    kind,
+    ...kind === "wrapped" ? { width } : {},
+    totalParagraphs: paragraphs.length,
+    wrappedParagraphs,
+    maxLineLength
+  };
+}
+
+export {
+  stringifyMarkdown,
+  DEFAULT_RESOURCE_MAX_BYTES,
+  DEFAULT_RESOURCE_TIMEOUT_MS,
+  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+  LOCAL_ONLY_RESOURCE_POLICY,
+  ResourcePolicyError,
+  isResourceUrlAllowed,
+  fetchResourceBytes,
+  DEFAULT_WRAP_WIDTH,
+  MARKDOWN_SOURCE_TRANSFORMS,
+  applyMarkdownSourceTransform,
+  unwrapMarkdownSource,
+  wrapMarkdownSource,
+  cleanupMarkdownSource,
+  detectMarkdownWrapState
+};