@bendyline/squisq-formats 2.1.0 → 2.3.0

package/src/__tests__/xlsxImport.test.ts

@@ -1,80 +0,0 @@
-/**
- * Tests for XLSX import: xlsxToMarkdownDoc. Builds a minimal .xlsx fixture
- * with the shared OOXML writer (dogfooding), then imports it.
- */
-
-import { describe, expect, it } from 'vitest';
-import type { MarkdownHeading, MarkdownTable, MarkdownText } from '@bendyline/squisq/markdown';
-import { NS_R, NS_SML, REL_OFFICE_DOCUMENT } from '../ooxml/namespaces';
-import { createPackage } from '../ooxml/writer';
-import { xmlDeclaration } from '../ooxml/xmlUtils';
-import { xlsxToMarkdownDoc } from '../xlsx/import';
-
-const REL_WORKSHEET =
-  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet';
-const REL_SHARED_STRINGS =
-  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings';
-
-async function buildTestXlsx(): Promise<ArrayBuffer> {
-  const pkg = createPackage();
-
-  pkg.addPart(
-    'xl/workbook.xml',
-    `${xmlDeclaration()}<workbook xmlns="${NS_SML}" xmlns:r="${NS_R}">` +
-      `<sheets><sheet name="Data" sheetId="1" r:id="rId1"/></sheets></workbook>`,
-    'application/xml',
-  );
-  pkg.addPart(
-    'xl/sharedStrings.xml',
-    `${xmlDeclaration()}<sst xmlns="${NS_SML}">` +
-      `<si><t>Name</t></si><si><t>Age</t></si><si><t>Alice</t></si></sst>`,
-    'application/xml',
-  );
-  pkg.addPart(
-    'xl/worksheets/sheet1.xml',
-    `${xmlDeclaration()}<worksheet xmlns="${NS_SML}"><sheetData>` +
-      `<row r="1"><c r="A1" t="s"><v>0</v></c><c r="B1" t="s"><v>1</v></c></row>` +
-      `<row r="2"><c r="A2" t="s"><v>2</v></c><c r="B2"><v>30</v></c></row>` +
-      `</sheetData></worksheet>`,
-    'application/xml',
-  );
-
-  pkg.addRelationship('', { id: 'rId1', type: REL_OFFICE_DOCUMENT, target: 'xl/workbook.xml' });
-  pkg.addRelationship('xl/workbook.xml', {
-    id: 'rId1',
-    type: REL_WORKSHEET,
-    target: 'worksheets/sheet1.xml',
-  });
-  pkg.addRelationship('xl/workbook.xml', {
-    id: 'rId2',
-    type: REL_SHARED_STRINGS,
-    target: 'sharedStrings.xml',
-  });
-
-  return pkg.toArrayBuffer();
-}
-
-describe('xlsxToMarkdownDoc', () => {
-  it('imports a sheet as a heading + table, resolving shared strings', async () => {
-    const doc = await xlsxToMarkdownDoc(await buildTestXlsx());
-    expect(doc.type).toBe('document');
-
-    const heading = doc.children[0] as MarkdownHeading;
-    expect(heading.type).toBe('heading');
-    expect((heading.children[0] as MarkdownText).value).toBe('Data');
-
-    const table = doc.children[1] as MarkdownTable;
-    expect(table.type).toBe('table');
-    expect(table.children).toHaveLength(2);
-    const headerCell = table.children[0]!.children[0]!;
-    expect(headerCell.isHeader).toBe(true);
-    expect((headerCell.children[0] as MarkdownText).value).toBe('Name');
-    expect((table.children[1]!.children[0]!.children[0] as MarkdownText).value).toBe('Alice');
-    expect((table.children[1]!.children[1]!.children[0] as MarkdownText).value).toBe('30');
-  });
-
-  it('selects a single sheet by name without a heading', async () => {
-    const doc = await xlsxToMarkdownDoc(await buildTestXlsx(), { sheet: 'Data' });
-    expect(doc.children[0]!.type).toBe('table');
-  });
-});

package/src/__tests__/zipSafety.test.ts

