@bendyline/squisq 2.0.1 → 2.2.0

package/dist/chunk-3IGPAPQ7.js

@@ -0,0 +1,645 @@
+import {
+  assertMarkdownDocumentWithinLimits,
+  toMdast
+} from "./chunk-ACZOVWX3.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/sanitize.ts
+var SAFE_LINK_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel"]);
+var SAFE_MEDIA_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "blob"]);
+var NEVER_ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["javascript", "vbscript", "data"]);
+var SAFE_DATA_MEDIA_RE = /^data:(?:image\/(?!svg\+xml)[a-z0-9.+-]+|audio\/[a-z0-9.+-]+|video\/[a-z0-9.+-]+);/i;
+var SAFE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "blockquote",
+  "br",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "figcaption",
+  "figure",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "img",
+  "kbd",
+  "li",
+  "mark",
+  "ol",
+  "p",
+  "pre",
+  "q",
+  "s",
+  "samp",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "audio"
+]);
+var DROP_WITH_CONTENT_TAGS = /* @__PURE__ */ new Set([
+  "base",
+  "button",
+  "embed",
+  "form",
+  "iframe",
+  "input",
+  "link",
+  "meta",
+  "object",
+  "option",
+  "script",
+  "select",
+  "style",
+  "svg",
+  "template",
+  "textarea"
+]);
+var GLOBAL_ATTRS = /* @__PURE__ */ new Set(["class", "id", "title", "role"]);
+var TAG_ATTRS = {
+  a: /* @__PURE__ */ new Set(["href", "target", "rel"]),
+  audio: /* @__PURE__ */ new Set(["src", "controls", "preload", "muted", "loop"]),
+  col: /* @__PURE__ */ new Set(["span", "width"]),
+  colgroup: /* @__PURE__ */ new Set(["span"]),
+  data: /* @__PURE__ */ new Set(["value"]),
+  img: /* @__PURE__ */ new Set(["src", "alt", "width", "height", "loading", "decoding"]),
+  li: /* @__PURE__ */ new Set(["value"]),
+  ol: /* @__PURE__ */ new Set(["start", "type"]),
+  q: /* @__PURE__ */ new Set(["cite"]),
+  source: /* @__PURE__ */ new Set(["src", "type", "media"]),
+  td: /* @__PURE__ */ new Set(["colspan", "rowspan", "align"]),
+  th: /* @__PURE__ */ new Set(["colspan", "rowspan", "align", "scope"]),
+  time: /* @__PURE__ */ new Set(["datetime"]),
+  track: /* @__PURE__ */ new Set(["src", "kind", "label", "srclang", "default"]),
+  video: /* @__PURE__ */ new Set([
+    "src",
+    "poster",
+    "width",
+    "height",
+    "controls",
+    "preload",
+    "muted",
+    "loop",
+    "playsinline"
+  ])
+};
+var SAFE_ATTR_NAME_RE = /^[a-z][a-z0-9:_.-]*$/;
+var SAFE_OL_TYPES = /* @__PURE__ */ new Set(["1", "a", "A", "i", "I"]);
+var SAFE_PRELOAD_VALUES = /* @__PURE__ */ new Set(["none", "metadata", "auto"]);
+var SAFE_TRACK_KINDS = /* @__PURE__ */ new Set(["subtitles", "captions", "descriptions", "chapters", "metadata"]);
+function sanitizeUrl(url, kind = "link", options) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const compact = stripUrlSchemeNoise(trimmed);
+  const colon = compact.indexOf(":");
+  const firstPathChar = firstIndexOfAny(compact, ["/", "?", "#"]);
+  const hasScheme = colon >= 0 && (firstPathChar < 0 || colon < firstPathChar);
+  if (!hasScheme) return trimmed;
+  const scheme = compact.slice(0, colon).toLowerCase();
+  if (kind === "media") {
+    if (scheme === "data") return SAFE_DATA_MEDIA_RE.test(compact) ? trimmed : null;
+    return SAFE_MEDIA_SCHEMES.has(scheme) ? trimmed : null;
+  }
+  if (SAFE_LINK_SCHEMES.has(scheme)) return trimmed;
+  if (options?.extraLinkSchemes?.includes(scheme) && !NEVER_ALLOWED_SCHEMES.has(scheme)) {
+    return trimmed;
+  }
+  return null;
+}
+function sanitizeHtmlNodes(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    out.push(...sanitizeHtmlNode(node));
+  }
+  return out;
+}
+function sanitizeHtmlNode(node) {
+  switch (node.type) {
+    case "htmlText":
+      return [node];
+    case "htmlComment":
+      return [];
+    case "htmlElement":
+      return sanitizeHtmlElement(node);
+  }
+}
+function sanitizeHtmlElement(node) {
+  const tag = node.tagName.toLowerCase();
+  if (DROP_WITH_CONTENT_TAGS.has(tag)) return [];
+  const children = sanitizeHtmlNodes(node.children);
+  if (!SAFE_TAGS.has(tag)) return children;
+  return [
+    {
+      type: "htmlElement",
+      tagName: tag,
+      attributes: sanitizeAttrs(tag, node.attributes),
+      children,
+      selfClosing: node.selfClosing
+    }
+  ];
+}
+function sanitizeAttrs(tag, attrs) {
+  const out = {};
+  for (const [rawName, rawValue] of Object.entries(attrs)) {
+    const name = rawName.toLowerCase();
+    if (!isAllowedAttr(tag, name)) continue;
+    const value = String(rawValue);
+    const safeValue = sanitizeAttrValue(tag, name, value);
+    if (safeValue === null) continue;
+    out[name] = safeValue;
+  }
+  if (tag === "a" && out.target === "_blank") {
+    out.rel = ensureRelTokens(out.rel, ["noopener", "noreferrer"]);
+  }
+  return out;
+}
+function isAllowedAttr(tag, name) {
+  if (!SAFE_ATTR_NAME_RE.test(name)) return false;
+  if (name.startsWith("on")) return false;
+  if (name.startsWith("aria-") || name.startsWith("data-")) return true;
+  if (GLOBAL_ATTRS.has(name)) return true;
+  return TAG_ATTRS[tag]?.has(name) ?? false;
+}
+function sanitizeAttrValue(tag, name, value) {
+  if (name === "href") return sanitizeUrl(value, "link");
+  if (name === "src" || name === "poster") return sanitizeUrl(value, "media");
+  if ((name === "width" || name === "height" || name === "span" || name === "colspan" || name === "rowspan" || name === "value") && !isNonNegativeInteger(value)) {
+    return null;
+  }
+  if (name === "start" && !isInteger(value)) return null;
+  if (name === "type" && tag === "ol" && !SAFE_OL_TYPES.has(value)) return null;
+  if (name === "preload" && !SAFE_PRELOAD_VALUES.has(value)) return null;
+  if (name === "kind" && tag === "track" && !SAFE_TRACK_KINDS.has(value)) return null;
+  if (name === "align" && value !== "left" && value !== "right" && value !== "center") return null;
+  if (name === "target")
+    return value === "_blank" || value === "_self" || value === "_parent" || value === "_top" ? value : null;
+  if (name === "rel") return sanitizeRel(value);
+  return value;
+}
+function sanitizeRel(value) {
+  return relTokens(value).join(" ");
+}
+function ensureRelTokens(value, required) {
+  const tokens = new Set(value ? relTokens(value) : []);
+  for (const token of required) tokens.add(token);
+  return Array.from(tokens).join(" ");
+}
+function relTokens(value) {
+  const tokens = value.split(/\s+/).map((token) => token.trim().toLowerCase()).filter(Boolean).filter((token) => /^[a-z0-9_-]+$/.test(token));
+  return Array.from(new Set(tokens));
+}
+function isInteger(value) {
+  return /^-?\d+$/.test(value.trim());
+}
+function isNonNegativeInteger(value) {
+  return /^\d+$/.test(value.trim());
+}
+function firstIndexOfAny(value, needles) {
+  let result = -1;
+  for (const needle of needles) {
+    const index = value.indexOf(needle);
+    if (index >= 0 && (result < 0 || index < result)) result = index;
+  }
+  return result;
+}
+function stripUrlSchemeNoise(value) {
+  let out = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 32 || code === 127 || char.trim() === "") continue;
+    out += char;
+  }
+  return out;
+}
+
+// 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,
+  sanitizeUrl,
+  sanitizeHtmlNodes,
+  DEFAULT_RESOURCE_MAX_BYTES,
+  DEFAULT_RESOURCE_TIMEOUT_MS,
+  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+  LOCAL_ONLY_RESOURCE_POLICY,
+  ResourcePolicyError,
+  isResourceUrlAllowed,
+  fetchResourceBytes
+};

package/dist/{chunk-QE7TWGVT.js → chunk-4VOD55SX.js}

@@ -175,4 +175,3 @@ export {
   resolveTransitionDuration,
   resolveBlockTransition
 };
-//# sourceMappingURL=chunk-QE7TWGVT.js.map

package/dist/{chunk-3E5F2XMR.js → chunk-67L6WRJN.js}

@@ -126,4 +126,3 @@ export {
   calculatePrefixDuration,
   estimateNarrationDuration
 };
-//# sourceMappingURL=chunk-3E5F2XMR.js.map