@bendyline/squisq-formats 2.0.1 → 2.2.0

package/dist/{chunk-GVS2XXV6.js → chunk-PJXJI2LY.js}

@@ -1,11 +1,314 @@
 import {
   buildContainer
-} from "./chunk-SSUPBUF5.js";
+} from "./chunk-IIQYS2YH.js";
 
 // src/pdf/export.ts
-import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
+import { PDFDocument, StandardFonts, rgb, PDFString } from "pdf-lib";
 import { docToMarkdown, resolveThemeForDoc } from "@bendyline/squisq/doc";
-import { readFrontmatterThemeId } from "@bendyline/squisq/markdown";
+import { readFrontmatterThemeId, sanitizeUrl } from "@bendyline/squisq/markdown";
+
+// src/pdf/winAnsi.ts
+var CP1252_HIGH_SPECIALS = /* @__PURE__ */ new Set([
+  8364,
+  // euro sign
+  8218,
+  // single low-9 quotation mark
+  402,
+  // latin small letter f with hook
+  8222,
+  // double low-9 quotation mark
+  8230,
+  // horizontal ellipsis
+  8224,
+  // dagger
+  8225,
+  // double dagger
+  710,
+  // modifier letter circumflex accent
+  8240,
+  // per mille sign
+  352,
+  // latin capital letter S with caron
+  8249,
+  // single left-pointing angle quotation mark
+  338,
+  // latin capital ligature OE
+  381,
+  // latin capital letter Z with caron
+  8216,
+  // left single quotation mark
+  8217,
+  // right single quotation mark
+  8220,
+  // left double quotation mark
+  8221,
+  // right double quotation mark
+  8226,
+  // bullet
+  8211,
+  // en dash
+  8212,
+  // em dash
+  732,
+  // small tilde
+  8482,
+  // trade mark sign
+  353,
+  // latin small letter s with caron
+  8250,
+  // single right-pointing angle quotation mark
+  339,
+  // latin small ligature oe
+  382,
+  // latin small letter z with caron
+  376
+  // latin capital letter Y with diaeresis
+]);
+function isWinAnsiEncodable(codePoint) {
+  if (codePoint >= 32 && codePoint <= 126) return true;
+  if (codePoint >= 160 && codePoint <= 255) return true;
+  return CP1252_HIGH_SPECIALS.has(codePoint);
+}
+var WINANSI_REPLACEMENT = "?";
+var TRANSLITERATIONS = /* @__PURE__ */ new Map([
+  // ── Whitespace & invisibles ──
+  // A tab keeps its visual width (code fences are the common case); every
+  // other control/format character collapses to a space or disappears.
+  [9, "    "],
+  // tab
+  [10, " "],
+  // line feed
+  [11, " "],
+  // vertical tab
+  [12, " "],
+  // form feed
+  [13, " "],
+  // carriage return
+  [133, " "],
+  // next line
+  [8232, " "],
+  // line separator
+  [8233, " "],
+  // paragraph separator
+  [8192, " "],
+  // en quad
+  [8193, " "],
+  // em quad
+  [8194, " "],
+  // en space
+  [8195, " "],
+  // em space
+  [8196, " "],
+  // three-per-em space
+  [8197, " "],
+  // four-per-em space
+  [8198, " "],
+  // six-per-em space
+  [8199, " "],
+  // figure space
+  [8200, " "],
+  // punctuation space
+  [8201, " "],
+  // thin space
+  [8202, " "],
+  // hair space
+  [8239, " "],
+  // narrow no-break space
+  [8287, " "],
+  // medium mathematical space
+  [12288, " "],
+  // ideographic space
+  [8203, ""],
+  // zero-width space
+  [8204, ""],
+  // zero-width non-joiner
+  [8205, ""],
+  // zero-width joiner
+  [8288, ""],
+  // word joiner
+  [65279, ""],
+  // zero-width no-break space / BOM
+  // ── Dashes & hyphens (en/em dash ARE encodable and stay verbatim) ──
+  [8208, "-"],
+  // hyphen
+  [8209, "-"],
+  // non-breaking hyphen
+  [8210, "-"],
+  // figure dash
+  [8213, "--"],
+  // horizontal bar
+  [8722, "-"],
+  // minus sign
+  // ── Quotes & primes (curly quotes ARE encodable and stay verbatim) ──
+  [8242, "'"],
+  // prime
+  [8243, '"'],
+  // double prime
+  [8245, "'"],
+  // reversed prime
+  [8246, '"'],
+  // reversed double prime
+  // ── Arrows ──
+  [8592, "<-"],
+  // leftwards arrow
+  [8593, "^"],
+  // upwards arrow
+  [8594, "->"],
+  // rightwards arrow
+  [8595, "v"],
+  // downwards arrow
+  [8596, "<->"],
+  // left right arrow
+  [8656, "<="],
+  // leftwards double arrow
+  [8658, "=>"],
+  // rightwards double arrow
+  [8660, "<=>"],
+  // left right double arrow
+  // ── Math & comparison ──
+  [8800, "!="],
+  // not equal to
+  [8804, "<="],
+  // less-than or equal to
+  [8805, ">="],
+  // greater-than or equal to
+  [8776, "~="],
+  // almost equal to
+  [8801, "=="],
+  // identical to
+  [8734, "inf"],
+  // infinity
+  [8730, "sqrt"],
+  // square root
+  [8721, "sum"],
+  // n-ary summation
+  [8719, "prod"],
+  // n-ary product
+  [8260, "/"],
+  // fraction slash
+  // ── Bullets & marks (U+2022 bullet IS encodable) ──
+  [8227, "*"],
+  // triangular bullet
+  [8259, "-"],
+  // hyphen bullet
+  [8729, "*"],
+  // bullet operator
+  [9642, "*"],
+  // black small square
+  [9643, "*"],
+  // white small square
+  [9675, "o"],
+  // white circle
+  [9679, "*"],
+  // black circle
+  [9702, "o"],
+  // white bullet
+  [10003, "v"],
+  // check mark
+  [10004, "v"],
+  // heavy check mark
+  [10007, "x"],
+  // ballot x
+  [10008, "x"],
+  // heavy ballot x
+  // ── Ellipsis variants (U+2026 itself IS encodable) ──
+  [8229, ".."],
+  // two dot leader
+  [8943, "..."],
+  // midline horizontal ellipsis
+  // ── Ligatures ──
+  [64256, "ff"],
+  [64257, "fi"],
+  [64258, "fl"],
+  [64259, "ffi"],
+  [64260, "ffl"]
+]);
+var WHITESPACE_LIKE = /* @__PURE__ */ new Set([
+  9,
+  10,
+  11,
+  12,
+  13,
+  133,
+  8232,
+  8233,
+  8192,
+  8193,
+  8194,
+  8195,
+  8196,
+  8197,
+  8198,
+  8199,
+  8200,
+  8201,
+  8202,
+  8239,
+  8287,
+  12288,
+  8203,
+  8204,
+  8205,
+  8288,
+  65279
+]);
+var MAX_SAMPLES = 5;
+var ASCII_ONLY = /^[\x20-\x7e]*$/;
+var COMBINING_MARKS = /[̀-ͯ]/g;
+function stripDiacritics(ch) {
+  const decomposed = ch.normalize("NFKD").replace(COMBINING_MARKS, "");
+  if (!decomposed) return void 0;
+  for (const c of decomposed) {
+    if (!isWinAnsiEncodable(c.codePointAt(0))) return void 0;
+  }
+  return decomposed;
+}
+function sanitizeWinAnsi(input) {
+  if (ASCII_ONLY.test(input)) return { text: input, substitutions: 0, samples: [] };
+  const text = input.normalize("NFC");
+  let out = "";
+  let substitutions = 0;
+  const samples = [];
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (isWinAnsiEncodable(cp)) {
+      out += ch;
+      continue;
+    }
+    const mapped = TRANSLITERATIONS.get(cp) ?? stripDiacritics(ch) ?? WINANSI_REPLACEMENT;
+    out += mapped;
+    if (WHITESPACE_LIKE.has(cp)) continue;
+    substitutions++;
+    const sample = `"${ch}" -> "${mapped}"`;
+    if (samples.length < MAX_SAMPLES && !samples.includes(sample)) samples.push(sample);
+  }
+  return { text: out, substitutions, samples };
+}
+var WinAnsiTracker = class {
+  constructor() {
+    this.count = 0;
+    this.samples = [];
+  }
+  /** Sanitize `text` for pdf-lib and record any substitutions. */
+  clean(text) {
+    const result = sanitizeWinAnsi(text);
+    this.count += result.substitutions;
+    for (const sample of result.samples) {
+      if (this.samples.length >= MAX_SAMPLES) break;
+      if (!this.samples.includes(sample)) this.samples.push(sample);
+    }
+    return result.text;
+  }
+  /** Total substituted characters across the export. */
+  get substitutions() {
+    return this.count;
+  }
+  /** One-shot summary for the export, or undefined when nothing was lost. */
+  warning() {
+    if (this.count === 0) return void 0;
+    return `PDF export replaced ${this.count} character(s) that the standard PDF fonts cannot encode (${this.samples.join(", ")}). Scripts such as emoji, CJK and Cyrillic require an embedded Unicode font.`;
+  }
+};
 
 // src/pdf/styles.ts
 var PAGE_WIDTH_LETTER = 612;
