@bendyline/squisq-formats 1.4.0 → 1.4.2

package/src/registry/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Format registry + programmatic `convert()` — @bendyline/squisq-formats/registry
+ *
+ * A small registry maps format ids (`md`, `docx`, `pdf`, `pptx`, `xlsx`, `csv`,
+ * `html`, `htmlzip`, `epub`, `dbk`) to `FormatDefinition`s that know how to
+ * import to / export from squisq's markdown + Doc model. `convert()` is the
+ * front door: give it a source and a target format id and it returns the
+ * encoded bytes plus a suggested filename.
+ *
+ * @example
+ * ```ts
+ * import { convert } from '@bendyline/squisq-formats/registry';
+ *
+ * const result = await convert(
+ *   { kind: 'markdown', markdown: '# Hello', baseName: 'greeting' },
+ *   'docx',
+ * );
+ * // result.bytes, result.mimeType, result.suggestedFilename ('greeting.docx')
+ * ```
+ */
+
+export type {
+  FormatId,
+  ConversionResult,
+  NormalizedInput,
+  ConvertOptions,
+  FormatDefinition,
+  FormatRegistry,
+  ConvertSource,
+} from './types.js';
+export { BUILTIN_FORMAT_IDS } from './types.js';
+
+export { ConversionError } from './errors.js';
+export type { ConversionErrorCode, ConversionErrorOptions } from './errors.js';
+
+export { createRegistry, defaultRegistry } from './registry.js';
+export { defaultFormats } from './defaultFormats.js';
+export { convert } from './convert.js';

package/src/registry/registry.ts

@@ -0,0 +1,48 @@
+/**
+ * Format registry implementation.
+ *
+ * `createRegistry()` returns an empty, mutable registry (last-write-wins by id);
+ * `defaultRegistry()` returns one preloaded with every built-in format.
+ */
+
+import type { FormatDefinition, FormatId, FormatRegistry } from './types.js';
+import { defaultFormats } from './defaultFormats.js';
+
+/** Normalize an extension to lowercase, without a leading dot. */
+function normalizeExt(ext: string): string {
+  return ext.replace(/^\.+/, '').toLowerCase();
+}
+
+/** Create an empty registry. Registering an existing id overwrites it. */
+export function createRegistry(): FormatRegistry {
+  const byId = new Map<FormatId, FormatDefinition>();
+
+  return {
+    register(def: FormatDefinition): void {
+      byId.set(def.id, def);
+    },
+    get(id: FormatId): FormatDefinition | undefined {
+      return byId.get(id);
+    },
+    byExtension(ext: string): FormatDefinition | undefined {
+      const target = normalizeExt(ext);
+      if (!target) return undefined;
+      for (const def of byId.values()) {
+        if (def.extensions.some((e) => normalizeExt(e) === target)) return def;
+      }
+      return undefined;
+    },
+    list(): FormatDefinition[] {
+      return [...byId.values()];
+    },
+  };
+}
+
+/** Create a registry preloaded with all built-in formats. */
+export function defaultRegistry(): FormatRegistry {
+  const registry = createRegistry();
+  for (const def of defaultFormats()) {
+    registry.register(def);
+  }
+  return registry;
+}

package/src/registry/types.ts

