@bendyline/squisq 2.3.3 → 2.4.0

package/dist/chunk-UA5DTYAY.js

@@ -1,400 +0,0 @@
-import {
-  assertMarkdownDocumentWithinLimits,
-  toMdast
-} from "./chunk-G3JOS25T.js";
-import {
-  formatFrontmatterYaml
-} from "./chunk-BCCXTMN5.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`
-  );
-}
-
-export {
-  stringifyMarkdown,
-  DEFAULT_RESOURCE_MAX_BYTES,
-  DEFAULT_RESOURCE_TIMEOUT_MS,
-  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
-  LOCAL_ONLY_RESOURCE_POLICY,
-  ResourcePolicyError,
-  isResourceUrlAllowed,
-  fetchResourceBytes
-};