@@ -72,6 +375,7 @@ var IMPORT_URL_PATTERN = /https?:\/\/[^\s)>\]]+/g;
 
 // src/pdf/export.ts
 async function markdownDocToPdf(doc, options = {}) {
+  options.signal?.throwIfAborted();
   const pdfDoc = await PDFDocument.create();
   if (options.title) pdfDoc.setTitle(options.title);
   if (options.author) pdfDoc.setAuthor(options.author);
@@ -79,6 +383,11 @@ async function markdownDocToPdf(doc, options = {}) {
   pdfDoc.setModificationDate(/* @__PURE__ */ new Date());
   const ctx = await createExportContext(pdfDoc, options, doc);
   renderBlocks(doc.children, ctx, 0);
+  const warning = ctx.text.warning();
+  if (warning) {
+    if (options.onWarning) options.onWarning(warning);
+    else console.warn(warning);
+  }
   const bytes = await pdfDoc.save();
   return bytes.buffer;
 }
@@ -124,7 +433,9 @@ async function createExportContext(pdfDoc, options, doc) {
     y: pageHeight - margin,
     contentWidth: pageWidth - 2 * margin,
     bottomY: margin,
-    colors: { text: colorText, heading: colorHeading, link: colorLink }
+    colors: { text: colorText, heading: colorHeading, link: colorLink },
+    text: new WinAnsiTracker(),
+    signal: options.signal
   };
 }
 function ensureSpace(ctx, needed) {
@@ -144,7 +455,7 @@ function flattenInlines(nodes, ctx, state) {
       case "text": {
         const font = state.code ? state.bold ? ctx.fonts.monoBold : ctx.fonts.mono : pickFont(ctx, state.bold, state.italic);
         spans.push({
-          text: node.value,
+          text: ctx.text.clean(node.value),
           font,
           fontSize: state.code ? CODE_FONT_SIZE : ctx.fontSize,
           color: state.code ? COLOR_CODE_TEXT : state.color ?? ctx.colors.text,
@@ -173,7 +484,7 @@ function flattenInlines(nodes, ctx, state) {
         break;
       case "inlineCode": {
         spans.push({
-          text: node.value,
+          text: ctx.text.clean(node.value),
           font: ctx.fonts.mono,
           fontSize: CODE_FONT_SIZE,
           color: COLOR_CODE_TEXT,
@@ -183,11 +494,12 @@ function flattenInlines(nodes, ctx, state) {
       }
       case "link": {
         const linkNode = node;
+        const safeLink = sanitizeUrl(linkNode.url, "link") ?? void 0;
         spans.push(
           ...flattenInlines(linkNode.children, ctx, {
             ...state,
-            link: linkNode.url,
-            color: ctx.colors.link
+            link: safeLink,
+            color: safeLink ? ctx.colors.link : state.color
           })
         );
         break;
@@ -195,7 +507,7 @@ function flattenInlines(nodes, ctx, state) {
       case "image": {
         const imgNode = node;
         spans.push({
-          text: imgNode.alt ? `[Image: ${imgNode.alt}]` : "[Image]",
+          text: ctx.text.clean(imgNode.alt ? `[Image: ${imgNode.alt}]` : "[Image]"),
           font: ctx.fonts.italic,
           fontSize: ctx.fontSize,
           color: COLOR_BLOCKQUOTE_TEXT
@@ -214,7 +526,7 @@ function flattenInlines(nodes, ctx, state) {
         const html = node.rawHtml;
         if (html) {
           spans.push({
-            text: html,
+            text: ctx.text.clean(html),
             font: ctx.fonts.mono,
             fontSize: CODE_FONT_SIZE,
             color: COLOR_CODE_TEXT
@@ -224,7 +536,7 @@ function flattenInlines(nodes, ctx, state) {
       }
       case "inlineMath":
         spans.push({
-          text: node.value,
+          text: ctx.text.clean(node.value),
           font: ctx.fonts.mono,
           fontSize: CODE_FONT_SIZE,
           color: COLOR_CODE_TEXT
@@ -233,7 +545,7 @@ function flattenInlines(nodes, ctx, state) {
       case "footnoteReference": {
         const ref = node;
         spans.push({
-          text: `[${ref.identifier}]`,
+          text: ctx.text.clean(`[${ref.identifier}]`),
           font: ctx.fonts.regular,
           fontSize: ctx.fontSize * 0.75,
           color: ctx.colors.link
@@ -247,7 +559,7 @@ function flattenInlines(nodes, ctx, state) {
           spans.push(...flattenInlines(fallback.children, ctx, state));
         } else if (fallback.value) {
           spans.push({
-            text: fallback.value,
+            text: ctx.text.clean(fallback.value),
             font: pickFont(ctx, state.bold, state.italic),
             fontSize: ctx.fontSize,
             color: state.color ?? ctx.colors.text
@@ -283,12 +595,27 @@ function drawSpans(spans, ctx, availableWidth, x0) {
       });
       const textWidth = span.font.widthOfTextAtSize(span.text, span.fontSize);
       if (span.link) {
+        const baseline = ctx.y - span.fontSize;
         ctx.page.drawLine({
-          start: { x, y: ctx.y - span.fontSize - 1 },
-          end: { x: x + textWidth, y: ctx.y - span.fontSize - 1 },
+          start: { x, y: baseline - 1 },
+          end: { x: x + textWidth, y: baseline - 1 },
           thickness: 0.5,
           color: rgb(span.color.r, span.color.g, span.color.b)
         });
+        const annotation = ctx.pdfDoc.context.register(
+          ctx.pdfDoc.context.obj({
+            Type: "Annot",
+            Subtype: "Link",
+            Rect: [x, baseline - 2, x + textWidth, baseline + span.fontSize + 2],
+            Border: [0, 0, 0],
+            A: {
+              Type: "Action",
+              S: "URI",
+              URI: PDFString.of(span.link)
+            }
+          })
+        );
+        ctx.page.node.addAnnot(annotation);
       }
       if (span.strikethrough) {
         const midY = ctx.y - span.fontSize * 0.6;
@@ -360,7 +687,9 @@ function getLineHeight(line) {
   return (maxSize || DEFAULT_FONT_SIZE) * LINE_HEIGHT_FACTOR;
 }
 function renderBlocks(nodes, ctx, extraIndent) {
-  for (const node of nodes) {
+  for (let index = 0; index < nodes.length; index++) {
+    if ((index & 255) === 0) ctx.signal?.throwIfAborted();
+    const node = nodes[index];
     renderBlock(node, ctx, extraIndent);
   }
 }
@@ -499,7 +828,7 @@ function renderListItem(item, ctx, extraIndent, depth, ordered, counter) {
 function renderCodeBlock(node, ctx, extraIndent) {
   const x0 = ctx.margin + extraIndent;
   const _w = ctx.contentWidth - extraIndent;
-  const lines = node.value.split("\n");
+  const lines = node.value.split("\n").map((line) => ctx.text.clean(line));
   const lineH = CODE_FONT_SIZE * LINE_HEIGHT_FACTOR;
   const totalHeight = lines.length * lineH + 12;
   ensureSpace(ctx, Math.min(totalHeight, ctx.y - ctx.bottomY));
@@ -615,7 +944,7 @@ function renderThematicBreak(ctx, extraIndent) {
 }
 function renderHtmlBlock(node, ctx, extraIndent) {
   if (!node.rawHtml) return;
-  const lines = node.rawHtml.split("\n");
+  const lines = node.rawHtml.split("\n").map((line) => ctx.text.clean(line));
   const x0 = ctx.margin + extraIndent;
   for (const line of lines) {
     if (line.trim().length === 0) continue;
@@ -633,7 +962,7 @@ function renderHtmlBlock(node, ctx, extraIndent) {
   ctx.y -= PARAGRAPH_SPACING;
 }
 function renderMathBlock(node, ctx, extraIndent) {
-  const lines = node.value.split("\n");
+  const lines = node.value.split("\n").map((line) => ctx.text.clean(line));
   const x0 = ctx.margin + extraIndent;
   for (const line of lines) {
     const lineH = CODE_FONT_SIZE * LINE_HEIGHT_FACTOR;
@@ -652,7 +981,7 @@ function renderMathBlock(node, ctx, extraIndent) {
   ctx.y -= PARAGRAPH_SPACING;
 }
 function renderFootnoteDefinition(node, ctx, extraIndent) {
-  const label = `[${node.identifier}]`;
+  const label = ctx.text.clean(`[${node.identifier}]`);
   const lineH = ctx.fontSize * LINE_HEIGHT_FACTOR;
   ensureSpace(ctx, lineH);
   ctx.page.drawText(label, {
@@ -694,7 +1023,7 @@ function renderFallbackBlock(node, ctx, extraIndent) {
   } else if (fallback.value && typeof fallback.value === "string") {
     const lineH = ctx.fontSize * LINE_HEIGHT_FACTOR;
     ensureSpace(ctx, lineH);
-    ctx.page.drawText(fallback.value, {
+    ctx.page.drawText(ctx.text.clean(fallback.value), {
       x: ctx.margin + extraIndent,
       y: ctx.y - ctx.fontSize,
       size: ctx.fontSize,
@@ -717,11 +1046,13 @@ function hexToRgb(hex) {
 // src/pdf/import.ts
 import { markdownToDoc } from "@bendyline/squisq/doc";
 import { stringifyMarkdown } from "@bendyline/squisq/markdown";
+import UPNG from "@pdf-lib/upng";
 async function pdfToMarkdownDoc(data, options = {}) {
+  options.signal?.throwIfAborted();
   const bytes = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-  const loaded = await loadPdfDocument(bytes);
+  const loaded = await loadPdfDocument(bytes, options.signal);
   try {
-    const textLines = await extractTextLines(loaded.pdf);
+    const textLines = await extractTextLines(loaded.pdf, options);
     if (textLines.length === 0) {
       return { type: "document", children: [] };
     }
@@ -737,12 +1068,16 @@ async function pdfToDoc(data, options = {}) {
   return markdownToDoc(markdownDoc);
 }
 async function pdfToContainer(data, options = {}) {
+  options.signal?.throwIfAborted();
   const bytes = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-  const loaded = await loadPdfDocument(bytes);
+  const loaded = await loadPdfDocument(bytes, options.signal);
   let textLines;
   let images;
   try {
-    [textLines, images] = await Promise.all([extractTextLines(loaded.pdf), extractImages(loaded)]);
+    [textLines, images] = await Promise.all([
+      extractTextLines(loaded.pdf, options),
+      extractImages(loaded, options)
+    ]);
   } finally {
     await loaded.pdf.destroy?.();
   }
@@ -758,25 +1093,48 @@ async function pdfToContainer(data, options = {}) {
     images.map((img) => [img.path, { data: img.data, mimeType: "image/png" }])
   );
 }
-async function extractImages(loaded) {
-  if (typeof document === "undefined") return [];
+async function extractImages(loaded, options) {
   const { pdfjsLib, pdf } = loaded;
   const OPS_paintImageXObject = pdfjsLib.OPS?.paintImageXObject ?? 85;
+  const OPS_paintInlineImageXObject = pdfjsLib.OPS?.paintInlineImageXObject ?? 86;
   const images = [];
   let counter = 0;
+  let totalPixels = 0;
+  const maxPages = safetyLimit("maxPages", options.maxPages ?? 5e3);
+  const maxImagePixels = safetyLimit("maxImagePixels", options.maxImagePixels ?? 1e8);
+  if (pdf.numPages > maxPages)
+    throw new RangeError(`PDF exceeds the ${maxPages}-page safety limit`);
   for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+    options.signal?.throwIfAborted();
     const page = await pdf.getPage(pageNum);
     if (!page.getOperatorList) continue;
     const opList = await page.getOperatorList();
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < opList.fnArray.length; i++) {
-      if (opList.fnArray[i] !== OPS_paintImageXObject) continue;
-      const imgName = opList.argsArray[i]?.[0];
-      if (!imgName || typeof imgName !== "string" || seen.has(imgName)) continue;
-      seen.add(imgName);
+      const operation = opList.fnArray[i];
+      if (operation !== OPS_paintImageXObject && operation !== OPS_paintInlineImageXObject)
+        continue;
+      const operand = opList.argsArray[i]?.[0];
+      let imgData = null;
+      if (operation === OPS_paintImageXObject) {
+        if (!operand || typeof operand !== "string" || seen.has(operand)) continue;
+        seen.add(operand);
+        try {
+          imgData = await getPdfImageObject(page.objs, operand, options.signal);
+        } catch {
+          continue;
+        }
+      } else if (operand && typeof operand === "object") {
+        imgData = operand;
+      }
       try {
-        const imgData = page.objs?.get(imgName);
         if (!imgData?.data || !imgData.width || !imgData.height) continue;
+        totalPixels += imgData.width * imgData.height;
+        if (totalPixels > maxImagePixels) {
+          throw new RangeError(
+            `PDF decoded images exceed the ${maxImagePixels}-pixel safety limit`
+          );
+        }
         const pngData = imageDataToPng(imgData);
         if (!pngData) continue;
         counter++;
@@ -786,52 +1144,69 @@ async function extractImages(loaded) {
           page: pageNum - 1,
           y: 0
         });
-      } catch {
+      } catch (error) {
+        if (error instanceof RangeError) throw error;
       }
     }
   }
   return images;
 }
+function getPdfImageObject(objects, name, signal) {
+  if (!objects) return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      reject(signal?.reason ?? new DOMException("PDF image extraction cancelled", "AbortError"));
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      const immediate = objects.get(name, finish);
+      if (immediate !== void 0 && immediate !== null) finish(immediate);
+    } catch (error) {
+      signal?.removeEventListener("abort", onAbort);
+      reject(error);
+    }
+  });
+}
 function imageDataToPng(img) {
   try {
-    const canvas = document.createElement("canvas");
-    canvas.width = img.width;
-    canvas.height = img.height;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return null;
-    let imageData;
+    let rgba;
     if (img.kind === 3 || img.data.length === img.width * img.height * 4) {
-      imageData = new ImageData(new Uint8ClampedArray(img.data), img.width, img.height);
+      rgba = new Uint8ClampedArray(img.data);
     } else if (img.kind === 2 || img.data.length === img.width * img.height * 3) {
-      const rgba = new Uint8ClampedArray(img.width * img.height * 4);
+      rgba = new Uint8ClampedArray(img.width * img.height * 4);
       for (let j = 0, k = 0; j < img.data.length; j += 3, k += 4) {
         rgba[k] = img.data[j];
         rgba[k + 1] = img.data[j + 1];
         rgba[k + 2] = img.data[j + 2];
         rgba[k + 3] = 255;
       }
-      imageData = new ImageData(rgba, img.width, img.height);
     } else if (img.kind === 1 || img.data.length === img.width * img.height) {
-      const rgba = new Uint8ClampedArray(img.width * img.height * 4);
+      rgba = new Uint8ClampedArray(img.width * img.height * 4);
       for (let j = 0, k = 0; j < img.data.length; j++, k += 4) {
         rgba[k] = img.data[j];
         rgba[k + 1] = img.data[j];
         rgba[k + 2] = img.data[j];
         rgba[k + 3] = 255;
       }
-      imageData = new ImageData(rgba, img.width, img.height);
     } else {
       return null;
     }
-    ctx.putImageData(imageData, 0, 0);
-    const dataUrl = canvas.toDataURL("image/png");
-    const base64 = dataUrl.split(",")[1];
-    const binaryStr = atob(base64);
-    const bytes = new Uint8Array(binaryStr.length);
-    for (let i = 0; i < binaryStr.length; i++) {
-      bytes[i] = binaryStr.charCodeAt(i);
-    }
-    return bytes.buffer;
+    const owned = new Uint8Array(rgba.byteLength);
+    owned.set(rgba);
+    return UPNG.encode([owned.buffer], img.width, img.height, 0);
   } catch {
     return null;
   }
@@ -891,7 +1266,8 @@ async function applyWorkerConfig(pdfjsLib) {
     pdfjsLib.GlobalWorkerOptions.workerSrc = _workerSrc;
   }
 }
-async function loadPdfDocument(data) {
+async function loadPdfDocument(data, signal) {
+  signal?.throwIfAborted();
   let pdfjsLib;
   try {
     pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs");
@@ -904,16 +1280,27 @@ async function loadPdfDocument(data) {
     isEvalSupported: false,
     useSystemFonts: true
   });
-  return { pdfjsLib, pdf: await loadingTask.promise };
+  const pdf = await loadingTask.promise;
+  signal?.throwIfAborted();
+  return { pdfjsLib, pdf };
 }
-async function extractTextLines(pdf) {
+async function extractTextLines(pdf, options) {
   const allLines = [];
+  const maxPages = safetyLimit("maxPages", options.maxPages ?? 5e3);
+  const maxTextItems = safetyLimit("maxTextItems", options.maxTextItems ?? 1e6);
+  let textItemCount = 0;
+  if (pdf.numPages > maxPages)
+    throw new RangeError(`PDF exceeds the ${maxPages}-page safety limit`);
   for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+    options.signal?.throwIfAborted();
     const page = await pdf.getPage(pageNum);
     const content = await page.getTextContent();
     const styleMap = content.styles || {};
     const items = [];
     for (const item of content.items) {
+      if (++textItemCount > maxTextItems) {
+        throw new RangeError(`PDF exceeds the ${maxTextItems}-text-item safety limit`);
+      }
       if (!item.str || item.str.trim().length === 0) continue;
       const transform = item.transform || [1, 0, 0, 1, 0, 0];
       const x = transform[4];
@@ -965,6 +1352,12 @@ async function extractTextLines(pdf) {
   }
   return allLines;
 }
+function safetyLimit(name, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+}
 function detectBodyFontSize(lines) {
   const sizes = lines.map((l) => Math.round(l.fontSize * 2) / 2);
   return mode(sizes) || DEFAULT_FONT_SIZE;
@@ -1329,4 +1722,3 @@ export {
   pdfToContainer,
   configurePdfWorker
 };
-//# sourceMappingURL=chunk-GVS2XXV6.js.map