@@ -1,317 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import JSZip from 'jszip';
-import { getPartXml, openPackage } from '../ooxml/reader';
-import type { OoxmlPackage } from '../ooxml/types';
-import { openBoundedZipArchive, validateZipArchive, ZipSafetyError } from '../shared/zipSafety';
-import { declaredZipEntryCount } from '../shared/zipEntryCount';
-
-interface InstrumentedStream {
-  pause(): InstrumentedStream;
-}
-
-interface StreamableEntry {
-  internalStream(type: 'uint8array'): InstrumentedStream;
-}
-
-async function makeZip(
-  files: Record<string, string | Uint8Array>,
-  compression: 'STORE' | 'DEFLATE' = 'DEFLATE',
-): Promise<Uint8Array> {
-  const zip = new JSZip();
-  for (const [path, data] of Object.entries(files)) zip.file(path, data);
-  return zip.generateAsync({ type: 'uint8array', compression });
-}
-
-function patchMemberMetadata(
-  source: Uint8Array,
-  path: string,
-  patch: { uncompressedSize?: number; crc32?: number },
-): Uint8Array {
-  const bytes = source.slice();
-  const view = new DataView(bytes.buffer);
-  let patchedCentral = false;
-
-  for (let offset = 0; offset <= bytes.byteLength - 4; offset++) {
-    const signature = view.getUint32(offset, true);
-    let nameOffset: number;
-    let nameLengthOffset: number;
-    let uncompressedSizeOffset: number;
-    let crcOffset: number;
-    if (signature === 0x02014b50) {
-      nameOffset = offset + 46;
-      nameLengthOffset = offset + 28;
-      uncompressedSizeOffset = offset + 24;
-      crcOffset = offset + 16;
-    } else if (signature === 0x04034b50) {
-      nameOffset = offset + 30;
-      nameLengthOffset = offset + 26;
-      uncompressedSizeOffset = offset + 22;
-      crcOffset = offset + 14;
-    } else {
-      continue;
-    }
-
-    const nameLength = view.getUint16(nameLengthOffset, true);
-    const name = new TextDecoder().decode(bytes.subarray(nameOffset, nameOffset + nameLength));
-    if (name !== path) continue;
-    if (patch.uncompressedSize !== undefined) {
-      view.setUint32(uncompressedSizeOffset, patch.uncompressedSize, true);
-    }
-    if (patch.crc32 !== undefined) view.setUint32(crcOffset, patch.crc32, true);
-    if (signature === 0x02014b50) patchedCentral = true;
-  }
-
-  expect(patchedCentral).toBe(true);
-  return bytes;
-}
-
-function renameZipMember(source: Uint8Array, from: string, to: string): Uint8Array {
-  expect(to.length).toBe(from.length);
-  const bytes = source.slice();
-  const view = new DataView(bytes.buffer);
-  const replacement = new TextEncoder().encode(to);
-  let renamedCentral = false;
-  for (let offset = 0; offset <= bytes.byteLength - 4; offset++) {
-    const signature = view.getUint32(offset, true);
-    const isCentral = signature === 0x02014b50;
-    const isLocal = signature === 0x04034b50;
-    if (!isCentral && !isLocal) continue;
-    const nameLengthOffset = offset + (isCentral ? 28 : 26);
-    const nameOffset = offset + (isCentral ? 46 : 30);
-    const nameLength = view.getUint16(nameLengthOffset, true);
-    const name = new TextDecoder().decode(bytes.subarray(nameOffset, nameOffset + nameLength));
-    if (name !== from) continue;
-    bytes.set(replacement, nameOffset);
-    if (isCentral) renamedCentral = true;
-  }
-  expect(renamedCentral).toBe(true);
-  return bytes;
-}
-
-describe('bounded JSZip reads', () => {
-  it('preflights duplicate central records before JSZip collapses their names', async () => {
-    const valid = await makeZip({ 'one.txt': '1', 'two.txt': '2' }, 'STORE');
-    const duplicate = renameZipMember(valid, 'two.txt', 'one.txt');
-    const parsed = await JSZip.loadAsync(duplicate);
-    expect(Object.values(parsed.files).filter((entry) => !entry.dir)).toHaveLength(1);
-
-    const blob = new Blob([duplicate.slice().buffer]);
-    await expect(openBoundedZipArchive(blob, { maxEntries: 1 })).rejects.toMatchObject({
-      code: 'too-many-entries',
-      limit: 1,
-      actual: 2,
-    });
-  });
-
-  it('counts directory-only central records toward the entry limit', async () => {
-    const zip = new JSZip();
-    zip.folder('one');
-    zip.folder('two');
-    const data = await zip.generateAsync({ type: 'uint8array' });
-    await expect(openBoundedZipArchive(data, { maxEntries: 1 })).rejects.toMatchObject({
-      code: 'too-many-entries',
-      actual: 2,
-    });
-  });
-
-  it('finds the EOCD record with a comment containing signature-like bytes', async () => {
-    const zip = new JSZip();
-    zip.file('one.txt', '1');
-    zip.file('two.txt', '2');
-    const data = await zip.generateAsync({
-      type: 'uint8array',
-      comment: 'looks like PK\u0005\u0006 but is only a comment',
-    });
-    expect(declaredZipEntryCount(data)).toBe(2);
-  });
-
-  it('reads ZIP64 record counts and falls back when ZIP64 metadata is ambiguous', () => {
-    const zip64 = new Uint8Array(98);
-    const view = new DataView(zip64.buffer);
-    view.setUint32(0, 0x06064b50, true);
-    view.setUint32(32, 3, true);
-    view.setUint32(56, 0x07064b50, true);
-    view.setUint32(64, 0, true);
-    view.setUint32(76, 0x06054b50, true);
-    view.setUint16(86, 0xffff, true);
-    expect(declaredZipEntryCount(zip64)).toBe(3);
-
-    zip64.fill(0, 56, 76);
-    expect(declaredZipEntryCount(zip64)).toBeUndefined();
-  });
-
-  it('maps Blob read failures to a structured invalid-archive error', async () => {
-    const unreadable = {
-      size: 10,
-      slice: () => unreadable,
-      arrayBuffer: () => Promise.reject(new Error('read failed')),
-    } as unknown as Blob;
-    await expect(openBoundedZipArchive(unreadable)).rejects.toMatchObject({
-      code: 'invalid-archive',
-    });
-  });
-
-  it('returns structured errors while preserving established messages', async () => {
-    const data = await makeZip({ 'large.txt': '12345' }, 'STORE');
-    let error: unknown;
-    try {
-      await openBoundedZipArchive(data, { maxEntryUncompressedBytes: 4 });
-    } catch (caught: unknown) {
-      error = caught;
-    }
-
-    expect(error).toBeInstanceOf(ZipSafetyError);
-    expect(error).toMatchObject({
-      name: 'ZipSafetyError',
-      code: 'entry-too-large',
-      path: 'large.txt',
-      limit: 4,
-      actual: 5,
-    });
-    expect((error as Error).message).toMatch(/exceeds 4 byte per-entry limit/);
-  });
-
-  it('rejects a high-ratio member from central-directory metadata', async () => {
-    const data = await makeZip({ 'repeated.bin': new Uint8Array(128 * 1024) });
-    await expect(openBoundedZipArchive(data, { maxCompressionRatio: 2 })).rejects.toMatchObject({
-      code: 'compression-ratio-exceeded',
-      path: 'repeated.bin',
-      limit: 2,
-    });
-  });
-
-  it('enforces the default compression-ratio ceiling against a single-member bomb', async () => {
-    const data = await makeZip({ 'zeros.bin': new Uint8Array(2 * 1024 * 1024) });
-    await expect(openBoundedZipArchive(data)).rejects.toMatchObject({
-      code: 'compression-ratio-exceeded',
-      path: 'zeros.bin',
-      limit: 1000,
-    });
-  });
-
-  it('halts an underdeclared member on its first emitted chunk without retaining it', async () => {
-    const valid = await makeZip({ 'bomb.txt': new Uint8Array(1024 * 1024) });
-    const forged = patchMemberMetadata(valid, 'bomb.txt', { uncompressedSize: 1 });
-    const archive = await openBoundedZipArchive(forged);
-
-    await expect(archive.read('bomb.txt')).rejects.toMatchObject({
-      code: 'size-mismatch',
-      path: 'bomb.txt',
-    });
-    expect(archive.emittedUncompressedBytes).toBe(0);
-  });
-
-  it('pauses every concurrent JSZip stream when one read breaches its bound', async () => {
-    const data = await makeZip(
-      {
-        'one.bin': new Uint8Array(64 * 1024),
-        'two.bin': new Uint8Array(64 * 1024),
-      },
-      'STORE',
-    );
-    const archive = await openBoundedZipArchive(data);
-    const pauseSpies: Array<ReturnType<typeof vi.fn>> = [];
-
-    for (const metadata of archive.entries) {
-      const entry = metadata.entry as unknown as StreamableEntry;
-      const original = entry.internalStream.bind(entry);
-      entry.internalStream = ((type: 'uint8array') => {
-        const stream = original(type);
-        const pause = vi.fn(stream.pause.bind(stream));
-        stream.pause = pause;
-        pauseSpies.push(pause);
-        return stream;
-      }) as StreamableEntry['internalStream'];
-    }
-
-    const results = await Promise.allSettled([
-      archive.read('one.bin', 1),
-      archive.read('two.bin', 1),
-    ]);
-    expect(results.every((result) => result.status === 'rejected')).toBe(true);
-    expect(pauseSpies).toHaveLength(2);
-    expect(pauseSpies.every((pause) => pause.mock.calls.length > 0)).toBe(true);
-    expect(archive.emittedUncompressedBytes).toBe(0);
-  });
-
-  it('caches successful part reads without charging the aggregate budget twice', async () => {
-    const data = await makeZip({ 'part.xml': '<part />' }, 'STORE');
-    const archive = await openBoundedZipArchive(data);
-    const first = await archive.read('part.xml');
-    const emittedAfterFirstRead = archive.emittedUncompressedBytes;
-    const second = await archive.read('part.xml');
-
-    expect(second).toBe(first);
-    expect(archive.emittedUncompressedBytes).toBe(emittedAfterFirstRead);
-    expect(emittedAfterFirstRead).toBe(new TextEncoder().encode('<part />').byteLength);
-  });
-
-  it('checks CRC32 while streaming instead of eagerly inflating during load', async () => {
-    const valid = await makeZip({ 'content.txt': 'integrity' }, 'STORE');
-    const forged = patchMemberMetadata(valid, 'content.txt', { crc32: 0 });
-    const archive = await openBoundedZipArchive(forged);
-
-    await expect(archive.read('content.txt')).rejects.toMatchObject({
-      code: 'crc-mismatch',
-      path: 'content.txt',
-    });
-  });
-
-  it('does not reject an otherwise valid JSZip object solely for unavailable internals', async () => {
-    const data = await makeZip({ 'content.txt': 'okay' }, 'STORE');
-    const zip = await JSZip.loadAsync(data);
-    const entry = zip.file('content.txt') as unknown as {
-      _data: { uncompressedSize?: number; compressedSize?: number; crc32?: number };
-    };
-    delete entry._data.uncompressedSize;
-    delete entry._data.compressedSize;
-    delete entry._data.crc32;
-
-    expect(() => validateZipArchive(zip)).not.toThrow();
-  });
-
-  it('rejects manually constructed OOXML packages that bypass bounded archive opening', async () => {
-    const forged = {
-      contentTypes: { overrides: new Map(), defaults: new Map() },
-      rootRelationships: [],
-    } as unknown as OoxmlPackage;
-
-    await expect(getPartXml(forged, 'custom.xml')).rejects.toThrow(
-      'Invalid OoxmlPackage: create packages with openPackage().',
-    );
-  });
-
-  it('bounds mandatory OOXML metadata independently of large media allowances', async () => {
-    const oversizedContentTypes = `<Types>${' '.repeat(1024 * 1024)}</Types>`;
-    const data = await makeZip(
-      {
-        '[Content_Types].xml': oversizedContentTypes,
-        'word/media/large.bin': new Uint8Array(2 * 1024 * 1024),
-      },
-      'STORE',
-    );
-
-    await expect(openPackage(data.slice().buffer)).rejects.toMatchObject({
-      code: 'entry-too-large',
-      path: '[Content_Types].xml',
-      limit: 1024 * 1024,
-    });
-  });
-
-  it('bounds OOXML relationship metadata before DOM parsing', async () => {
-    const oversizedRelationships = `<Relationships>${' '.repeat(4 * 1024 * 1024)}</Relationships>`;
-    const data = await makeZip(
-      {
-        '[Content_Types].xml': '<Types />',
-        '_rels/.rels': oversizedRelationships,
-      },
-      'STORE',
-    );
-
-    await expect(openPackage(data.slice().buffer)).rejects.toMatchObject({
-      code: 'entry-too-large',
-      path: '_rels/.rels',
-      limit: 4 * 1024 * 1024,
-    });
-  });
-});