@@ -0,0 +1,107 @@
+/**
+ * Format registry — shared types.
+ *
+ * The registry is the programmatic heart of `convert()`: it maps a small set of
+ * format ids (`md`, `docx`, `pdf`, …) to `FormatDefinition`s, each of which
+ * knows how to import to / export from squisq's markdown + Doc model. Every
+ * converter module is loaded lazily via `import()` inside the definition
+ * methods, so pulling in the registry never eagerly bundles heavy converters.
+ */
+
+import type { Doc } from '@bendyline/squisq/schemas';
+import type { MarkdownDocument } from '@bendyline/squisq/markdown';
+import type { ContentContainer } from '@bendyline/squisq/storage';
+
+/** A format identifier (e.g. `'docx'`). Strings so hosts can register their own. */
+export type FormatId = string;
+
+/** The built-in formats the default registry ships with. */
+export const BUILTIN_FORMAT_IDS = [
+  'md',
+  'docx',
+  'pdf',
+  'pptx',
+  'xlsx',
+  'csv',
+  'html',
+  'htmlzip',
+  'epub',
+  'dbk',
+] as const;
+
+/** The bytes + metadata produced by a successful export. */
+export interface ConversionResult {
+  /** Encoded output bytes. */
+  bytes: Uint8Array;
+  /** MIME type of the output. */
+  mimeType: string;
+  /** A sensible download filename (`<baseName>.<ext>`). */
+  suggestedFilename: string;
+  /** Non-fatal notes accumulated during conversion (may be empty). */
+  warnings: string[];
+}
+
+/**
+ * A source normalized into every shape an exporter might need. `doc` is always
+ * present; `markdownDoc` is present when the source was markdown-shaped (an
+ * exporter that wants markdown but finds none derives it from `doc`).
+ */
+export interface NormalizedInput {
+  doc: Doc;
+  markdownDoc?: MarkdownDocument;
+  container: ContentContainer;
+  baseName: string;
+}
+
+/** Options threaded through `convert()` and into every format method. */
+export interface ConvertOptions {
+  /** Registry to resolve formats against. Defaults to `defaultRegistry()`. */
+  registry?: FormatRegistry;
+  /** Explicit source format id (skips extension/byte sniffing). */
+  from?: FormatId;
+  /** Theme id to apply to the exported document. */
+  themeId?: string;
+  /** Transform style id to apply before export. */
+  transformStyle?: string;
+  /** Content-aware auto-templating when deriving a Doc from markdown. */
+  autoTemplates?: boolean;
+  /** Title hint for exporters that support one (epub, html). */
+  title?: string;
+  /** Lazily resolve the standalone player IIFE bundle (required for HTML export). */
+  resolvePlayerScript?: () => Promise<string>;
+  /** Per-format escape hatch for extra options. */
+  formatOptions?: Record<FormatId, Record<string, unknown>>;
+}
+
+/** Describes how a single format imports to / exports from the squisq model. */
+export interface FormatDefinition {
+  id: FormatId;
+  label: string;
+  mimeType: string;
+  extensions: readonly string[];
+  /** Import raw bytes to a MarkdownDocument. */
+  importDoc?(data: ArrayBuffer, options: ConvertOptions): Promise<MarkdownDocument>;
+  /** Import raw bytes to a ContentContainer (markdown + extracted media). */
+  importContainer?(data: ArrayBuffer, options: ConvertOptions): Promise<ContentContainer>;
+  /** Export a normalized input to bytes. */
+  exportDoc?(input: NormalizedInput, options: ConvertOptions): Promise<ConversionResult>;
+}
+
+/** A mutable collection of format definitions keyed by id. */
+export interface FormatRegistry {
+  register(def: FormatDefinition): void;
+  get(id: FormatId): FormatDefinition | undefined;
+  byExtension(ext: string): FormatDefinition | undefined;
+  list(): FormatDefinition[];
+}
+
+/** The three shapes `convert()` accepts as a source. */
+export type ConvertSource =
+  | { kind: 'bytes'; data: ArrayBuffer | Uint8Array; filename?: string }
+  | {
+      kind: 'markdown';
+      markdown: string | MarkdownDocument;
+      container?: ContentContainer;
+      baseName?: string;
+    }
+  | { kind: 'doc'; doc: Doc; container?: ContentContainer; baseName?: string };

