@bendyline/squisq-formats 1.4.0 → 1.4.2

package/dist/{chunk-A3FHLTY5.js → chunk-MJGRI6XR.js}

@@ -1,23 +1,10 @@
+import {
+  extToMime
+} from "./chunk-DQAZR57U.js";
+
 // src/html/imageUtils.ts
-var MIME_MAP = {
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  gif: "image/gif",
-  webp: "image/webp",
-  svg: "image/svg+xml",
-  ico: "image/x-icon",
-  bmp: "image/bmp",
-  avif: "image/avif",
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  ogg: "audio/ogg",
-  mp4: "video/mp4",
-  webm: "video/webm"
-};
 function inferMimeType(filename) {
-  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
-  return MIME_MAP[ext] ?? "application/octet-stream";
+  return extToMime(filename.split(".").pop() ?? "");
 }
 function arrayBufferToBase64DataUrl(buffer, mimeType) {
   const bytes = new Uint8Array(buffer);
@@ -39,4 +26,4 @@ export {
   arrayBufferToBase64DataUrl,
   extractFilename
 };
-//# sourceMappingURL=chunk-A3FHLTY5.js.map
+//# sourceMappingURL=chunk-MJGRI6XR.js.map

package/dist/chunk-MJGRI6XR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/html/imageUtils.ts"],"sourcesContent":["/**\n * Image Utilities for HTML Export\n *\n * Browser-compatible helpers for converting image data to base64 data URIs\n * and inferring MIME types from filenames.\n */\n\nimport { extToMime } from '../shared/images.js';\n\n/**\n * Infer a MIME type from a filename's extension.\n * Returns 'application/octet-stream' for unknown types.\n *\n * Thin wrapper over the shared {@link extToMime} map so html export, docx\n * import, and pptx import all agree on extension → MIME.\n */\nexport function inferMimeType(filename: string): string {\n  return extToMime(filename.split('.').pop() ?? '');\n}\n\n/**\n * Convert an ArrayBuffer to a base64-encoded data URI string.\n *\n * @param buffer - The binary image data\n * @param mimeType - MIME type (e.g., 'image/jpeg'). If not provided, defaults to\n *   'application/octet-stream'.\n * @returns A `data:` URI string\n */\nexport function arrayBufferToBase64DataUrl(buffer: ArrayBuffer, mimeType: string): string {\n  const bytes = new Uint8Array(buffer);\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  const base64 = btoa(binary);\n  return `data:${mimeType};base64,${base64}`;\n}\n\n/**\n * Extract the filename from a path or URL (strips directory and query).\n *\n * @example\n *   extractFilename('images/hero.jpg') // 'hero.jpg'\n *   extractFilename('https://example.com/photo.png?v=2') // 'photo.png'\n */\nexport function extractFilename(path: string): string {\n  // Strip query/hash\n  const clean = path.split('?')[0].split('#')[0];\n  // Get last segment\n  const parts = clean.split('/');\n  return parts[parts.length - 1] || path;\n}\n"],"mappings":";;;;;AAgBO,SAAS,cAAc,UAA0B;AACtD,SAAO,UAAU,SAAS,MAAM,GAAG,EAAE,IAAI,KAAK,EAAE;AAClD;AAUO,SAAS,2BAA2B,QAAqB,UAA0B;AACxF,QAAM,QAAQ,IAAI,WAAW,MAAM;AACnC,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,cAAU,OAAO,aAAa,MAAM,CAAC,CAAC;AAAA,EACxC;AACA,QAAM,SAAS,KAAK,MAAM;AAC1B,SAAO,QAAQ,QAAQ,WAAW,MAAM;AAC1C;AASO,SAAS,gBAAgB,MAAsB;AAEpD,QAAM,QAAQ,KAAK,MAAM,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AAE7C,QAAM,QAAQ,MAAM,MAAM,GAAG;AAC7B,SAAO,MAAM,MAAM,SAAS,CAAC,KAAK;AACpC;","names":[]}

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

@@ -100,7 +100,14 @@ function cellText(cell) {
 }
 function markdownDocToCsv(doc, options = {}) {
   const delimiter = options.delimiter ?? ",";
-  const table = doc.children.find((n) => n.type === "table");
+  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)) {
+    throw new Error(
+      `CSV export: tableIndex ${index} is out of range \u2014 the document contains ${tables.length} table(s).`
+    );
+  }
+  const table = tables[index];
   if (!table) return "";
   return table.children.map(
     (row) => row.children.map((cell) => escapeCsvField(cellText(cell), delimiter)).join(delimiter)
@@ -113,4 +120,4 @@ export {
   csvToDoc,
   markdownDocToCsv
 };
-//# sourceMappingURL=chunk-JBNVE2GV.js.map
+//# sourceMappingURL=chunk-RFAPOKHJ.js.map

package/dist/chunk-RFAPOKHJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/csv/index.ts"],"sourcesContent":["/**\n * @bendyline/squisq-formats CSV Module\n *\n * Bridges CSV ↔ the squisq markdown table model. CSV isn't OOXML, so this\n * module is self-contained (no jszip / DOMParser): a small RFC-4180 parser on\n * the import side and a serializer on the export side. The first row is treated\n * as the table header by default.\n *\n * @example\n * ```ts\n * import { csvToMarkdownDoc, markdownDocToCsv } from '@bendyline/squisq-formats/csv';\n * ```\n */\n\nimport { markdownToDoc } from '@bendyline/squisq/doc';\nimport type {\n  MarkdownDocument,\n  MarkdownTable,\n  MarkdownTableCell,\n  MarkdownTableRow,\n} from '@bendyline/squisq/markdown';\nimport type { Doc } from '@bendyline/squisq/schemas';\n\nexport interface CsvImportOptions {\n  /** Field delimiter. Default `,`. */\n  delimiter?: string;\n  /** Treat the first row as a header row. Default true. */\n  hasHeader?: boolean;\n}\n\nexport interface CsvExportOptions {\n  /** Field delimiter. Default `,`. */\n  delimiter?: string;\n  /**\n   * Zero-based index of the table to export when the document contains more\n   * than one. Default 0 (the first table). An explicitly provided index that\n   * doesn't match a table in the document is an error.\n   */\n  tableIndex?: number;\n}\n\nasync function toText(data: ArrayBuffer | Blob | string): Promise<string> {\n  if (typeof data === 'string') return data;\n  if (typeof Blob !== 'undefined' && data instanceof Blob) return data.text();\n  return new TextDecoder().decode(new Uint8Array(data as ArrayBuffer));\n}\n\n/** Parse CSV text into a grid of string cells (RFC 4180: quotes, escaped quotes). */\nexport function parseCsv(text: string, delimiter = ','): string[][] {\n  const rows: string[][] = [];\n  let row: string[] = [];\n  let field = '';\n  let inQuotes = false;\n  let sawAny = false;\n  const pushField = () => {\n    row.push(field);\n    field = '';\n  };\n  const pushRow = () => {\n    pushField();\n    rows.push(row);\n    row = [];\n  };\n  for (let i = 0; i < text.length; i++) {\n    const ch = text[i]!;\n    if (inQuotes) {\n      if (ch === '\"') {\n        if (text[i + 1] === '\"') {\n          field += '\"';\n          i++;\n        } else {\n          inQuotes = false;\n        }\n      } else {\n        field += ch;\n      }\n      continue;\n    }\n    if (ch === '\"') {\n      inQuotes = true;\n      sawAny = true;\n      continue;\n    }\n    if (ch === delimiter) {\n      sawAny = true;\n      pushField();\n      continue;\n    }\n    if (ch === '\\n' || ch === '\\r') {\n      if (ch === '\\r' && text[i + 1] === '\\n') i++;\n      pushRow();\n      sawAny = false;\n      continue;\n    }\n    sawAny = true;\n    field += ch;\n  }\n  // Flush a trailing field/row only if the last line wasn't terminated.\n  if (field !== '' || row.length > 0 || sawAny) pushRow();\n  return rows;\n}\n\nfunction rowsToTable(rows: string[][], hasHeader: boolean): MarkdownTable {\n  const maxCols = rows.reduce((m, r) => Math.max(m, r.length), 1);\n  const mdRows: MarkdownTableRow[] = rows.map((cells, rowIdx) => {\n    const children: MarkdownTableCell[] = [];\n    for (let c = 0; c < maxCols; c++) {\n      const value = cells[c] ?? '';\n      children.push({\n        type: 'tableCell',\n        ...(hasHeader && rowIdx === 0 ? { isHeader: true } : {}),\n        children: value ? [{ type: 'text', value }] : [],\n      });\n    }\n    return { type: 'tableRow', children };\n  });\n  return { type: 'table', children: mdRows };\n}\n\n/** Convert CSV to a MarkdownDocument containing a single table. */\nexport async function csvToMarkdownDoc(\n  data: ArrayBuffer | Blob | string,\n  options: CsvImportOptions = {},\n): Promise<MarkdownDocument> {\n  const text = await toText(data);\n  const rows = parseCsv(text, options.delimiter ?? ',');\n  const hasHeader = options.hasHeader ?? true;\n  const children = rows.length > 0 ? [rowsToTable(rows, hasHeader)] : [];\n  return { type: 'document', children };\n}\n\n/** Convert CSV to a squisq Doc. */\nexport async function csvToDoc(\n  data: ArrayBuffer | Blob | string,\n  options: CsvImportOptions = {},\n): Promise<Doc> {\n  return markdownToDoc(await csvToMarkdownDoc(data, options));\n}\n\nfunction escapeCsvField(value: string, delimiter: string): string {\n  if (value.includes('\"') || value.includes(delimiter) || /[\\r\\n]/.test(value)) {\n    return `\"${value.replace(/\"/g, '\"\"')}\"`;\n  }\n  return value;\n}\n\nfunction cellText(cell: MarkdownTableCell): string {\n  // Flatten inline children to plain text (CSV has no formatting).\n  const walk = (nodes: unknown[]): string =>\n    nodes\n      .map((n) => {\n        const node = n as { type?: string; value?: string; children?: unknown[] };\n        if (node.value !== undefined) return node.value;\n        if (Array.isArray(node.children)) return walk(node.children);\n        return '';\n      })\n      .join('');\n  return walk(cell.children);\n}\n\n/**\n * Serialize one table in a MarkdownDocument to CSV text.\n *\n * By default the first table is exported. Documents with multiple tables can\n * select another via `options.tableIndex` (zero-based). An explicit\n * `tableIndex` that is out of range throws; the implicit first-table default\n * on a table-less document returns an empty string (back-compat).\n */\nexport function markdownDocToCsv(doc: MarkdownDocument, options: CsvExportOptions = {}): string {\n  const delimiter = options.delimiter ?? ',';\n  const tables = doc.children.filter((n): n is MarkdownTable => n.type === 'table');\n  const index = options.tableIndex ?? 0;\n  if (\n    options.tableIndex !== undefined &&\n    (!Number.isInteger(index) || index < 0 || index >= tables.length)\n  ) {\n    throw new Error(\n      `CSV export: tableIndex ${index} is out of range — the document contains ${tables.length} table(s).`,\n    );\n  }\n  const table = tables[index];\n  if (!table) return '';\n  return table.children\n    .map((row) =>\n      row.children.map((cell) => escapeCsvField(cellText(cell), delimiter)).join(delimiter),\n    )\n    .join('\\r\\n');\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-RTS5XBZ7.js

@@ -0,0 +1,526 @@
+// src/registry/types.ts
+var BUILTIN_FORMAT_IDS = [
+  "md",
+  "docx",
+  "pdf",
+  "pptx",
+  "xlsx",
+  "csv",
+  "html",
+  "htmlzip",
+  "epub",
+  "dbk"
+];
+
+// src/registry/errors.ts
+var ConversionError = class extends Error {
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "ConversionError";
+    this.code = code;
+    this.format = opts.format;
+    this.hint = opts.hint;
+    if (opts.cause !== void 0) {
+      this.cause = opts.cause;
+    }
+  }
+};
+
+// src/registry/defaultFormats.ts
+var MIME = {
+  md: "text/markdown",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  pdf: "application/pdf",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  csv: "text/csv",
+  html: "text/html",
+  zip: "application/zip",
+  epub: "application/epub+zip"
+};
+async function toBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (typeof data.arrayBuffer === "function") {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  const buffer = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error);
+    reader.readAsArrayBuffer(data);
+  });
+  return new Uint8Array(buffer);
+}
+function resolveThemeId(input, options) {
+  return options.themeId ?? input.doc.themeId;
+}
+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) {
+  const images = /* @__PURE__ */ new Map();
+  const files = await container.listFiles();
+  for (const file of files) {
+    if (!/\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i.test(file.path)) continue;
+    const data = await container.readFile(file.path);
+    if (!data) continue;
+    images.set(file.path, data);
+    const slash = file.path.lastIndexOf("/");
+    if (slash !== -1) images.set(file.path.slice(slash + 1), data);
+  }
+  return images;
+}
+async function requirePlayerScript(options, format) {
+  const script = await options.resolvePlayerScript?.();
+  if (!script) {
+    throw new ConversionError("missing-dependency", "HTML export needs a player script.", {
+      format,
+      hint: "pass resolvePlayerScript, e.g. () => import('@bendyline/squisq-react/standalone-source').then(m => m.PLAYER_BUNDLE)"
+    });
+  }
+  return script;
+}
+function ok(bytes, mimeType, warnings = []) {
+  return { bytes, mimeType, suggestedFilename: "", warnings };
+}
+function defaultFormats() {
+  const md = {
+    id: "md",
+    label: "Markdown",
+    mimeType: MIME.md,
+    extensions: [".md", ".markdown"],
+    async importDoc(data) {
+      const { parseMarkdown } = await import("@bendyline/squisq/markdown");
+      return parseMarkdown(new TextDecoder().decode(data));
+    },
+    async exportDoc(input) {
+      const { stringifyMarkdown } = await import("@bendyline/squisq/markdown");
+      const text = stringifyMarkdown(await markdownOf(input));
+      return ok(new TextEncoder().encode(text), MIME.md);
+    }
+  };
+  const docx = {
+    id: "docx",
+    label: "Word (DOCX)",
+    mimeType: MIME.docx,
+    extensions: [".docx"],
+    async importContainer(data) {
+      const { docxToContainer } = await import("./docx/index.js");
+      return docxToContainer(data);
+    },
+    async importDoc(data) {
+      const { docxToMarkdownDoc } = await import("./docx/index.js");
+      return docxToMarkdownDoc(data);
+    },
+    async exportDoc(input, options) {
+      const { markdownDocToDocx } = await import("./docx/index.js");
+      const buf = await markdownDocToDocx(await markdownOf(input), {
+        themeId: resolveThemeId(input, options)
+      });
+      return ok(await toBytes(buf), MIME.docx);
+    }
+  };
+  const pdf = {
+    id: "pdf",
+    label: "PDF",
+    mimeType: MIME.pdf,
+    extensions: [".pdf"],
+    async importContainer(data) {
+      const { pdfToContainer } = await import("./pdf/index.js");
+      return pdfToContainer(data);
+    },
+    async importDoc(data) {
+      const { pdfToMarkdownDoc } = await import("./pdf/index.js");
+      return pdfToMarkdownDoc(data);
+    },
+    async exportDoc(input, options) {
+      const { markdownDocToPdf } = await import("./pdf/index.js");
+      const buf = await markdownDocToPdf(await markdownOf(input), {
+        themeId: resolveThemeId(input, options)
+      });
+      return ok(await toBytes(buf), MIME.pdf);
+    }
+  };
+  const pptx = {
+    id: "pptx",
+    label: "PowerPoint (PPTX)",
+    mimeType: MIME.pptx,
+    extensions: [".pptx"],
+    async importContainer(data) {
+      const { pptxToContainer } = await import("./pptx/index.js");
+      return pptxToContainer(data);
+    },
+    async importDoc(data) {
+      const { pptxToMarkdownDoc } = await import("./pptx/index.js");
+      return pptxToMarkdownDoc(data);
+    },
+    async exportDoc(input, options) {
+      const { markdownDocToPptx } = await import("./pptx/index.js");
+      const images = await collectContainerImages(input.container);
+      const buf = await markdownDocToPptx(await markdownOf(input), {
+        themeId: resolveThemeId(input, options),
+        images
+      });
+      return ok(await toBytes(buf), MIME.pptx);
+    }
+  };
+  const xlsx = {
+    id: "xlsx",
+    label: "Excel (XLSX)",
+    mimeType: MIME.xlsx,
+    extensions: [".xlsx"],
+    async importDoc(data) {
+      const { xlsxToMarkdownDoc } = await import("./xlsx/index.js");
+      return xlsxToMarkdownDoc(data);
+    },
+    async exportDoc(input) {
+      const { markdownDocToXlsx } = await import("./xlsx/index.js");
+      const markdownDoc = await markdownOf(input);
+      const omitted = markdownDoc.children.filter(
+        (n) => n.type !== "table" && n.type !== "heading"
+      ).length;
+      const warnings = omitted > 0 ? [`XLSX export is tables-only; ${omitted} non-table block(s) were omitted.`] : [];
+      const blob = await markdownDocToXlsx(markdownDoc);
+      return ok(await toBytes(blob), MIME.xlsx, warnings);
+    }
+  };
+  const csv = {
+    id: "csv",
+    label: "CSV",
+    mimeType: MIME.csv,
+    extensions: [".csv"],
+    async importDoc(data) {
+      const { csvToMarkdownDoc } = await import("./csv/index.js");
+      return csvToMarkdownDoc(data);
+    },
+    async exportDoc(input) {
+      const { markdownDocToCsv } = await import("./csv/index.js");
+      const markdownDoc = await markdownOf(input);
+      const tableCount = markdownDoc.children.filter((n) => n.type === "table").length;
+      const warnings = [];
+      if (tableCount > 1) {
+        warnings.push(
+          `Document has ${tableCount} tables; CSV export emitted only the first. Use the csv converter's tableIndex option to select another.`
+        );
+      }
+      const text = markdownDocToCsv(markdownDoc);
+      return ok(new TextEncoder().encode(text), MIME.csv, warnings);
+    }
+  };
+  const html = {
+    id: "html",
+    label: "HTML (single file)",
+    mimeType: MIME.html,
+    extensions: [".html", ".htm"],
+    async importDoc(data) {
+      const { htmlToMarkdownDoc } = await import("./html/index.js");
+      return htmlToMarkdownDoc(data);
+    },
+    // importContainer omitted: HTML import already inlines images as data URIs,
+    // so there is nothing to extract into a container this wave.
+    async exportDoc(input, options) {
+      const playerScript = await requirePlayerScript(options, "html");
+      const { docToHtml } = await import("./html/index.js");
+      const images = await collectContainerImages(input.container);
+      const htmlText = docToHtml(input.doc, {
+        playerScript,
+        images,
+        title: options.title ?? input.baseName,
+        mode: "static",
+        themeId: resolveThemeId(input, options)
+      });
+      return ok(new TextEncoder().encode(htmlText), MIME.html);
+    }
+  };
+  const htmlzip = {
+    id: "htmlzip",
+    label: "HTML (ZIP archive)",
+    mimeType: MIME.zip,
+    extensions: [".html.zip"],
+    async exportDoc(input, options) {
+      const playerScript = await requirePlayerScript(options, "htmlzip");
+      const { docToHtmlZip } = await import("./html/index.js");
+      const images = await collectContainerImages(input.container);
+      const blob = await docToHtmlZip(input.doc, {
+        playerScript,
+        images,
+        title: options.title ?? input.baseName,
+        mode: "static",
+        themeId: resolveThemeId(input, options)
+      });
+      return ok(await toBytes(blob), MIME.zip);
+    }
+  };
+  const epub = {
+    id: "epub",
+    label: "EPUB",
+    mimeType: MIME.epub,
+    extensions: [".epub"],
+    async exportDoc(input, options) {
+      const { markdownDocToEpub } = await import("./epub/index.js");
+      const images = await collectContainerImages(input.container);
+      const buf = await markdownDocToEpub(await markdownOf(input), {
+        title: options.title ?? input.baseName,
+        themeId: resolveThemeId(input, options),
+        images
+      });
+      return ok(await toBytes(buf), MIME.epub);
+    }
+  };
+  const dbk = {
+    id: "dbk",
+    label: "Squisq container (DBK)",
+    mimeType: MIME.zip,
+    extensions: [".dbk", ".zip"],
+    async importContainer(data) {
+      const { zipToContainer } = await import("./container/index.js");
+      return zipToContainer(data);
+    },
+    async exportDoc(input) {
+      const { containerToZip } = await import("./container/index.js");
+      const blob = await containerToZip(input.container);
+      return ok(await toBytes(blob), MIME.zip);
+    }
+  };
+  return [md, docx, pdf, pptx, xlsx, csv, html, htmlzip, epub, dbk];
+}
+
+// src/registry/registry.ts
+function normalizeExt(ext) {
+  return ext.replace(/^\.+/, "").toLowerCase();
+}
+function createRegistry() {
+  const byId = /* @__PURE__ */ new Map();
+  return {
+    register(def) {
+      byId.set(def.id, def);
+    },
+    get(id) {
+      return byId.get(id);
+    },
+    byExtension(ext) {
+      const target = normalizeExt(ext);
+      if (!target) return void 0;
+      for (const def of byId.values()) {
+        if (def.extensions.some((e) => normalizeExt(e) === target)) return def;
+      }
+      return void 0;
+    },
+    list() {
+      return [...byId.values()];
+    }
+  };
+}
+function defaultRegistry() {
+  const registry = createRegistry();
+  for (const def of defaultFormats()) {
+    registry.register(def);
+  }
+  return registry;
+}
+
+// src/registry/convert.ts
+function hasPrefix(bytes, prefix) {
+  if (bytes.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (bytes[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+var ZIP_MAGIC = [80, 75, 3, 4];
+var PDF_MAGIC = [37, 80, 68, 70];
+async function sniffZip(bytes) {
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(bytes).catch(() => {
+    throw new ConversionError("invalid-input", "Input is not a readable ZIP archive.");
+  });
+  const contentTypes = zip.file("[Content_Types].xml");
+  if (!contentTypes) return "dbk";
+  const xml = await contentTypes.async("string");
+  if (xml.includes("wordprocessingml")) return "docx";
+  if (xml.includes("presentationml")) return "pptx";
+  if (xml.includes("spreadsheetml")) return "xlsx";
+  return "dbk";
+}
+async function detectByteFormat(bytes, filename, options, registry) {
+  if (options.from) return options.from;
+  const ext = filename ? extractExt(filename) : void 0;
+  if (ext) {
+    const byExt = registry.byExtension(ext);
+    if (byExt) return byExt.id;
+  }
+  if (hasPrefix(bytes, PDF_MAGIC)) return "pdf";
+  if (hasPrefix(bytes, ZIP_MAGIC)) return sniffZip(bytes);
+  return "md";
+}
+function extractExt(filename) {
+  const base = filename.split("/").pop() ?? filename;
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return base.slice(dot + 1).toLowerCase();
+}
+function baseNameOf(filename) {
+  const base = filename.split("/").pop() ?? filename;
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+async function normalizeBytes(source, options, registry) {
+  const bytes = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const fromId = await detectByteFormat(bytes, source.filename, options, registry);
+  const fromDef = registry.get(fromId);
+  if (!fromDef) {
+    throw new ConversionError("unknown-format", `Unknown source format "${fromId}".`, {
+      format: fromId
+    });
+  }
+  if (!fromDef.importContainer && !fromDef.importDoc) {
+    throw new ConversionError(
+      "unsupported-input",
+      `Format "${fromDef.label}" cannot be used as a conversion source.`,
+      {
+        format: fromId,
+        hint: "This format is export-only."
+      }
+    );
+  }
+  const { markdownToDoc } = await import("@bendyline/squisq/doc");
+  const { parseMarkdown, stringifyMarkdown } = await import("@bendyline/squisq/markdown");
+  const warnings = [];
+  let markdownDoc;
+  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) : { 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));
+    container = mem;
+  }
+  const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  const baseName = source.filename ? baseNameOf(source.filename) : "document";
+  return {
+    input: { doc, markdownDoc, container, baseName },
+    warnings
+  };
+}
+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) : source.markdown;
+  let container = source.container;
+  if (!container) {
+    const { MemoryContentContainer } = await import("@bendyline/squisq/storage");
+    const mem = new MemoryContentContainer();
+    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    container = mem;
+  }
+  const doc = markdownToDoc(markdownDoc, { autoTemplates: options.autoTemplates });
+  const baseName = source.baseName ?? "document";
+  return { input: { doc, markdownDoc, container, baseName }, warnings: [] };
+}
+async function normalizeDoc(source) {
+  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)));
+    container = mem;
+  }
+  const baseName = source.baseName ?? "document";
+  return { input: { doc: source.doc, container, baseName }, warnings: [] };
+}
+async function normalize(source, options, registry) {
+  switch (source.kind) {
+    case "bytes":
+      return normalizeBytes(source, options, registry);
+    case "markdown":
+      return normalizeMarkdown(source, options);
+    case "doc":
+      return normalizeDoc(source);
+  }
+}
+async function applyTransformStyle(input, transformStyle, themeId) {
+  const { applyTransform, extractDocImages } = await import("@bendyline/squisq/transform");
+  const { docToMarkdown, markdownToDoc } = await import("@bendyline/squisq/doc");
+  const images = extractDocImages(input.doc.blocks);
+  const result = applyTransform(input.doc, transformStyle, { themeId, images });
+  input.doc = result.doc;
+  const markdownDoc = docToMarkdown(result.doc);
+  input.markdownDoc = markdownDoc;
+  const roundTripped = markdownToDoc(markdownDoc, { autoTemplates: false });
+  if (roundTripped.blocks.length < result.doc.blocks.length) {
+    return [
+      "Transform produced blocks that don\u2019t round-trip to markdown; export may be incomplete."
+    ];
+  }
+  return [];
+}
+async function convert(source, to, options = {}) {
+  const registry = options.registry ?? defaultRegistry();
+  const target = registry.get(to);
+  if (!target) {
+    throw new ConversionError("unknown-format", `Unknown target format "${to}".`, { format: to });
+  }
+  if (!target.exportDoc) {
+    throw new ConversionError(
+      "unsupported-output",
+      `Format "${target.label}" does not support export.`,
+      { format: to, hint: "This format is import-only." }
+    );
+  }
+  const { input, warnings } = await normalize(source, options, registry);
+  if (options.themeId && !input.doc.themeId) {
+    input.doc.themeId = options.themeId;
+  }
+  if (options.transformStyle) {
+    warnings.push(
+      ...await applyTransformStyle(
+        input,
+        options.transformStyle,
+        options.themeId ?? input.doc.themeId
+      )
+    );
+  }
+  let result;
+  try {
+    result = await target.exportDoc(input, options);
+  } catch (err) {
+    if (err instanceof ConversionError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConversionError("conversion-failed", message, { format: to, cause: err });
+  }
+  const ext = target.extensions[0]?.replace(/^\.+/, "") ?? to;
+  return {
+    ...result,
+    suggestedFilename: `${input.baseName}.${ext}`,
+    warnings: [...warnings, ...result.warnings]
+  };
+}
+
+export {
+  BUILTIN_FORMAT_IDS,
+  ConversionError,
+  defaultFormats,
+  createRegistry,
+  defaultRegistry,
+  convert
+};
+//# sourceMappingURL=chunk-RTS5XBZ7.js.map