@bendyline/squisq-formats 2.1.0 → 2.2.0

package/dist/{chunk-WQSHGBLN.js → chunk-3NKXBZSR.js}

@@ -1,10 +1,11 @@
 import {
   ConversionError
-} from "./chunk-ODL3SSPT.js";
+} from "./chunk-KXOZMWBS.js";
 import {
   ZipSafetyError,
-  openBoundedZipArchive
-} from "./chunk-FE6OJV6O.js";
+  openBoundedZipArchive,
+  resolveZipSafetyLimits
+} from "./chunk-7AWFHP5U.js";
 
 // src/registry/types.ts
 var BUILTIN_FORMAT_IDS = [
@@ -20,6 +21,84 @@ var BUILTIN_FORMAT_IDS = [
   "dbk"
 ];
 
+// src/registry/limits.ts
+var DEFAULT_CONVERSION_LIMITS = Object.freeze({
+  maxInputBytes: 256 * 1024 * 1024,
+  maxMarkdownBytes: 16 * 1024 * 1024,
+  maxMarkdownNodes: 25e4,
+  maxMarkdownDepth: 128,
+  maxTableCells: 1e5,
+  maxBlocks: 5e4,
+  maxBlockDepth: 128,
+  maxDurationSeconds: 24 * 60 * 60,
+  maxAudioSegments: 1e4
+});
+function resolveConversionLimits(limits) {
+  const resolved = { ...DEFAULT_CONVERSION_LIMITS, ...limits };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+  }
+  return resolved;
+}
+function markdownLimitsFromConversion(limits) {
+  if (limits === false) return false;
+  const resolved = resolveConversionLimits(limits);
+  return {
+    maxSourceBytes: resolved.maxMarkdownBytes,
+    maxNodes: resolved.maxMarkdownNodes,
+    maxDepth: resolved.maxMarkdownDepth,
+    maxTableCells: resolved.maxTableCells
+  };
+}
+function assertDocWithinConversionLimits(doc, limits, signal) {
+  if (limits === false) return;
+  const resolved = resolveConversionLimits(limits);
+  if (!Number.isFinite(doc.duration) || doc.duration < 0 || doc.duration > resolved.maxDurationSeconds) {
+    throw new RangeError(
+      `Document duration must be between 0 and ${resolved.maxDurationSeconds} seconds`
+    );
+  }
+  if (doc.audio.segments.length > resolved.maxAudioSegments) {
+    throw new RangeError(
+      `Document exceeds the ${resolved.maxAudioSegments}-audio-segment safety limit`
+    );
+  }
+  let audioDuration = 0;
+  for (const segment of doc.audio.segments) {
+    if (!Number.isFinite(segment.duration) || segment.duration < 0) {
+      throw new RangeError("Audio segment durations must be non-negative finite numbers");
+    }
+    audioDuration += segment.duration;
+    if (audioDuration > resolved.maxDurationSeconds) {
+      throw new RangeError(
+        `Narration exceeds the ${resolved.maxDurationSeconds}-second safety limit`
+      );
+    }
+  }
+  const stack = [];
+  for (let index = doc.blocks.length - 1; index >= 0; index--) {
+    stack.push({ block: doc.blocks[index], depth: 0 });
+  }
+  let count = 0;
+  while (stack.length > 0) {
+    if ((count & 1023) === 0) signal?.throwIfAborted();
+    const { block, depth } = stack.pop();
+    if (++count > resolved.maxBlocks) {
+      throw new RangeError(`Document exceeds the ${resolved.maxBlocks}-block safety limit`);
+    }
+    if (depth > resolved.maxBlockDepth) {
+      throw new RangeError(
+        `Document exceeds the ${resolved.maxBlockDepth}-level block nesting safety limit`
+      );
+    }
+    for (let index = (block.children?.length ?? 0) - 1; index >= 0; index--) {
+      stack.push({ block: block.children[index], depth: depth + 1 });
+    }
+  }
+}
+
 // src/shared/fidelity.ts
 var CONTENT_NODE_TYPES = {
   heading: true,
@@ -86,7 +165,7 @@ var PROFILE_LABELS = {
   pptx: "PPTX",
   epub: "EPUB"
 };
-function markdownFidelityWarnings(document2, profile) {
+function markdownFidelityWarnings(document, profile) {
   const supported = PROFILE_SUPPORT[profile];
   const omitted = /* @__PURE__ */ new Map();
   const visit = (candidate) => {
@@ -103,7 +182,7 @@ function markdownFidelityWarnings(document2, profile) {
       for (const child of node.children) visit(child);
     }
   };
-  for (const child of document2.children) visit(child);
+  for (const child of document.children) visit(child);
   if (omitted.size === 0) return [];
   const total = [...omitted.values()].reduce((sum, count) => sum + count, 0);
   const details = [...omitted].map(([type, count]) => `${type} (${count})`).join(", ");
@@ -142,17 +221,22 @@ function resolveThemeId(input, options) {
   return options.themeId ?? input.doc.themeId;
 }
 function optionsFor(options, id) {
-  return options.formatOptions?.[id] ?? {};
+  return {
+    ...options.formatOptions?.[id] ?? {},
+    ...options.signal ? { signal: options.signal } : {}
+  };
 }
 async function markdownOf(input) {
   if (input.markdownDoc) return input.markdownDoc;
   const { docToMarkdown } = await import("@bendyline/squisq/doc");
   return docToMarkdown(input.doc);
 }
-async function collectContainerImages(container) {
+async function collectContainerImages(container, signal) {
   const images = /* @__PURE__ */ new Map();
   const files = await container.listFiles();
-  for (const file of files) {
+  for (let index = 0; index < files.length; index++) {
+    if ((index & 63) === 0) signal?.throwIfAborted();
+    const file = files[index];
     if (!/\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i.test(file.path)) continue;
     const data = await container.readFile(file.path);
     if (!data) continue;
@@ -162,9 +246,9 @@ async function collectContainerImages(container) {
   }
   return images;
 }
-async function collectContainerDocxImages(container) {
-  const images = await collectContainerImages(container);
-  const { extToMime } = await import("./images-7FBWPKE3.js");
+async function collectContainerDocxImages(container, signal) {
+  const images = await collectContainerImages(container, signal);
+  const { extToMime } = await import("./images-ESPQKVTW.js");
   return new Map(
     [...images].map(([path, data]) => [
       path,
@@ -172,11 +256,13 @@ async function collectContainerDocxImages(container) {
     ])
   );
 }
-async function snapshotContainerWithDocument(input) {
+async function snapshotContainerWithDocument(input, signal) {
   const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
   const snapshot = new MemoryContentContainer();
   const entries = await input.container.listFiles();
-  for (const entry of entries) {
+  for (let index = 0; index < entries.length; index++) {
+    if ((index & 63) === 0) signal?.throwIfAborted();
+    const entry = entries[index];
     const data = await input.container.readFile(entry.path);
     if (data) await snapshot.writeFile(entry.path, new Uint8Array(data), entry.mimeType);
   }
@@ -214,11 +300,21 @@ function defaultFormats() {
     extensions: [".md", ".markdown"],
     async importDoc(data, options) {
       const { parseMarkdown } = await import("@bendyline/squisq/markdown");
-      return parseMarkdown(new TextDecoder().decode(data), optionsFor(options, "md").parse);
+      const raw = optionsFor(options, "md").parse ?? {};
+      return parseMarkdown(new TextDecoder().decode(data), {
+        ...raw,
+        signal: options.signal,
+        limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+      });
     },
     async exportDoc(input, options) {
       const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-      const text = stringifyMarkdown(await markdownOf(input), optionsFor(options, "md").stringify);
+      const raw = optionsFor(options, "md").stringify ?? {};
+      const text = stringifyMarkdown(await markdownOf(input), {
+        ...raw,
+        signal: options.signal,
+        limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+      });
       return ok(new TextEncoder().encode(text), MIME.md);
     }
   };
@@ -239,7 +335,7 @@ function defaultFormats() {
       const { markdownDocToDocx } = await import("./docx/index.js");
       const raw = optionsFor(options, "docx");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerDocxImages(input.container);
+      const containerImages = await collectContainerDocxImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToDocx(markdownDoc, {
         ...raw,
@@ -268,13 +364,18 @@ function defaultFormats() {
       const { markdownDocToPdf } = await import("./pdf/index.js");
       const raw = optionsFor(options, "pdf");
       const markdownDoc = await markdownOf(input);
+      const pdfWarnings = [];
       const buf = await markdownDocToPdf(markdownDoc, {
         ...raw,
         ...options.title !== void 0 ? { title: options.title } : {},
         themeId: resolveThemeId(input, options),
-        themeRegistry: options.themeRegistry ?? raw.themeRegistry
+        themeRegistry: options.themeRegistry ?? raw.themeRegistry,
+        onWarning: (message) => pdfWarnings.push(message)
       });
-      return ok(await toBytes(buf), MIME.pdf, markdownFidelityWarnings(markdownDoc, "pdf"));
+      return ok(await toBytes(buf), MIME.pdf, [
+        ...markdownFidelityWarnings(markdownDoc, "pdf"),
+        ...pdfWarnings
+      ]);
     }
   };
   const pptx = {
@@ -294,7 +395,7 @@ function defaultFormats() {
       const { markdownDocToPptx } = await import("./pptx/index.js");
       const raw = optionsFor(options, "pptx");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToPptx(markdownDoc, {
         ...raw,
@@ -368,7 +469,7 @@ function defaultFormats() {
       const playerScript = await requirePlayerScript(options, "html");
       const { docToHtml } = await import("./html/index.js");
       const raw = optionsFor(options, "html");
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const htmlText = docToHtml(input.doc, {
         ...raw,
@@ -391,7 +492,7 @@ function defaultFormats() {
       const playerScript = await requirePlayerScript(options, "htmlzip");
       const { docToHtmlZip } = await import("./html/index.js");
       const raw = optionsFor(options, "htmlzip");
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const blob = await docToHtmlZip(input.doc, {
         ...raw,
@@ -414,7 +515,7 @@ function defaultFormats() {
       const { markdownDocToEpub } = await import("./epub/index.js");
       const raw = optionsFor(options, "epub");
       const markdownDoc = await markdownOf(input);
-      const containerImages = await collectContainerImages(input.container);
+      const containerImages = await collectContainerImages(input.container, options.signal);
       const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const buf = await markdownDocToEpub(markdownDoc, {
         ...raw,
@@ -438,7 +539,7 @@ function defaultFormats() {
     async exportDoc(input, options) {
       const { containerToZip } = await import("./container/index.js");
       const blob = await containerToZip(
-        await snapshotContainerWithDocument(input),
+        await snapshotContainerWithDocument(input, options.signal),
         optionsFor(options, "dbk")
       );
       return ok(await toBytes(blob), MIME.zip);
@@ -485,6 +586,22 @@ function defaultRegistry() {
 function markdownFormatOptions(options) {
   return options.formatOptions?.md ?? {};
 }
+function parseOptions(options) {
+  const raw = markdownFormatOptions(options).parse ?? {};
+  return {
+    ...raw,
+    signal: options.signal,
+    limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+  };
+}
+function stringifyOptions(options) {
+  const raw = markdownFormatOptions(options).stringify ?? {};
+  return {
+    ...raw,
+    signal: options.signal,
+    limits: raw.limits ?? markdownLimitsFromConversion(options.limits)
+  };
+}
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   if (signal.reason !== void 0) throw signal.reason;
@@ -501,11 +618,26 @@ function hasPrefix(bytes, prefix) {
 }
 var ZIP_MAGIC = [80, 75, 3, 4];
 var PDF_MAGIC = [37, 80, 68, 70];
-async function sniffZip(bytes) {
-  const archive = await openBoundedZipArchive(bytes).catch((cause) => {
-    if (cause instanceof ZipSafetyError && cause.code !== "invalid-archive") throw cause;
-    throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.", { cause });
-  });
+var ZIP_SNIFF_CANDIDATES = ["docx", "pptx", "xlsx", "dbk"];
+function sniffZipLimits(options) {
+  const effective = ZIP_SNIFF_CANDIDATES.map(
+    (id) => resolveZipSafetyLimits(options.formatOptions?.[id] ?? {})
+  );
+  return {
+    signal: options.signal,
+    maxEntries: Math.max(...effective.map((l) => l.maxEntries)),
+    maxUncompressedBytes: Math.max(...effective.map((l) => l.maxUncompressedBytes)),
+    maxEntryUncompressedBytes: Math.max(...effective.map((l) => l.maxEntryUncompressedBytes)),
+    maxCompressionRatio: Math.max(...effective.map((l) => l.maxCompressionRatio))
+  };
+}
+async function sniffZip(bytes, options) {
+  const archive = await openBoundedZipArchive(bytes, sniffZipLimits(options)).catch(
+    (cause) => {
+      if (cause instanceof ZipSafetyError && cause.code !== "invalid-archive") throw cause;
+      throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.", { cause });
+    }
+  );
   const contentTypes = archive.entries.find((entry) => entry.path === "[Content_Types].xml");
   if (!contentTypes) return "dbk";
   const maxContentTypesBytes = 1024 * 1024;
@@ -528,7 +660,7 @@ async function detectByteFormat(bytes, filename, options, registry) {
     if (byExt) return byExt.id;
   }
   if (hasPrefix(bytes, PDF_MAGIC)) return "pdf";
-  if (hasPrefix(bytes, ZIP_MAGIC)) return sniffZip(bytes);
+  if (hasPrefix(bytes, ZIP_MAGIC)) return sniffZip(bytes, options);
   return "md";
 }
 function extractExt(filename) {
@@ -546,6 +678,12 @@ function baseNameOf(filename) {
 }
 async function normalizeBytes(source, options, registry) {
   const bytes = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+  if (options.limits !== false && bytes.byteLength > resolveConversionLimits(options.limits).maxInputBytes) {
+    throw new ConversionError(
+      "invalid-input",
+      `Input exceeds the ${resolveConversionLimits(options.limits).maxInputBytes}-byte safety limit.`
+    );
+  }
   const buffer = bytes.buffer.slice(
     bytes.byteOffset,
     bytes.byteOffset + bytes.byteLength
@@ -574,21 +712,23 @@ async function normalizeBytes(source, options, registry) {
   let container;
   if (fromDef.importContainer) {
     container = await fromDef.importContainer(buffer, options);
-    if (fromDef.id === "pdf" && typeof document === "undefined") {
-      warnings.push(
-        "PDF embedded images were skipped \u2014 image decoding requires a browser canvas (running under Node)."
-      );
-    }
     const text = await container.readDocument();
-    markdownDoc = text ? parseMarkdown(text, markdownFormatOptions(options).parse) : { type: "document", children: [] };
+    markdownDoc = text ? parseMarkdown(text, parseOptions(options)) : { type: "document", children: [] };
   } else {
     markdownDoc = await fromDef.importDoc(buffer, options);
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    await mem.writeDocument(stringifyMarkdown(markdownDoc, stringifyOptions(options)));
     container = mem;
   }
+  const { assertMarkdownDocumentWithinLimits } = await import("@bendyline/squisq/markdown");
+  assertMarkdownDocumentWithinLimits(
+    markdownDoc,
+    markdownLimitsFromConversion(options.limits),
+    options.signal
+  );
   const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  assertDocWithinConversionLimits(doc, options.limits, options.signal);
   const baseName = source.filename ? baseNameOf(source.filename) : "document";
   return {
     input: { doc, markdownDoc, container, baseName },
@@ -599,26 +739,36 @@ async function normalizeMarkdown(source, options) {
   const { markdownToDoc } = await import("@bendyline/squisq/doc");
   const { parseMarkdown } = await import("@bendyline/squisq/markdown");
   const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
-  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown, markdownFormatOptions(options).parse) : source.markdown;
+  const markdownDoc = typeof source.markdown === "string" ? parseMarkdown(source.markdown, parseOptions(options)) : source.markdown;
+  const { assertMarkdownDocumentWithinLimits } = await import("@bendyline/squisq/markdown");
+  assertMarkdownDocumentWithinLimits(
+    markdownDoc,
+    markdownLimitsFromConversion(options.limits),
+    options.signal
+  );
   let container = source.container;
   if (!container) {
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    await mem.writeDocument(stringifyMarkdown(markdownDoc, stringifyOptions(options)));
     container = mem;
   }
   const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  assertDocWithinConversionLimits(doc, options.limits, options.signal);
   const baseName = source.baseName ?? "document";
   return { input: { doc, markdownDoc, container, baseName }, warnings: [] };
 }
-async function normalizeDoc(source) {
+async function normalizeDoc(source, options) {
+  assertDocWithinConversionLimits(source.doc, options.limits, options.signal);
   let container = source.container;
   if (!container) {
     const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
     const { docToMarkdown } = await import("@bendyline/squisq/doc");
     const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
     const mem = new MemoryContentContainer();
-    await mem.writeDocument(stringifyMarkdown(docToMarkdown(source.doc)));
+    await mem.writeDocument(
+      stringifyMarkdown(docToMarkdown(source.doc), stringifyOptions(options))
+    );
     container = mem;
   }
   const baseName = source.baseName ?? "document";
@@ -631,7 +781,7 @@ async function normalize(source, options, registry) {
     case "markdown":
       return normalizeMarkdown(source, options);
     case "doc":
-      return normalizeDoc(source);
+      return normalizeDoc(source, options);
   }
 }
 async function applyTransformStyle(input, transformStyle, themeId, registry) {
@@ -758,10 +908,11 @@ async function convert(source, to, options = {}) {
 
 export {
   BUILTIN_FORMAT_IDS,
+  DEFAULT_CONVERSION_LIMITS,
+  resolveConversionLimits,
   defaultFormats,
   createRegistry,
   defaultRegistry,
   prepareConversion,
   convert
 };
-//# sourceMappingURL=chunk-WQSHGBLN.js.map

package/dist/{chunk-KURGXM4I.js → chunk-4V3KCHAP.js}

@@ -1,7 +1,7 @@
 import {
   escapeXml,
   xmlDeclaration
-} from "./chunk-U4MRIFKL.js";
+} from "./chunk-JU2RHXUB.js";
 import {
   CONTENT_TYPE_CORE_PROPERTIES,
   CONTENT_TYPE_RELATIONSHIPS,
@@ -12,10 +12,10 @@ import {
   NS_RELATIONSHIPS,
   NS_XSI,
   REL_CORE_PROPERTIES
-} from "./chunk-7ARKUCQT.js";
+} from "./chunk-X2DEAXNK.js";
 import {
   assertSafeZipPath
-} from "./chunk-FE6OJV6O.js";
+} from "./chunk-7AWFHP5U.js";
 
 // src/ooxml/writer.ts
 import JSZip from "jszip";
@@ -192,4 +192,3 @@ function groupRelationshipsBySource(pending) {
 export {
   createPackage
 };
-//# sourceMappingURL=chunk-KURGXM4I.js.map

package/dist/{chunk-MLX2BOJC.js → chunk-6RQOV3B3.js}

@@ -1,6 +1,6 @@
 import {
   extToMime
-} from "./chunk-O3GVVND4.js";
+} from "./chunk-AONELFLA.js";
 
 // src/html/imageUtils.ts
 function inferMimeType(filename) {
@@ -31,4 +31,3 @@ export {
   arrayBufferToBase64DataUrl,
   extractFilename
 };
-//# sourceMappingURL=chunk-MLX2BOJC.js.map

package/dist/{chunk-EW54IRRS.js → chunk-6S6GU3ZG.js}

@@ -1,19 +1,19 @@
 import {
   ConversionError
-} from "./chunk-ODL3SSPT.js";
+} from "./chunk-KXOZMWBS.js";
 import {
   extractDocxTheme,
   extractPptxTheme,
   extractXlsxTheme
-} from "./chunk-74GO3FVS.js";
+} from "./chunk-PU7REGWV.js";
 import {
   colorHintsFromExtraction,
   compileExtractedTheme
-} from "./chunk-NKAJPJ4G.js";
+} from "./chunk-2JJ5RFDZ.js";
 import {
   openPackage,
   throwIfOoxmlAborted
-} from "./chunk-7ARKUCQT.js";
+} from "./chunk-X2DEAXNK.js";
 
 // src/infer/index.ts
 async function looksLikePdf(data, signal) {
@@ -107,7 +107,7 @@ async function inferThemeFromFile(data, options = {}) {
     if (format !== "pptx") {
       warnings.push("Layout inference is only available for PowerPoint files; skipped.");
     } else {
-      const { analyzePptxLayouts } = await import("./layouts-5VDIRPIJ.js");
+      const { analyzePptxLayouts } = await import("./layouts-DRWZGSPD.js");
       const analysis = await analyzePptxLayouts(pkg, {
         colors: colorHintsFromExtraction(extraction),
         signal: options.signal
@@ -124,4 +124,3 @@ async function inferThemeFromFile(data, options = {}) {
 export {
   inferThemeFromFile
 };
-//# sourceMappingURL=chunk-EW54IRRS.js.map

package/dist/{chunk-FE6OJV6O.js → chunk-7AWFHP5U.js}

@@ -555,6 +555,6 @@ function makeCrcTable() {
 export {
   ZipSafetyError,
   assertSafeZipPath,
+  resolveZipSafetyLimits,
   openBoundedZipArchive
 };
-//# sourceMappingURL=chunk-FE6OJV6O.js.map

package/dist/{chunk-RFAPOKHJ.js → chunk-AD2WT564.js}

@@ -1,27 +1,54 @@
 // src/csv/index.ts
 import { markdownToDoc } from "@bendyline/squisq/doc";
+var DEFAULT_MAX_CSV_CELLS = 1e5;
+var DEFAULT_MAX_CSV_ROWS = 1e4;
+var DEFAULT_MAX_CSV_FIELD_CHARS = 1024 * 1024;
 async function toText(data) {
   if (typeof data === "string") return data;
   if (typeof Blob !== "undefined" && data instanceof Blob) return data.text();
   return new TextDecoder().decode(new Uint8Array(data));
 }
-function parseCsv(text, delimiter = ",") {
+function validateDelimiter(delimiter) {
+  if ([...delimiter].length !== 1 || /["\r\n\uFEFF]/u.test(delimiter)) {
+    throw new TypeError(
+      "CSV delimiter must be exactly one character and cannot be a quote, line break, or BOM"
+    );
+  }
+  return delimiter;
+}
+function parseCsv(text, delimiter = ",", limits = {}) {
+  delimiter = validateDelimiter(delimiter);
+  const maxCells = safetyInteger("maxCells", limits.maxCells ?? DEFAULT_MAX_CSV_CELLS);
+  const maxRows = safetyInteger("maxRows", limits.maxRows ?? DEFAULT_MAX_CSV_ROWS);
+  const maxFieldChars = safetyInteger(
+    "maxFieldChars",
+    limits.maxFieldChars ?? DEFAULT_MAX_CSV_FIELD_CHARS
+  );
   const rows = [];
   let row = [];
   let field = "";
   let inQuotes = false;
   let sawAny = false;
+  let cellCount = 0;
   const pushField = () => {
+    if (++cellCount > maxCells)
+      throw new RangeError(`CSV exceeds the ${maxCells}-cell safety limit`);
     row.push(field);
     field = "";
   };
   const pushRow = () => {
+    if (rows.length >= maxRows) throw new RangeError(`CSV exceeds the ${maxRows}-row safety limit`);
     pushField();
     rows.push(row);
     row = [];
   };
   for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
+    if ((i & 16383) === 0) limits.signal?.throwIfAborted();
+    let ch = text[i];
+    if (delimiter.length === 2 && text.slice(i, i + 2) === delimiter) {
+      ch = delimiter;
+      i++;
+    }
     if (inQuotes) {
       if (ch === '"') {
         if (text[i + 1] === '"') {
@@ -32,6 +59,9 @@ function parseCsv(text, delimiter = ",") {
         }
       } else {
         field += ch;
+        if (field.length > maxFieldChars) {
+          throw new RangeError(`CSV field exceeds the ${maxFieldChars}-character safety limit`);
+        }
       }
       continue;
     }
@@ -53,10 +83,19 @@ function parseCsv(text, delimiter = ",") {
     }
     sawAny = true;
     field += ch;
+    if (field.length > maxFieldChars) {
+      throw new RangeError(`CSV field exceeds the ${maxFieldChars}-character safety limit`);
+    }
   }
   if (field !== "" || row.length > 0 || sawAny) pushRow();
   return rows;
 }
+function safetyInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+}
 function rowsToTable(rows, hasHeader) {
   const maxCols = rows.reduce((m, r) => Math.max(m, r.length), 1);
   const mdRows = rows.map((cells, rowIdx) => {
@@ -74,8 +113,8 @@ function rowsToTable(rows, hasHeader) {
   return { type: "table", children: mdRows };
 }
 async function csvToMarkdownDoc(data, options = {}) {
-  const text = await toText(data);
-  const rows = parseCsv(text, options.delimiter ?? ",");
+  const text = (await toText(data)).replace(/^\uFEFF/, "");
+  const rows = parseCsv(text, options.delimiter ?? ",", options);
   const hasHeader = options.hasHeader ?? true;
   const children = rows.length > 0 ? [rowsToTable(rows, hasHeader)] : [];
   return { type: "document", children };
@@ -89,6 +128,11 @@ function escapeCsvField(value, delimiter) {
   }
   return value;
 }
+var SPREADSHEET_FORMULA_PREFIX = /^[\t\r\n \uFEFF]*[=+\-@]/;
+function neutralizeSpreadsheetFormula(value, handling) {
+  if (handling === "preserve" || !SPREADSHEET_FORMULA_PREFIX.test(value)) return value;
+  return `'${value}`;
+}
 function cellText(cell) {
   const walk = (nodes) => nodes.map((n) => {
     const node = n;
@@ -99,7 +143,8 @@ function cellText(cell) {
   return walk(cell.children);
 }
 function markdownDocToCsv(doc, options = {}) {
-  const delimiter = options.delimiter ?? ",";
+  const delimiter = validateDelimiter(options.delimiter ?? ",");
+  const formulaHandling = options.formulaHandling ?? "escape";
   const tables = doc.children.filter((n) => n.type === "table");
   const index = options.tableIndex ?? 0;
   if (options.tableIndex !== void 0 && (!Number.isInteger(index) || index < 0 || index >= tables.length)) {
@@ -109,9 +154,15 @@ function markdownDocToCsv(doc, options = {}) {
   }
   const table = tables[index];
   if (!table) return "";
-  return table.children.map(
-    (row) => row.children.map((cell) => escapeCsvField(cellText(cell), delimiter)).join(delimiter)
-  ).join("\r\n");
+  const maxCells = safetyInteger("maxCells", options.maxCells ?? DEFAULT_MAX_CSV_CELLS);
+  const cellCount = table.children.reduce((count, row) => count + row.children.length, 0);
+  if (cellCount > maxCells) throw new RangeError(`CSV exceeds the ${maxCells}-cell safety limit`);
+  return table.children.map((row, rowIndex) => {
+    if ((rowIndex & 255) === 0) options.signal?.throwIfAborted();
+    return row.children.map(
+      (cell) => escapeCsvField(neutralizeSpreadsheetFormula(cellText(cell), formulaHandling), delimiter)
+    ).join(delimiter);
+  }).join("\r\n");
 }
 
 export {
@@ -120,4 +171,3 @@ export {
   csvToDoc,
   markdownDocToCsv
 };
-//# sourceMappingURL=chunk-RFAPOKHJ.js.map

package/dist/{chunk-O3GVVND4.js → chunk-AONELFLA.js}

@@ -30,4 +30,3 @@ function extToMime(ext) {
 export {
   extToMime
 };
-//# sourceMappingURL=chunk-O3GVVND4.js.map