package/src/shared/container.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared tail for the container-producing importers.
+ *
+ * `docxToContainer`, `pptxToContainer`, and `pdfToContainer` all end the same
+ * way: create a `MemoryContentContainer`, write the primary markdown document,
+ * then write each extracted image under its path with its MIME type. This
+ * factors that identical epilogue into one place.
+ */
+
+import { MemoryContentContainer } from '@bendyline/squisq/storage';
+import type { ContentContainer } from '@bendyline/squisq/storage';
+
+/**
+ * Assemble a {@link ContentContainer} from a markdown document plus a set of
+ * media files. `images` is any iterable of `[path, { data, mimeType }]` pairs
+ * (a `Map` from the importers' extraction context satisfies this directly).
+ */
+export async function buildContainer(
+  markdown: string,
+  images: Iterable<readonly [string, { data: ArrayBuffer; mimeType: string }]>,
+): Promise<ContentContainer> {
+  const container = new MemoryContentContainer();
+  await container.writeDocument(markdown);
+  for (const [path, { data, mimeType }] of images) {
+    await container.writeFile(path, new Uint8Array(data), mimeType);
+  }
+  return container;
+}

package/src/shared/images.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared extension → MIME-type mapping for embedded media.
+ *
+ * Previously triplicated with subtle drift: the docx and pptx importers each
+ * carried a byte-identical dotted-key map (png/jpg/.../emf/wmf), while the html
+ * exporter's `inferMimeType` used no-dot keys and a different key set (added
+ * audio/video/ico/avif, omitted tiff/emf/wmf). This module is the single union
+ * of all of them, so a newly-supported type only has to be added once.
+ */
+
+/** Union of every extension→MIME entry the format modules need. */
+const EXT_TO_MIME: Record<string, string> = {
+  // Raster / vector images
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  bmp: 'image/bmp',
+  svg: 'image/svg+xml',
+  tiff: 'image/tiff',
+  tif: 'image/tiff',
+  ico: 'image/x-icon',
+  avif: 'image/avif',
+  // Office vector formats (docx/pptx embedded metafiles)
+  emf: 'image/emf',
+  wmf: 'image/wmf',
+  // Audio / video (html export inlines these as data URIs)
+  mp3: 'audio/mpeg',
+  wav: 'audio/wav',
+  ogg: 'audio/ogg',
+  mp4: 'video/mp4',
+  webm: 'video/webm',
+};
+
+/**
+ * Map a file extension to its MIME type. Tolerates a leading dot and any
+ * casing (`.PNG`, `png`, `.png` all resolve). Returns
+ * `application/octet-stream` for unknown extensions.
+ */
+export function extToMime(ext: string): string {
+  const key = ext.replace(/^\./, '').toLowerCase();
+  return EXT_TO_MIME[key] ?? 'application/octet-stream';
+}

package/src/xlsx/export.ts

