@bendyline/squisq-formats 0.1.0

package/dist/chunk-TBPD5PCU.js

@@ -0,0 +1,1136 @@
+// src/pdf/export.ts
+import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
+import { docToMarkdown } from "@bendyline/squisq/doc";
+
+// src/pdf/styles.ts
+var PAGE_WIDTH_LETTER = 612;
+var PAGE_HEIGHT_LETTER = 792;
+var PAGE_WIDTH_A4 = 595.28;
+var PAGE_HEIGHT_A4 = 841.89;
+var DEFAULT_MARGIN = 72;
+var DEFAULT_FONT_SIZE = 11;
+var HEADING_SIZES = {
+  1: 24,
+  2: 20,
+  3: 16,
+  4: 14,
+  5: 13,
+  6: 12
+};
+var CODE_FONT_SIZE = 10;
+var LINE_HEIGHT_FACTOR = 1.4;
+var HEADING_SPACE_BEFORE = 18;
+var HEADING_SPACE_AFTER = 6;
+var PARAGRAPH_SPACING = 8;
+var LIST_INDENT = 24;
+var BULLET_CHAR = "\u2022";
+var BLOCKQUOTE_INDENT = 24;
+var BLOCKQUOTE_BAR_WIDTH = 3;
+var COLOR_TEXT = { r: 0.12, g: 0.12, b: 0.14 };
+var COLOR_HEADING = { r: 0.08, g: 0.08, b: 0.1 };
+var COLOR_LINK = { r: 0.05, g: 0.27, b: 0.73 };
+var COLOR_CODE_TEXT = { r: 0.2, g: 0.2, b: 0.22 };
+var COLOR_BLOCKQUOTE_BAR = { r: 0.75, g: 0.75, b: 0.78 };
+var COLOR_BLOCKQUOTE_TEXT = { r: 0.35, g: 0.35, b: 0.38 };
+var COLOR_THEMATIC_BREAK = { r: 0.78, g: 0.78, b: 0.8 };
+var COLOR_TABLE_BORDER = { r: 0.75, g: 0.75, b: 0.78 };
+var COLOR_TABLE_HEADER_BG = { r: 0.93, g: 0.93, b: 0.95 };
+var TABLE_CELL_PAD_X = 6;
+var TABLE_CELL_PAD_Y = 4;
+var TABLE_BORDER_WIDTH = 0.5;
+var IMPORT_HEADING_MIN_SIZE = 13;
+var IMPORT_HEADING_SIZE_RANGES = [
+  { min: 22, depth: 1 },
+  { min: 18, depth: 2 },
+  { min: 15, depth: 3 },
+  { min: 13.5, depth: 4 },
+  { min: 12.5, depth: 5 },
+  { min: 12, depth: 6 }
+];
+var IMPORT_PARAGRAPH_GAP = 4;
+var IMPORT_BULLET_CHARS = /* @__PURE__ */ new Set([
+  "\u2022",
+  "\u2023",
+  "\u25E6",
+  "\u2043",
+  "-",
+  "*",
+  "\u2013",
+  "\u2014",
+  "\u25AA",
+  "\u25AB"
+]);
+var IMPORT_ORDERED_PREFIX = /^(\d+|[a-z]+|[ivxlcdm]+)[.)]\s/i;
+var IMPORT_COLUMN_TOLERANCE = 8;
+var IMPORT_TABLE_MIN_ROWS = 2;
+var IMPORT_URL_PATTERN = /https?:\/\/[^\s)>\]]+/g;
+
+// src/pdf/export.ts
+async function markdownDocToPdf(doc, options = {}) {
+  const pdfDoc = await PDFDocument.create();
+  if (options.title) pdfDoc.setTitle(options.title);
+  if (options.author) pdfDoc.setAuthor(options.author);
+  pdfDoc.setCreationDate(/* @__PURE__ */ new Date());
+  pdfDoc.setModificationDate(/* @__PURE__ */ new Date());
+  const ctx = await createExportContext(pdfDoc, options);
+  renderBlocks(doc.children, ctx, 0);
+  const bytes = await pdfDoc.save();
+  return bytes.buffer;
+}
+async function docToPdf(doc, options = {}) {
+  const markdownDoc = docToMarkdown(doc);
+  return markdownDocToPdf(markdownDoc, options);
+}
+async function createExportContext(pdfDoc, options) {
+  const [regular, bold, italic, boldItalic, mono, monoBold] = await Promise.all([
+    pdfDoc.embedFont(StandardFonts.Helvetica),
+    pdfDoc.embedFont(StandardFonts.HelveticaBold),
+    pdfDoc.embedFont(StandardFonts.HelveticaOblique),
+    pdfDoc.embedFont(StandardFonts.HelveticaBoldOblique),
+    pdfDoc.embedFont(StandardFonts.Courier),
+    pdfDoc.embedFont(StandardFonts.CourierBold)
+  ]);
+  const isA4 = options.pageSize === "a4";
+  const pageWidth = isA4 ? PAGE_WIDTH_A4 : PAGE_WIDTH_LETTER;
+  const pageHeight = isA4 ? PAGE_HEIGHT_A4 : PAGE_HEIGHT_LETTER;
+  const margin = options.margin ?? DEFAULT_MARGIN;
+  const fontSize = options.defaultFontSize ?? DEFAULT_FONT_SIZE;
+  const page = pdfDoc.addPage([pageWidth, pageHeight]);
+  return {
+    pdfDoc,
+    fonts: { regular, bold, italic, boldItalic, mono, monoBold },
+    pageWidth,
+    pageHeight,
+    margin,
+    fontSize,
+    page,
+    y: pageHeight - margin,
+    contentWidth: pageWidth - 2 * margin,
+    bottomY: margin
+  };
+}
+function ensureSpace(ctx, needed) {
+  if (ctx.y - needed < ctx.bottomY) {
+    newPage(ctx);
+  }
+}
+function newPage(ctx) {
+  const page = ctx.pdfDoc.addPage([ctx.pageWidth, ctx.pageHeight]);
+  ctx.page = page;
+  ctx.y = ctx.pageHeight - ctx.margin;
+}
+function flattenInlines(nodes, ctx, state) {
+  const spans = [];
+  for (const node of nodes) {
+    switch (node.type) {
+      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,
+          font,
+          fontSize: state.code ? CODE_FONT_SIZE : ctx.fontSize,
+          color: state.code ? COLOR_CODE_TEXT : state.color ?? COLOR_TEXT,
+          link: state.link,
+          strikethrough: state.strikethrough
+        });
+        break;
+      }
+      case "strong":
+        spans.push(
+          ...flattenInlines(node.children, ctx, { ...state, bold: true })
+        );
+        break;
+      case "emphasis":
+        spans.push(
+          ...flattenInlines(node.children, ctx, { ...state, italic: true })
+        );
+        break;
+      case "delete":
+        spans.push(
+          ...flattenInlines(node.children, ctx, {
+            ...state,
+            strikethrough: true
+          })
+        );
+        break;
+      case "inlineCode": {
+        spans.push({
+          text: node.value,
+          font: ctx.fonts.mono,
+          fontSize: CODE_FONT_SIZE,
+          color: COLOR_CODE_TEXT,
+          link: state.link
+        });
+        break;
+      }
+      case "link": {
+        const linkNode = node;
+        spans.push(
+          ...flattenInlines(linkNode.children, ctx, {
+            ...state,
+            link: linkNode.url,
+            color: COLOR_LINK
+          })
+        );
+        break;
+      }
+      case "image": {
+        const imgNode = node;
+        spans.push({
+          text: imgNode.alt ? `[Image: ${imgNode.alt}]` : "[Image]",
+          font: ctx.fonts.italic,
+          fontSize: ctx.fontSize,
+          color: COLOR_BLOCKQUOTE_TEXT
+        });
+        break;
+      }
+      case "break":
+        spans.push({
+          text: "\n",
+          font: ctx.fonts.regular,
+          fontSize: ctx.fontSize,
+          color: COLOR_TEXT
+        });
+        break;
+      case "htmlInline": {
+        const html = node.rawHtml;
+        if (html) {
+          spans.push({
+            text: html,
+            font: ctx.fonts.mono,
+            fontSize: CODE_FONT_SIZE,
+            color: COLOR_CODE_TEXT
+          });
+        }
+        break;
+      }
+      case "inlineMath":
+        spans.push({
+          text: node.value,
+          font: ctx.fonts.mono,
+          fontSize: CODE_FONT_SIZE,
+          color: COLOR_CODE_TEXT
+        });
+        break;
+      case "footnoteReference": {
+        const ref = node;
+        spans.push({
+          text: `[${ref.identifier}]`,
+          font: ctx.fonts.regular,
+          fontSize: ctx.fontSize * 0.75,
+          color: COLOR_LINK
+        });
+        break;
+      }
+      // linkReference, imageReference, textDirective — render children or identifier
+      default: {
+        const fallback = node;
+        if (fallback.children) {
+          spans.push(...flattenInlines(fallback.children, ctx, state));
+        } else if (fallback.value) {
+          spans.push({
+            text: fallback.value,
+            font: pickFont(ctx, state.bold, state.italic),
+            fontSize: ctx.fontSize,
+            color: state.color ?? COLOR_TEXT
+          });
+        }
+        break;
+      }
+    }
+  }
+  return spans;
+}
+function pickFont(ctx, bold, italic) {
+  if (bold && italic) return ctx.fonts.boldItalic;
+  if (bold) return ctx.fonts.bold;
+  if (italic) return ctx.fonts.italic;
+  return ctx.fonts.regular;
+}
+function drawSpans(spans, ctx, availableWidth, x0) {
+  if (spans.length === 0) return;
+  const lines = wrapSpans(spans, availableWidth);
+  for (const line of lines) {
+    const lineHeight = getLineHeight(line);
+    ensureSpace(ctx, lineHeight);
+    let x = x0;
+    for (const span of line) {
+      ctx.page.drawText(span.text, {
+        x,
+        y: ctx.y - span.fontSize,
+        // pdf-lib y is baseline
+        size: span.fontSize,
+        font: span.font,
+        color: rgb(span.color.r, span.color.g, span.color.b)
+      });
+      const textWidth = span.font.widthOfTextAtSize(span.text, span.fontSize);
+      if (span.link) {
+        ctx.page.drawLine({
+          start: { x, y: ctx.y - span.fontSize - 1 },
+          end: { x: x + textWidth, y: ctx.y - span.fontSize - 1 },
+          thickness: 0.5,
+          color: rgb(span.color.r, span.color.g, span.color.b)
+        });
+      }
+      if (span.strikethrough) {
+        const midY = ctx.y - span.fontSize * 0.6;
+        ctx.page.drawLine({
+          start: { x, y: midY },
+          end: { x: x + textWidth, y: midY },
+          thickness: 0.5,
+          color: rgb(span.color.r, span.color.g, span.color.b)
+        });
+      }
+      x += textWidth;
+    }
+    ctx.y -= lineHeight;
+  }
+}
+function wrapSpans(spans, maxWidth) {
+  const lines = [];
+  let currentLine = [];
+  let lineWidth = 0;
+  for (const span of spans) {
+    if (span.text === "\n") {
+      lines.push(currentLine);
+      currentLine = [];
+      lineWidth = 0;
+      continue;
+    }
+    const words = splitIntoWords(span.text);
+    for (const word of words) {
+      const wordWidth = span.font.widthOfTextAtSize(word, span.fontSize);
+      if (lineWidth + wordWidth > maxWidth && currentLine.length > 0 && word.trim().length > 0) {
+        lines.push(currentLine);
+        currentLine = [];
+        lineWidth = 0;
+      }
+      const trimmedWord = currentLine.length === 0 ? word.replace(/^\s+/, "") : word;
+      if (trimmedWord.length > 0) {
+        const tw = span.font.widthOfTextAtSize(trimmedWord, span.fontSize);
+        currentLine.push({ ...span, text: trimmedWord });
+        lineWidth += tw;
+      }
+    }
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [[]];
+}
+function splitIntoWords(text) {
+  const tokens = [];
+  let current = "";
+  let inSpace = false;
+  for (const ch of text) {
+    const isSpace = ch === " " || ch === "	";
+    if (isSpace !== inSpace && current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+    current += ch;
+    inSpace = isSpace;
+  }
+  if (current.length > 0) tokens.push(current);
+  return tokens;
+}
+function getLineHeight(line) {
+  let maxSize = 0;
+  for (const span of line) {
+    if (span.fontSize > maxSize) maxSize = span.fontSize;
+  }
+  return (maxSize || DEFAULT_FONT_SIZE) * LINE_HEIGHT_FACTOR;
+}
+function renderBlocks(nodes, ctx, extraIndent) {
+  for (const node of nodes) {
+    renderBlock(node, ctx, extraIndent);
+  }
+}
+function renderBlock(node, ctx, extraIndent) {
+  switch (node.type) {
+    case "heading":
+      renderHeading(node, ctx, extraIndent);
+      break;
+    case "paragraph":
+      renderParagraph(node, ctx, extraIndent);
+      break;
+    case "blockquote":
+      renderBlockquote(node, ctx, extraIndent);
+      break;
+    case "list":
+      renderList(node, ctx, extraIndent, 0);
+      break;
+    case "code":
+      renderCodeBlock(node, ctx, extraIndent);
+      break;
+    case "table":
+      renderTable(node, ctx, extraIndent);
+      break;
+    case "thematicBreak":
+      renderThematicBreak(ctx, extraIndent);
+      break;
+    case "htmlBlock":
+      renderHtmlBlock(node, ctx, extraIndent);
+      break;
+    case "math":
+      renderMathBlock(node, ctx, extraIndent);
+      break;
+    case "footnoteDefinition":
+      renderFootnoteDefinition(node, ctx, extraIndent);
+      break;
+    default:
+      renderFallbackBlock(node, ctx, extraIndent);
+      break;
+  }
+}
+function renderHeading(node, ctx, extraIndent) {
+  const origFontSize = ctx.fontSize;
+  ctx.fontSize = HEADING_SIZES[node.depth] ?? DEFAULT_FONT_SIZE;
+  ctx.y -= HEADING_SPACE_BEFORE;
+  const x0 = ctx.margin + extraIndent;
+  const w = ctx.contentWidth - extraIndent;
+  const spans = flattenInlines(node.children, ctx, {
+    bold: true,
+    italic: false,
+    code: false,
+    color: COLOR_HEADING
+  });
+  drawSpans(spans, ctx, w, x0);
+  ctx.y -= HEADING_SPACE_AFTER;
+  ctx.fontSize = origFontSize;
+}
+function renderParagraph(node, ctx, extraIndent, colorOverride) {
+  const x0 = ctx.margin + extraIndent;
+  const w = ctx.contentWidth - extraIndent;
+  const spans = flattenInlines(node.children, ctx, {
+    bold: false,
+    italic: false,
+    code: false,
+    color: colorOverride
+  });
+  drawSpans(spans, ctx, w, x0);
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderBlockquote(node, ctx, extraIndent) {
+  const barX = ctx.margin + extraIndent + 4;
+  const indent = extraIndent + BLOCKQUOTE_INDENT;
+  const startY = ctx.y;
+  for (const child of node.children) {
+    if (child.type === "paragraph") {
+      renderParagraph(child, ctx, indent, COLOR_BLOCKQUOTE_TEXT);
+    } else {
+      renderBlock(child, ctx, indent);
+    }
+  }
+  const endY = ctx.y + PARAGRAPH_SPACING;
+  if (startY > endY) {
+    ctx.page.drawRectangle({
+      x: barX,
+      y: endY,
+      width: BLOCKQUOTE_BAR_WIDTH,
+      height: startY - endY,
+      color: rgb(COLOR_BLOCKQUOTE_BAR.r, COLOR_BLOCKQUOTE_BAR.g, COLOR_BLOCKQUOTE_BAR.b)
+    });
+  }
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderList(node, ctx, extraIndent, depth) {
+  const ordered = node.ordered ?? false;
+  let counter = node.start ?? 1;
+  for (const child of node.children) {
+    if (child.type === "listItem") {
+      renderListItem(child, ctx, extraIndent, depth, ordered, counter);
+      if (ordered) counter++;
+    }
+  }
+}
+function renderListItem(item, ctx, extraIndent, depth, ordered, counter) {
+  const indent = extraIndent + depth * LIST_INDENT;
+  const bullet = ordered ? `${counter}.` : BULLET_CHAR;
+  const bulletFont = ctx.fonts.regular;
+  const bulletWidth = bulletFont.widthOfTextAtSize(bullet + " ", ctx.fontSize);
+  const lineHeight = ctx.fontSize * LINE_HEIGHT_FACTOR;
+  ensureSpace(ctx, lineHeight);
+  ctx.page.drawText(bullet, {
+    x: ctx.margin + indent,
+    y: ctx.y - ctx.fontSize,
+    size: ctx.fontSize,
+    font: bulletFont,
+    color: rgb(COLOR_TEXT.r, COLOR_TEXT.g, COLOR_TEXT.b)
+  });
+  const textIndent = indent + bulletWidth + 4;
+  const textWidth = ctx.contentWidth - textIndent;
+  let isFirstChild = true;
+  for (const child of item.children) {
+    if (child.type === "paragraph" && isFirstChild) {
+      const spans = flattenInlines(child.children, ctx, {
+        bold: false,
+        italic: false,
+        code: false
+      });
+      drawSpans(spans, ctx, textWidth, ctx.margin + textIndent);
+      ctx.y -= PARAGRAPH_SPACING / 2;
+    } else if (child.type === "list") {
+      renderList(child, ctx, extraIndent, depth + 1);
+    } else {
+      renderBlock(child, ctx, textIndent);
+    }
+    isFirstChild = false;
+  }
+}
+function renderCodeBlock(node, ctx, extraIndent) {
+  const x0 = ctx.margin + extraIndent;
+  const _w = ctx.contentWidth - extraIndent;
+  const lines = node.value.split("\n");
+  const lineH = CODE_FONT_SIZE * LINE_HEIGHT_FACTOR;
+  const totalHeight = lines.length * lineH + 12;
+  ensureSpace(ctx, Math.min(totalHeight, ctx.y - ctx.bottomY));
+  const _bgTop = ctx.y;
+  const _bgStartY = ctx.y;
+  ctx.y -= 6;
+  for (const line of lines) {
+    ensureSpace(ctx, lineH);
+    if (line.length > 0) {
+      ctx.page.drawText(line, {
+        x: x0 + 8,
+        y: ctx.y - CODE_FONT_SIZE,
+        size: CODE_FONT_SIZE,
+        font: ctx.fonts.mono,
+        color: rgb(COLOR_CODE_TEXT.r, COLOR_CODE_TEXT.g, COLOR_CODE_TEXT.b)
+      });
+    }
+    ctx.y -= lineH;
+  }
+  ctx.y -= 6;
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderTable(node, ctx, extraIndent) {
+  if (node.children.length === 0) return;
+  const x0 = ctx.margin + extraIndent;
+  const tableWidth = ctx.contentWidth - extraIndent;
+  const numCols = Math.max(
+    ...node.children.map((row) => row.children.length)
+  );
+  if (numCols === 0) return;
+  const colWidth = tableWidth / numCols;
+  for (let rowIdx = 0; rowIdx < node.children.length; rowIdx++) {
+    const row = node.children[rowIdx];
+    const isHeader = rowIdx === 0 && row.children.some((c) => c.isHeader);
+    const rowCellHeights = row.children.map((cell) => {
+      const cellNode = cell;
+      const spans = flattenInlines(cellNode.children, ctx, {
+        bold: isHeader,
+        italic: false,
+        code: false
+      });
+      const lines = wrapSpans(spans, colWidth - 2 * TABLE_CELL_PAD_X);
+      return lines.length * ctx.fontSize * LINE_HEIGHT_FACTOR + 2 * TABLE_CELL_PAD_Y;
+    });
+    const rowHeight = Math.max(
+      ...rowCellHeights,
+      ctx.fontSize * LINE_HEIGHT_FACTOR + 2 * TABLE_CELL_PAD_Y
+    );
+    ensureSpace(ctx, rowHeight);
+    if (isHeader) {
+      ctx.page.drawRectangle({
+        x: x0,
+        y: ctx.y - rowHeight,
+        width: tableWidth,
+        height: rowHeight,
+        color: rgb(COLOR_TABLE_HEADER_BG.r, COLOR_TABLE_HEADER_BG.g, COLOR_TABLE_HEADER_BG.b)
+      });
+    }
+    for (let colIdx = 0; colIdx < numCols; colIdx++) {
+      const cellX = x0 + colIdx * colWidth;
+      ctx.page.drawRectangle({
+        x: cellX,
+        y: ctx.y - rowHeight,
+        width: colWidth,
+        height: rowHeight,
+        borderColor: rgb(COLOR_TABLE_BORDER.r, COLOR_TABLE_BORDER.g, COLOR_TABLE_BORDER.b),
+        borderWidth: TABLE_BORDER_WIDTH
+      });
+      if (colIdx < row.children.length) {
+        const cellNode = row.children[colIdx];
+        const spans = flattenInlines(cellNode.children, ctx, {
+          bold: isHeader,
+          italic: false,
+          code: false
+        });
+        const savedY = ctx.y;
+        ctx.y = ctx.y - TABLE_CELL_PAD_Y;
+        const cellAvailableWidth = colWidth - 2 * TABLE_CELL_PAD_X;
+        const wrappedLines = wrapSpans(spans, cellAvailableWidth);
+        for (const line of wrappedLines) {
+          let lx = cellX + TABLE_CELL_PAD_X;
+          for (const span of line) {
+            ctx.page.drawText(span.text, {
+              x: lx,
+              y: ctx.y - span.fontSize,
+              size: span.fontSize,
+              font: span.font,
+              color: rgb(span.color.r, span.color.g, span.color.b)
+            });
+            lx += span.font.widthOfTextAtSize(span.text, span.fontSize);
+          }
+          ctx.y -= getLineHeight(line);
+        }
+        ctx.y = savedY;
+      }
+    }
+    ctx.y -= rowHeight;
+  }
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderThematicBreak(ctx, extraIndent) {
+  ctx.y -= PARAGRAPH_SPACING;
+  ensureSpace(ctx, 10);
+  const x0 = ctx.margin + extraIndent;
+  const x1 = ctx.margin + ctx.contentWidth;
+  ctx.page.drawLine({
+    start: { x: x0, y: ctx.y },
+    end: { x: x1, y: ctx.y },
+    thickness: 1,
+    color: rgb(COLOR_THEMATIC_BREAK.r, COLOR_THEMATIC_BREAK.g, COLOR_THEMATIC_BREAK.b)
+  });
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderHtmlBlock(node, ctx, extraIndent) {
+  if (!node.rawHtml) return;
+  const lines = node.rawHtml.split("\n");
+  const x0 = ctx.margin + extraIndent;
+  for (const line of lines) {
+    if (line.trim().length === 0) continue;
+    const lineH = CODE_FONT_SIZE * LINE_HEIGHT_FACTOR;
+    ensureSpace(ctx, lineH);
+    ctx.page.drawText(line, {
+      x: x0,
+      y: ctx.y - CODE_FONT_SIZE,
+      size: CODE_FONT_SIZE,
+      font: ctx.fonts.mono,
+      color: rgb(COLOR_CODE_TEXT.r, COLOR_CODE_TEXT.g, COLOR_CODE_TEXT.b)
+    });
+    ctx.y -= lineH;
+  }
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderMathBlock(node, ctx, extraIndent) {
+  const lines = node.value.split("\n");
+  const x0 = ctx.margin + extraIndent;
+  for (const line of lines) {
+    const lineH = CODE_FONT_SIZE * LINE_HEIGHT_FACTOR;
+    ensureSpace(ctx, lineH);
+    if (line.length > 0) {
+      ctx.page.drawText(line, {
+        x: x0,
+        y: ctx.y - CODE_FONT_SIZE,
+        size: CODE_FONT_SIZE,
+        font: ctx.fonts.mono,
+        color: rgb(COLOR_CODE_TEXT.r, COLOR_CODE_TEXT.g, COLOR_CODE_TEXT.b)
+      });
+    }
+    ctx.y -= lineH;
+  }
+  ctx.y -= PARAGRAPH_SPACING;
+}
+function renderFootnoteDefinition(node, ctx, extraIndent) {
+  const label = `[${node.identifier}]`;
+  const lineH = ctx.fontSize * LINE_HEIGHT_FACTOR;
+  ensureSpace(ctx, lineH);
+  ctx.page.drawText(label, {
+    x: ctx.margin + extraIndent,
+    y: ctx.y - ctx.fontSize * 0.75,
+    size: ctx.fontSize * 0.75,
+    font: ctx.fonts.bold,
+    color: rgb(COLOR_LINK.r, COLOR_LINK.g, COLOR_LINK.b)
+  });
+  renderBlocks(node.children, ctx, extraIndent + LIST_INDENT);
+}
+function renderFallbackBlock(node, ctx, extraIndent) {
+  const fallback = node;
+  if (fallback.children && Array.isArray(fallback.children)) {
+    if (fallback.children.length > 0 && typeof fallback.children[0]?.type === "string") {
+      const firstType = fallback.children[0].type;
+      const inlineTypes = /* @__PURE__ */ new Set([
+        "text",
+        "strong",
+        "emphasis",
+        "delete",
+        "inlineCode",
+        "link",
+        "image",
+        "break"
+      ]);
+      if (inlineTypes.has(firstType)) {
+        const spans = flattenInlines(fallback.children, ctx, {
+          bold: false,
+          italic: false,
+          code: false
+        });
+        drawSpans(spans, ctx, ctx.contentWidth - extraIndent, ctx.margin + extraIndent);
+        ctx.y -= PARAGRAPH_SPACING;
+        return;
+      }
+    }
+    renderBlocks(fallback.children, 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, {
+      x: ctx.margin + extraIndent,
+      y: ctx.y - ctx.fontSize,
+      size: ctx.fontSize,
+      font: ctx.fonts.regular,
+      color: rgb(COLOR_TEXT.r, COLOR_TEXT.g, COLOR_TEXT.b)
+    });
+    ctx.y -= lineH + PARAGRAPH_SPACING;
+  }
+}
+
+// src/pdf/import.ts
+import { markdownToDoc } from "@bendyline/squisq/doc";
+async function pdfToMarkdownDoc(data, options = {}) {
+  const bytes = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  const textLines = await extractTextLines(bytes);
+  if (textLines.length === 0) {
+    return { type: "document", children: [] };
+  }
+  const bodySize = options.bodyFontSize ?? detectBodyFontSize(textLines);
+  const blocks = classifyLines(textLines, bodySize, options);
+  return { type: "document", children: blocks };
+}
+async function pdfToDoc(data, options = {}) {
+  const markdownDoc = await pdfToMarkdownDoc(data, options);
+  return markdownToDoc(markdownDoc);
+}
+function configurePdfWorker(workerSrc) {
+  _workerSrc = workerSrc;
+}
+var _workerSrc;
+async function applyWorkerConfig(pdfjsLib) {
+  if (!pdfjsLib.GlobalWorkerOptions) return;
+  if (pdfjsLib.GlobalWorkerOptions.workerSrc) return;
+  if (_workerSrc) {
+    pdfjsLib.GlobalWorkerOptions.workerSrc = _workerSrc;
+  }
+}
+async function extractTextLines(data) {
+  let pdfjsLib;
+  try {
+    pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  } catch {
+    pdfjsLib = await import("pdfjs-dist");
+  }
+  await applyWorkerConfig(pdfjsLib);
+  const loadingTask = pdfjsLib.getDocument({
+    data,
+    isEvalSupported: false,
+    useSystemFonts: true
+  });
+  const pdf = await loadingTask.promise;
+  const allLines = [];
+  for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+    const page = await pdf.getPage(pageNum);
+    const content = await page.getTextContent();
+    const styleMap = content.styles || {};
+    const items = [];
+    for (const item of content.items) {
+      if (!item.str || item.str.trim().length === 0) continue;
+      const transform = item.transform || [1, 0, 0, 1, 0, 0];
+      const x = transform[4];
+      const y = transform[5];
+      const height = Math.abs(transform[3]) || item.height || 12;
+      const width = item.width || 0;
+      const fontName = item.fontName || "";
+      const fontFamily = styleMap[fontName]?.fontFamily || "";
+      items.push({ str: item.str, x, y, width, height, fontName, fontFamily });
+    }
+    const lineMap = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const roundedY = Math.round(item.y * 2) / 2;
+      let foundKey;
+      for (const key of lineMap.keys()) {
+        if (Math.abs(key - roundedY) < 2) {
+          foundKey = key;
+          break;
+        }
+      }
+      if (foundKey !== void 0) {
+        lineMap.get(foundKey).push(item);
+      } else {
+        lineMap.set(roundedY, [item]);
+      }
+    }
+    const sortedKeys = [...lineMap.keys()].sort((a, b) => b - a);
+    for (const key of sortedKeys) {
+      const lineItems = lineMap.get(key).sort((a, b) => a.x - b.x);
+      const fontSizes = lineItems.map((i) => i.height);
+      const fontSize = mode(fontSizes) || 12;
+      const fontFamilies = lineItems.map((i) => i.fontFamily);
+      const fontFamily = modeStr(fontFamilies) || "";
+      const fontNames = lineItems.map((i) => i.fontName);
+      const fontName = modeStr(fontNames) || "";
+      const minX = Math.min(...lineItems.map((i) => i.x));
+      const text = lineItems.map((i) => i.str).join(" ");
+      allLines.push({
+        items: lineItems,
+        y: key,
+        page: pageNum - 1,
+        fontSize,
+        fontFamily,
+        fontName,
+        minX,
+        text
+      });
+    }
+  }
+  return allLines;
+}
+function detectBodyFontSize(lines) {
+  const sizes = lines.map((l) => Math.round(l.fontSize * 2) / 2);
+  return mode(sizes) || DEFAULT_FONT_SIZE;
+}
+function mode(arr) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const v of arr) freq.set(v, (freq.get(v) || 0) + 1);
+  let maxCount = 0;
+  let maxVal = 0;
+  for (const [v, c] of freq) {
+    if (c > maxCount) {
+      maxCount = c;
+      maxVal = v;
+    }
+  }
+  return maxVal;
+}
+function modeStr(arr) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const v of arr) freq.set(v, (freq.get(v) || 0) + 1);
+  let maxCount = 0;
+  let maxVal = "";
+  for (const [v, c] of freq) {
+    if (c > maxCount) {
+      maxCount = c;
+      maxVal = v;
+    }
+  }
+  return maxVal;
+}
+function classifyLines(lines, bodySize, options) {
+  const blocks = [];
+  const detectTables = options.detectTables !== false;
+  const detectCodeBlocks = options.detectCodeBlocks !== false;
+  const detectBlockquotes = options.detectBlockquotes !== false;
+  const _detectLinks = options.detectLinks !== false;
+  const leftMargins = lines.map((l) => Math.round(l.minX));
+  const typicalLeftMargin = mode(leftMargins) || 72;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.fontSize >= IMPORT_HEADING_MIN_SIZE && line.fontSize > bodySize + 1) {
+      const depth = sizeToHeadingDepth(line.fontSize);
+      blocks.push({
+        type: "heading",
+        depth,
+        children: buildInlineNodes(line, options)
+      });
+      i++;
+      continue;
+    }
+    if (detectCodeBlocks && isMonospaceLine(line)) {
+      const codeLines = [];
+      while (i < lines.length && isMonospaceLine(lines[i])) {
+        codeLines.push(lines[i].text);
+        i++;
+      }
+      blocks.push({
+        type: "code",
+        value: codeLines.join("\n")
+      });
+      continue;
+    }
+    if (detectTables && i + 1 < lines.length) {
+      const tableLines = tryDetectTable(lines, i, typicalLeftMargin);
+      if (tableLines > 0) {
+        const table = buildTable(lines.slice(i, i + tableLines), options);
+        if (table) {
+          blocks.push(table);
+          i += tableLines;
+          continue;
+        }
+      }
+    }
+    const bulletMatch = tryMatchBullet(line.text);
+    const orderedMatch = line.text.match(IMPORT_ORDERED_PREFIX);
+    if (bulletMatch || orderedMatch) {
+      const listResult = consumeList(lines, i, typicalLeftMargin, bodySize, options);
+      blocks.push(listResult.list);
+      i = listResult.nextIndex;
+      continue;
+    }
+    if (detectBlockquotes && line.minX > typicalLeftMargin + 20) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].minX > typicalLeftMargin + 20 && !isMonospaceLine(lines[i]) && lines[i].fontSize <= bodySize + 1) {
+        quoteLines.push(lines[i]);
+        i++;
+      }
+      const quoteBlocks = quoteLines.map(
+        (ql) => ({
+          type: "paragraph",
+          children: buildInlineNodes(ql, options)
+        })
+      );
+      blocks.push({
+        type: "blockquote",
+        children: quoteBlocks
+      });
+      continue;
+    }
+    const paraLines = [line];
+    i++;
+    while (i < lines.length) {
+      const next = lines[i];
+      if (next.page === line.page && Math.abs(next.fontSize - bodySize) <= 1 && !isMonospaceLine(next) && next.minX <= typicalLeftMargin + 15 && !tryMatchBullet(next.text) && !next.text.match(IMPORT_ORDERED_PREFIX)) {
+        const yGap = paraLines[paraLines.length - 1].y - next.y;
+        const lineHeight = bodySize * 1.6;
+        if (yGap > 0 && yGap < lineHeight + IMPORT_PARAGRAPH_GAP) {
+          paraLines.push(next);
+          i++;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    const allInlines = [];
+    for (let j = 0; j < paraLines.length; j++) {
+      if (j > 0) {
+        allInlines.push({ type: "text", value: " " });
+      }
+      allInlines.push(...buildInlineNodes(paraLines[j], options));
+    }
+    if (allInlines.length > 0) {
+      blocks.push({
+        type: "paragraph",
+        children: mergeAdjacentText(allInlines)
+      });
+    }
+  }
+  return blocks;
+}
+function sizeToHeadingDepth(fontSize) {
+  for (const range of IMPORT_HEADING_SIZE_RANGES) {
+    if (fontSize >= range.min) return range.depth;
+  }
+  return 6;
+}
+function isMonospaceLine(line) {
+  return isMonospaceFamily(line.fontFamily) || isMonospaceName(line.fontName);
+}
+function isMonospaceItem(item) {
+  return isMonospaceFamily(item.fontFamily) || isMonospaceName(item.fontName);
+}
+function isMonospaceFamily(fontFamily) {
+  const lower = fontFamily.toLowerCase();
+  return lower === "monospace" || lower.includes("monospace");
+}
+function isMonospaceName(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("courier") || lower.includes("mono") || lower.includes("consolas") || lower.includes("menlo") || lower.includes("inconsolata") || lower.includes("firacode") || lower.includes("source code") || lower.includes("dejavu sans mono");
+}
+function isBoldFont(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("bold") || lower.includes("black") || lower.includes("heavy");
+}
+function isItalicFont(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("italic") || lower.includes("oblique") || lower.includes("slanted");
+}
+function buildInlineNodes(line, options) {
+  const nodes = [];
+  const detectLinksOpt = options.detectLinks !== false;
+  for (const item of line.items) {
+    const text = item.str;
+    if (!text || text.trim().length === 0) continue;
+    const bold = isBoldFont(item.fontName);
+    const italic = isItalicFont(item.fontName);
+    const mono = isMonospaceItem(item);
+    let inlineNodes;
+    if (mono) {
+      inlineNodes = [{ type: "inlineCode", value: text }];
+    } else if (detectLinksOpt) {
+      inlineNodes = splitTextWithLinks(text);
+    } else {
+      inlineNodes = [{ type: "text", value: text }];
+    }
+    for (const node of inlineNodes) {
+      let wrapped = node;
+      if (italic) {
+        wrapped = { type: "emphasis", children: [wrapped] };
+      }
+      if (bold) {
+        wrapped = { type: "strong", children: [wrapped] };
+      }
+      nodes.push(wrapped);
+    }
+  }
+  return nodes;
+}
+function splitTextWithLinks(text) {
+  const nodes = [];
+  let lastIndex = 0;
+  IMPORT_URL_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = IMPORT_URL_PATTERN.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      nodes.push({ type: "text", value: text.slice(lastIndex, match.index) });
+    }
+    const url = match[0];
+    nodes.push({
+      type: "link",
+      url,
+      children: [{ type: "text", value: url }]
+    });
+    lastIndex = match.index + url.length;
+  }
+  if (lastIndex < text.length) {
+    nodes.push({ type: "text", value: text.slice(lastIndex) });
+  }
+  return nodes.length > 0 ? nodes : [{ type: "text", value: text }];
+}
+function tryMatchBullet(text) {
+  if (text.length === 0) return false;
+  return IMPORT_BULLET_CHARS.has(text[0]) || IMPORT_BULLET_CHARS.has(text.trimStart()[0]);
+}
+function stripBullet(text) {
+  const trimmed = text.trimStart();
+  if (IMPORT_BULLET_CHARS.has(trimmed[0])) {
+    return trimmed.slice(1).trimStart();
+  }
+  return text;
+}
+function stripOrderedPrefix(text) {
+  return text.replace(IMPORT_ORDERED_PREFIX, "");
+}
+function consumeList(lines, startIdx, _typicalLeftMargin, _bodySize, _options) {
+  const firstLine = lines[startIdx];
+  const isOrdered = !!firstLine.text.match(IMPORT_ORDERED_PREFIX);
+  const items = [];
+  let i = startIdx;
+  while (i < lines.length) {
+    const line = lines[i];
+    const isBullet = tryMatchBullet(line.text);
+    const isOrd = !!line.text.match(IMPORT_ORDERED_PREFIX);
+    if (!isBullet && !isOrd) break;
+    if (isOrdered && !isOrd) break;
+    if (!isOrdered && !isBullet) break;
+    const cleanText = isOrdered ? stripOrderedPrefix(line.text) : stripBullet(line.text);
+    const para = {
+      type: "paragraph",
+      children: splitTextWithLinks(cleanText)
+    };
+    items.push({
+      type: "listItem",
+      children: [para]
+    });
+    i++;
+  }
+  return {
+    list: {
+      type: "list",
+      ordered: isOrdered,
+      children: items
+    },
+    nextIndex: i
+  };
+}
+function tryDetectTable(lines, start, _typicalLeftMargin) {
+  const firstLine = lines[start];
+  if (firstLine.items.length < 2) return 0;
+  const cols = getColumnPositions(firstLine);
+  if (cols.length < 2) return 0;
+  let count = 1;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.items.length < 2) break;
+    const lineCols = getColumnPositions(line);
+    if (lineCols.length !== cols.length) break;
+    let aligned = true;
+    for (let c = 0; c < cols.length; c++) {
+      if (Math.abs(lineCols[c] - cols[c]) > IMPORT_COLUMN_TOLERANCE) {
+        aligned = false;
+        break;
+      }
+    }
+    if (!aligned) break;
+    count++;
+  }
+  return count >= IMPORT_TABLE_MIN_ROWS ? count : 0;
+}
+function getColumnPositions(line) {
+  const positions = [];
+  for (const item of line.items) {
+    const x = Math.round(item.x);
+    let found = false;
+    for (const p of positions) {
+      if (Math.abs(p - x) < IMPORT_COLUMN_TOLERANCE) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) positions.push(x);
+  }
+  return positions.sort((a, b) => a - b);
+}
+function buildTable(lines, _options) {
+  if (lines.length === 0) return null;
+  const cols = getColumnPositions(lines[0]);
+  if (cols.length < 2) return null;
+  const rows = [];
+  for (let ri = 0; ri < lines.length; ri++) {
+    const line = lines[ri];
+    const cells = [];
+    for (let ci = 0; ci < cols.length; ci++) {
+      const colLeft = cols[ci] - IMPORT_COLUMN_TOLERANCE;
+      const colRight = ci + 1 < cols.length ? cols[ci + 1] - IMPORT_COLUMN_TOLERANCE : Infinity;
+      const cellItems = line.items.filter((item) => item.x >= colLeft && item.x < colRight);
+      const text = cellItems.map((i) => i.str).join(" ").trim();
+      cells.push({
+        type: "tableCell",
+        isHeader: ri === 0,
+        children: text.length > 0 ? [{ type: "text", value: text }] : []
+      });
+    }
+    rows.push({
+      type: "tableRow",
+      children: cells
+    });
+  }
+  return {
+    type: "table",
+    children: rows
+  };
+}
+function mergeAdjacentText(nodes) {
+  if (nodes.length <= 1) return nodes;
+  const result = [];
+  for (const node of nodes) {
+    const prev = result[result.length - 1];
+    if (prev && prev.type === "text" && node.type === "text") {
+      prev.value += node.value;
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+}
+
+export {
+  markdownDocToPdf,
+  docToPdf,
+  pdfToMarkdownDoc,
+  pdfToDoc,
+  configurePdfWorker
+};
+//# sourceMappingURL=chunk-TBPD5PCU.js.map