package/src/container/index.ts

@@ -1,94 +0,0 @@
-/**
- * Container ZIP serialization — convert between ContentContainer and ZIP archives.
- *
- * Uses JSZip (already a formats dependency) to serialize a ContentContainer to
- * a ZIP blob and to deserialize a ZIP blob into a MemoryContentContainer.
- *
- * ZIP structure mirrors the container's flat path hierarchy directly:
- *   index.md
- *   images/hero.jpg
- *   audio/narration.mp3
- *   timing.json
- */
-
-import JSZip from 'jszip';
-import type { ContentContainer } from '@bendyline/squisq/storage';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
-import {
-  assertSafeZipPath,
-  openBoundedZipArchive,
-  ZipSafetyError,
-  type ZipSafetyLimits,
-  type ZipSafetyErrorCode,
-  type ZipSafetyErrorOptions,
-} from '../shared/zipSafety.js';
-
-export type ZipToContainerOptions = ZipSafetyLimits;
-export interface ContainerToZipOptions {
-  /** STORE avoids producing archives that violate strict import compression-ratio policies. */
-  compression?: 'STORE' | 'DEFLATE';
-  /** JSZip DEFLATE level; ignored for STORE. */
-  compressionLevel?: number;
-}
-export { ZipSafetyError };
-export type { ZipSafetyLimits, ZipSafetyErrorCode, ZipSafetyErrorOptions };
-
-/**
- * Serialize a ContentContainer to a ZIP blob.
- *
- * All files in the container are written to the ZIP archive preserving
- * their path structure. The resulting blob can be saved as a .zip file.
- *
- * @param container — The container to serialize
- * @returns A Blob containing the ZIP archive
- */
-export async function containerToZip(
-  container: ContentContainer,
-  options: ContainerToZipOptions = {},
-): Promise<Blob> {
-  const zip = new JSZip();
-  const entries = await container.listFiles();
-
-  for (const entry of entries) {
-    assertSafeZipPath(entry.path);
-    const data = await container.readFile(entry.path);
-    if (data) {
-      zip.file(entry.path, new Uint8Array(data));
-    }
-  }
-
-  const compression = options.compression ?? 'DEFLATE';
-  const compressionLevel = options.compressionLevel ?? 6;
-  if (!Number.isSafeInteger(compressionLevel) || compressionLevel < 1 || compressionLevel > 9) {
-    throw new Error('ZIP compression level must be an integer between 1 and 9');
-  }
-  return zip.generateAsync({
-    type: 'blob',
-    compression,
-    ...(compression === 'DEFLATE' ? { compressionOptions: { level: compressionLevel } } : {}),
-  });
-}
-
-/**
- * Deserialize a ZIP archive into a MemoryContentContainer.
- *
- * Reads all files from the ZIP and writes them into a new MemoryContentContainer.
- * Directory entries are skipped. The resulting container can be used immediately
- * for rendering, editing, or saving to persistent storage.
- *
- * @param zipData — The ZIP archive as ArrayBuffer, Uint8Array, or Blob
- * @returns A MemoryContentContainer populated with the ZIP's contents
- */
-export async function zipToContainer(
-  zipData: ArrayBuffer | Uint8Array | Blob,
-  options: ZipToContainerOptions = {},
-): Promise<MemoryContentContainer> {
-  const archive = await openBoundedZipArchive(zipData, options);
-  const container = new MemoryContentContainer();
-  for (const { path } of archive.entries) {
-    const data = await archive.read(path);
-    if (data) await container.writeFile(path, data);
-    archive.release(path);
-  }
-  return container;
-}

package/src/csv/index.ts

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