@@ -0,0 +1,253 @@
+/**
+ * XLSX export — MarkdownDocument → SpreadsheetML (.xlsx).
+ *
+ * Tables-only fidelity (honestly documented): every `table` node in the
+ * markdown AST becomes one worksheet; all other content (headings, prose,
+ * lists, images, …) is dropped except that the nearest preceding heading is
+ * used to name the sheet. This mirrors the import side (`xlsxToMarkdownDoc`),
+ * which turns each worksheet grid back into a markdown table.
+ *
+ * Cells are emitted as inline strings (`t="inlineStr"`) so no sharedStrings
+ * part is needed, except values matching a plain-number pattern, which are
+ * emitted as numeric cells. The package is assembled with the shared ooxml/
+ * writer (auto-generates `[Content_Types].xml` + `_rels`), so only the
+ * SpreadsheetML-specific parts (workbook, worksheets, styles) are written here.
+ *
+ * @example
+ * ```ts
+ * import { parseMarkdown } from '@bendyline/squisq/markdown';
+ * import { markdownDocToXlsx } from '@bendyline/squisq-formats/xlsx';
+ *
+ * const md = parseMarkdown('# Metrics\n\n| A | B |\n| - | - |\n| 1 | 2 |');
+ * const buffer = await markdownDocToXlsx(md);
+ * ```
+ */
+
+import type { Doc } from '@bendyline/squisq/schemas';
+import { docToMarkdown } from '@bendyline/squisq/doc';
+import type {
+  MarkdownDocument,
+  MarkdownBlockNode,
+  MarkdownTable,
+  MarkdownTableRow,
+} from '@bendyline/squisq/markdown';
+
+import { createPackage } from '../ooxml/writer.js';
+import { xmlDeclaration, escapeXml } from '../ooxml/xmlUtils.js';
+import { extractPlainText } from '../shared/text.js';
+import {
+  NS_SML,
+  NS_R,
+  REL_OFFICE_DOCUMENT,
+  REL_STYLES,
+  REL_WORKSHEET,
+  CONTENT_TYPE_XLSX_WORKBOOK,
+  CONTENT_TYPE_XLSX_WORKSHEET,
+  CONTENT_TYPE_XLSX_STYLES,
+} from '../ooxml/namespaces.js';
+
+/**
+ * Options for XLSX export.
+ */
+export interface XlsxExportOptions {
+  /** Workbook title (written to core properties). */
+  title?: string;
+  /** Workbook author (written to core properties). */
+  author?: string;
+  /** Prefix used for auto-named sheets when no heading precedes a table. Default: "Sheet". */
+  sheetNamePrefix?: string;
+}
+
+interface SheetData {
+  name: string;
+  /** Grid of cell text: first row is the header. */
+  grid: string[][];
+}
+
+/** A plain integer or decimal (optionally negative) — emitted as a numeric cell. */
+const NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+
+/**
+ * Sanitize a candidate name into a valid, unique Excel sheet name.
+ * Strips characters Excel forbids (`[]:*?/\`), caps at 31 chars, and
+ * de-duplicates against already-used names by appending 2, 3, …
+ */
+function sanitizeSheetName(raw: string, used: Set<string>, fallback: string): string {
+  let name = raw.replace(/[[\]:*?/\\]/g, '').trim();
+  if (name.length === 0) name = fallback;
+  name = name.slice(0, 31);
+
+  if (!used.has(name)) {
+    used.add(name);
+    return name;
+  }
+  // Dedupe: "Name", "Name2", "Name3", … keeping within the 31-char cap.
+  for (let n = 2; ; n++) {
+    const suffix = String(n);
+    const base = name.slice(0, 31 - suffix.length);
+    const candidate = `${base}${suffix}`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+  }
+}
+
+/** Convert a table node into a grid of plain-text cells. */
+function tableToGrid(table: MarkdownTable): string[][] {
+  return table.children.map((row: MarkdownTableRow) =>
+    row.children.map((cell) => extractPlainText(cell.children)),
+  );
+}
+
+/** Walk the document, pairing each table with the nearest preceding heading. */
+function collectSheets(doc: MarkdownDocument, prefix: string): SheetData[] {
+  const used = new Set<string>();
+  const sheets: SheetData[] = [];
+  let pendingHeading: string | null = null;
+
+  const visit = (nodes: MarkdownBlockNode[]): void => {
+    for (const node of nodes) {
+      if (node.type === 'heading') {
+        pendingHeading = extractPlainText(node.children);
+      } else if (node.type === 'table') {
+        const fallback = `${prefix}${sheets.length + 1}`;
+        const name = sanitizeSheetName(pendingHeading ?? fallback, used, fallback);
+        sheets.push({ name, grid: tableToGrid(node) });
+        pendingHeading = null;
+      }
+    }
+  };
+
+  visit(doc.children);
+  return sheets;
+}
+
+/** Column letters for a zero-based index (0 → "A", 26 → "AA"). */
+function columnLetter(index: number): string {
+  let n = index + 1;
+  let letters = '';
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    letters = String.fromCharCode(65 + rem) + letters;
+    n = Math.floor((n - 1) / 26);
+  }
+  return letters;
+}
+
+function cellXml(value: string, ref: string): string {
+  if (NUMERIC_RE.test(value)) {
+    return `<c r="${ref}"><v>${escapeXml(value)}</v></c>`;
+  }
+  return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escapeXml(value)}</t></is></c>`;
+}
+
+function worksheetXml(grid: string[][]): string {
+  const rows: string[] = [];
+  for (let r = 0; r < grid.length; r++) {
+    const cells = grid[r]!;
+    const cellsXml = cells.map((value, c) => cellXml(value, `${columnLetter(c)}${r + 1}`)).join('');
+    rows.push(`<row r="${r + 1}">${cellsXml}</row>`);
+  }
+  return (
+    `${xmlDeclaration()}\n` +
+    `<worksheet xmlns="${NS_SML}" xmlns:r="${NS_R}">` +
+    `<sheetData>${rows.join('')}</sheetData>` +
+    `</worksheet>`
+  );
+}
+
+function workbookXml(sheets: SheetData[]): string {
+  const sheetEls = sheets
+    .map(
+      (sheet, i) =>
+        `<sheet name="${escapeXml(sheet.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`,
+    )
+    .join('');
+  return (
+    `${xmlDeclaration()}\n` +
+    `<workbook xmlns="${NS_SML}" xmlns:r="${NS_R}">` +
+    `<sheets>${sheetEls}</sheets>` +
+    `</workbook>`
+  );
+}
+
+/** Minimal but valid styles part (Excel expects the referenced collections to exist). */
+function stylesXml(): string {
+  return (
+    `${xmlDeclaration()}\n` +
+    `<styleSheet xmlns="${NS_SML}">` +
+    `<fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts>` +
+    `<fills count="1"><fill><patternFill patternType="none"/></fill></fills>` +
+    `<borders count="1"><border/></borders>` +
+    `<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>` +
+    `<cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs>` +
+    `</styleSheet>`
+  );
+}
+
+/**
+ * Convert a MarkdownDocument to a .xlsx file (tables-only fidelity).
+ *
+ * Each markdown `table` becomes one worksheet; a document with no tables
+ * yields a single empty sheet (a valid, openable file — never throws).
+ */
+export async function markdownDocToXlsx(
+  doc: MarkdownDocument,
+  options: XlsxExportOptions = {},
+): Promise<ArrayBuffer> {
+  const prefix = options.sheetNamePrefix ?? 'Sheet';
+  let sheets = collectSheets(doc, prefix);
+
+  // Zero tables → one empty sheet so the file is still valid.
+  if (sheets.length === 0) {
+    sheets = [{ name: `${prefix}1`, grid: [] }];
+  }
+
+  const pkg = createPackage();
+
+  // Worksheets + workbook→worksheet relationships.
+  sheets.forEach((sheet, i) => {
+    const sheetPath = `xl/worksheets/sheet${i + 1}.xml`;
+    pkg.addPart(sheetPath, worksheetXml(sheet.grid), CONTENT_TYPE_XLSX_WORKSHEET);
+    pkg.addRelationship('xl/workbook.xml', {
+      id: `rId${i + 1}`,
+      type: REL_WORKSHEET,
+      target: `worksheets/sheet${i + 1}.xml`,
+    });
+  });
+
+  // Styles part (referenced after the sheet relationships).
+  pkg.addPart('xl/styles.xml', stylesXml(), CONTENT_TYPE_XLSX_STYLES);
+  pkg.addRelationship('xl/workbook.xml', {
+    id: `rId${sheets.length + 1}`,
+    type: REL_STYLES,
+    target: 'styles.xml',
+  });
+
+  // Workbook + root relationship.
+  pkg.addPart('xl/workbook.xml', workbookXml(sheets), CONTENT_TYPE_XLSX_WORKBOOK);
+  pkg.addRelationship('', {
+    id: 'rId1',
+    type: REL_OFFICE_DOCUMENT,
+    target: 'xl/workbook.xml',
+  });
+
+  if (options.title || options.author) {
+    pkg.setCoreProperties({
+      title: options.title,
+      creator: options.author,
+      created: new Date().toISOString(),
+      modified: new Date().toISOString(),
+    });
+  }
+
+  return pkg.toArrayBuffer();
+}
+
+/**
+ * Convert a squisq Doc to a .xlsx file (via the markdown table model).
+ */
+export async function docToXlsx(doc: Doc, options?: XlsxExportOptions): Promise<ArrayBuffer> {
+  return markdownDocToXlsx(docToMarkdown(doc), options);
+}

package/src/xlsx/index.ts

@@ -1,54 +1,28 @@
 /**
- * @bendyline/squisq-formats XLSX Module (Stub)
+ * @bendyline/squisq-formats XLSX Module
  *
- * Placeholder for Excel .xlsx import/export support.
- * Will use SpreadsheetML (`<spreadsheet>`, `<worksheet>`, `<sheetData>`)
- * via the shared ooxml/ infrastructure.
+ * Excel .xlsx support via SpreadsheetML and the shared ooxml/ infrastructure.
+ * Both directions are implemented: import (`xlsxToMarkdownDoc` / `xlsxToDoc`)
+ * turns each worksheet grid into a markdown table; export (`markdownDocToXlsx`
+ * / `docToXlsx`) turns each markdown table into a worksheet. Export is
+ * tables-only fidelity — non-table content is dropped (headings only survive
+ * as sheet names). See export.ts for details.
  *
  * @example
  * ```ts
- * import { markdownDocToXlsx } from '@bendyline/squisq-formats/xlsx';
+ * import { xlsxToMarkdownDoc, markdownDocToXlsx } from '@bendyline/squisq-formats/xlsx';
  * ```
  */
 
 import { markdownToDoc } from '@bendyline/squisq/doc';
-import type { MarkdownDocument } from '@bendyline/squisq/markdown';
 import type { Doc } from '@bendyline/squisq/schemas';
 import { type XlsxImportOptions, xlsxToMarkdownDoc } from './import.js';
 
 export type { XlsxImportOptions } from './import.js';
 export { xlsxToMarkdownDoc } from './import.js';
 
-/**
- * Options for XLSX export (placeholder).
- */
-export interface XlsxExportOptions {
-  /** Workbook title */
-  title?: string;
-  /** Workbook author */
-  author?: string;
-}
-
-/**
- * Convert a MarkdownDocument to a .xlsx Blob.
- *
- * @throws Error — XLSX export is not yet implemented
- */
-export async function markdownDocToXlsx(
-  _doc: MarkdownDocument,
-  _options?: XlsxExportOptions,
-): Promise<Blob> {
-  throw new Error('XLSX export is not yet implemented');
-}
-
-/**
- * Convert a squisq Doc to a .xlsx Blob.
- *
- * @throws Error — XLSX export is not yet implemented
- */
-export async function docToXlsx(_doc: Doc, _options?: XlsxExportOptions): Promise<Blob> {
-  throw new Error('XLSX export is not yet implemented');
-}
+export type { XlsxExportOptions } from './export.js';
+export { markdownDocToXlsx, docToXlsx } from './export.js';
 
 /**
  * Convert a .xlsx file to a squisq Doc (via the markdown table model).

package/dist/chunk-A3FHLTY5.js.map

@@ -1 +0,0 @@
-{"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\n/** Map of file extensions to MIME types */\nconst MIME_MAP: Record<string, string> = {\n  jpg: 'image/jpeg',\n  jpeg: 'image/jpeg',\n  png: 'image/png',\n  gif: 'image/gif',\n  webp: 'image/webp',\n  svg: 'image/svg+xml',\n  ico: 'image/x-icon',\n  bmp: 'image/bmp',\n  avif: 'image/avif',\n  mp3: 'audio/mpeg',\n  wav: 'audio/wav',\n  ogg: 'audio/ogg',\n  mp4: 'video/mp4',\n  webm: 'video/webm',\n};\n\n/**\n * Infer a MIME type from a filename's extension.\n * Returns 'application/octet-stream' for unknown types.\n */\nexport function inferMimeType(filename: string): string {\n  const ext = filename.split('.').pop()?.toLowerCase() ?? '';\n  return MIME_MAP[ext] ?? 'application/octet-stream';\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":";AAQA,IAAM,WAAmC;AAAA,EACvC,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AACR;AAMO,SAAS,cAAc,UAA0B;AACtD,QAAM,MAAM,SAAS,MAAM,GAAG,EAAE,IAAI,GAAG,YAAY,KAAK;AACxD,SAAO,SAAS,GAAG,KAAK;AAC1B;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":[]}