@cj-tech-master/excelts 7.6.0 → 8.0.0

package/dist/types/index.browser.d.ts

@@ -23,6 +23,8 @@ export { WorksheetWriter } from "./modules/excel/stream/worksheet-writer.js";
 export { WorksheetReader } from "./modules/excel/stream/worksheet-reader.js";
 export type { CsvOptions, CsvInput } from "./modules/excel/workbook.js";
 export { CsvParserStream, CsvFormatterStream, createCsvParserStream, createCsvFormatterStream } from "./modules/csv/stream/index.js";
+export type { MarkdownOptions } from "./modules/markdown/types.js";
+export type { MarkdownAlignment, MarkdownParseResult, MarkdownParseOptions, MarkdownColumnConfig, MarkdownFormatOptions } from "./modules/markdown/types.js";
 export { DefinedNames, type DefinedNameModel } from "./modules/excel/defined-names.js";
 export type { CheckboxState } from "./modules/excel/form-control.js";
 export type { ColumnDefn, ColumnHeaderValue } from "./modules/excel/column.js";
@@ -40,3 +42,4 @@ export { concatUint8Arrays, toUint8Array, stringToUint8Array, uint8ArrayToString
 export { pdf, excelToPdf, PageSizes, PdfError, PdfRenderError, PdfFontError, PdfStructureError, isPdfError } from "./modules/pdf/index.js";
 export type { PdfExportOptions, PdfPageSize, PdfOrientation, PdfMargins, PageSizeName, PdfColor } from "./modules/pdf/index.js";
 export { ExcelError, isExcelError, ExcelFileError, ExcelDownloadError, ExcelNotSupportedError, ExcelStreamStateError, InvalidAddressError, ColumnOutOfBoundsError, RowOutOfBoundsError, MergeConflictError, InvalidValueTypeError, XmlParseError, WorksheetNameError, PivotTableError, TableError, ImageError, MaxItemsExceededError } from "./modules/excel/errors.js";
+export { MarkdownError, MarkdownParseError } from "./modules/markdown/errors.js";

package/dist/types/index.d.ts

@@ -22,6 +22,8 @@ export type { WorksheetReaderOptions, WorksheetEvent, RowEvent, HyperlinkEvent,
 export type { WorkbookWriterOptions, WorkbookZipOptions, ZlibOptions } from "./modules/excel/stream/workbook-writer.js";
 export type { CsvOptions, CsvInput } from "./modules/excel/workbook.js";
 export { CsvParserStream, CsvFormatterStream, createCsvParserStream, createCsvFormatterStream } from "./modules/csv/stream/index.js";
+export type { MarkdownOptions } from "./modules/markdown/types.js";
+export type { MarkdownAlignment, MarkdownParseResult, MarkdownParseOptions, MarkdownColumnConfig, MarkdownFormatOptions } from "./modules/markdown/types.js";
 export { DefinedNames, type DefinedNameModel } from "./modules/excel/defined-names.js";
 export type { CheckboxState } from "./modules/excel/form-control.js";
 export type { ColumnDefn, ColumnHeaderValue } from "./modules/excel/column.js";
@@ -40,3 +42,4 @@ export { concatUint8Arrays, toUint8Array, stringToUint8Array, uint8ArrayToString
 export { pdf, excelToPdf, PageSizes, PdfError, PdfRenderError, PdfFontError, PdfStructureError, isPdfError } from "./modules/pdf/index.js";
 export type { PdfExportOptions, PdfPageSize, PdfOrientation, PdfMargins, PageSizeName, PdfColor } from "./modules/pdf/index.js";
 export { ExcelError, isExcelError, ExcelFileError, ExcelDownloadError, ExcelNotSupportedError, ExcelStreamStateError, InvalidAddressError, ColumnOutOfBoundsError, RowOutOfBoundsError, MergeConflictError, InvalidValueTypeError, XmlParseError, WorksheetNameError, PivotTableError, TableError, ImageError, MaxItemsExceededError } from "./modules/excel/errors.js";
+export { MarkdownError, MarkdownParseError } from "./modules/markdown/errors.js";

package/dist/types/modules/archive/compression/deflate-fallback.d.ts

@@ -28,18 +28,18 @@ export declare function inflateRaw(data: Uint8Array): Uint8Array;
  */
 export declare function deflateRawStore(data: Uint8Array): Uint8Array;
 /**
- * Compress data using DEFLATE with fixed Huffman codes.
+ * Compress data using DEFLATE with Dynamic Huffman codes (BTYPE=2).
  *
- * Uses LZ77 with hash chains and lazy matching for significantly better
- * compression than a single-entry hash table. The algorithm is modelled
- * after zlib's "fast" and "slow" deflate strategies.
+ * Uses LZ77 with hash chains and lazy matching for match finding, then builds
+ * optimal Huffman trees from the symbol frequencies for entropy coding.
  *
  * @param data - Data to compress
+ * @param level - Compression level (1-9, default 6)
  * @returns Compressed data in deflate-raw format
  */
-export declare function deflateRawCompressed(data: Uint8Array): Uint8Array;
+export declare function deflateRawCompressed(data: Uint8Array, level?: number): Uint8Array;
 /**
- * Stateful synchronous DEFLATE compressor.
+ * Stateful synchronous DEFLATE compressor with Dynamic Huffman encoding.
  *
  * Unlike `deflateRawCompressed` (which is a one-shot function), this class
  * maintains state across multiple `write()` calls:
@@ -47,32 +47,29 @@ export declare function deflateRawCompressed(data: Uint8Array): Uint8Array;
  *  - **LZ77 sliding window**: back-references can span across chunks.
  *  - **Hash chains**: match positions persist across chunks with typed-array
  *    hash tables for fast lookup.
- *  - **Lazy matching**: each match is compared with the next position's match
- *    to pick the longer one.
+ *  - **Lazy matching**: configurable per compression level.
+ *  - **Dynamic Huffman**: each block builds optimal Huffman trees from
+ *    actual symbol frequencies (BTYPE=2), producing significantly smaller
+ *    output than fixed Huffman (BTYPE=1).
  *  - **Bit writer**: bit position is preserved, so consecutive blocks form
  *    a single valid DEFLATE bit-stream without alignment issues.
  *
- * Each `write()` emits one non-final fixed-Huffman block (BFINAL=0).
- * `finish()` emits a final empty block (BFINAL=1) and returns the tail bytes.
+ * Each `write()` emits one non-final Dynamic Huffman block (BFINAL=0).
+ * `finish()` emits a final empty fixed-Huffman block (BFINAL=1).
  *
  * This is the pure-JS equivalent of Node.js `zlib.deflateRawSync` with
  * `Z_SYNC_FLUSH`, used by the streaming ZIP writer (`pushSync`) to achieve
  * constant-memory streaming in both Node.js and browsers.
+ *
+ * @param level - Compression level (0-9). Level 0 emits STORE blocks.
+ *                Default: 6 (matching zlib default).
  */
 export declare class SyncDeflater {
     private _output;
-    private _head;
-    private _prev;
-    /** Sliding window: the last WINDOW_SIZE bytes of uncompressed data. */
-    private _window;
-    /** Number of valid bytes currently in the window. */
-    private _windowLen;
-    /** Total bytes written so far (monotonically increasing; used for hash offsets). */
-    private _totalIn;
-    private _hasPrevMatch;
-    private _prevMatchLen;
-    private _prevMatchDist;
-    private _prevLiteral;
+    private _config;
+    private _level;
+    private _state;
+    constructor(level?: number);
     /**
      * Compress a chunk and return the compressed bytes produced so far.
      * The output is a valid prefix of a DEFLATE stream (one or more non-final blocks).
@@ -83,4 +80,9 @@ export declare class SyncDeflater {
      * and returns any remaining bytes (including partial-byte padding).
      */
     finish(): Uint8Array;
+    /**
+     * Write STORE (uncompressed) blocks for level=0.
+     * Each block is non-final (BFINAL=0); the final block is emitted by finish().
+     */
+    private _writeStore;
 }

package/dist/types/modules/archive/compression/streaming-compress.browser.d.ts

@@ -44,3 +44,10 @@ export declare function createUnzlibStream(options?: StreamCompressOptions): Unz
  * bit-stream state across `write()` calls.
  */
 export { PureJsSyncDeflater as SyncDeflater };
+/**
+ * Returns true when the browser supports native `CompressionStream("deflate-raw")`,
+ * signalling that `push()` should prefer the async path over `SyncDeflater`.
+ *
+ * Only checks for compression support — decompression is not needed for writing.
+ */
+export declare function hasNativeAsyncDeflate(): boolean;

package/dist/types/modules/archive/compression/streaming-compress.d.ts

@@ -75,3 +75,8 @@ export declare class SyncDeflater implements SyncDeflaterLike {
     finish(): Uint8Array;
     private _flushBatch;
 }
+/**
+ * On Node.js, `zlib.deflateRawSync` is native and fast — no need to detour
+ * through the async streaming path. Always returns false.
+ */
+export declare function hasNativeAsyncDeflate(): boolean;

package/dist/types/modules/excel/workbook.browser.d.ts

@@ -16,6 +16,7 @@ import { WorkbookWriter, type WorkbookWriterOptions } from "./stream/workbook-wr
 import { WorkbookReader, type WorkbookReaderOptions } from "./stream/workbook-reader.js";
 import { type DateFormat } from "../../utils/datetime.js";
 import type { CsvParseOptions, CsvFormatOptions } from "../csv/types.js";
+import type { MarkdownOptions } from "../markdown/types.js";
 import type { Readable } from "../stream/index.js";
 import type { IReadable, IWritable } from "../stream/types.js";
 import type { PivotTable } from "./pivot-table.js";
@@ -253,6 +254,77 @@ declare class Workbook {
     private _readCsvFile;
     private _readCsvBlob;
     private _writeCsvString;
+    /**
+     * Populate a worksheet from a parsed Markdown table result.
+     * Shared by readMarkdown and readMarkdownAll.
+     */
+    private _populateMarkdownWorksheet;
+    /**
+     * Read a Markdown table and add as worksheet.
+     *
+     * @example
+     * ```ts
+     * // From a Markdown string
+     * workbook.readMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+     *
+     * // With options
+     * workbook.readMarkdown(markdownString, { sheetName: "Data", map: (v, col) => Number(v) || v });
+     * ```
+     */
+    readMarkdown(input: string, options?: MarkdownOptions): Worksheet;
+    /**
+     * Read all Markdown tables from a document, each becoming a separate worksheet.
+     *
+     * @param input - Markdown string containing one or more tables
+     * @param options - Parse options (sheetName is used as prefix: "sheetName", "sheetName_2", ...)
+     * @returns Array of created worksheets (empty if no tables found)
+     *
+     * @example
+     * ```ts
+     * // Parse a document with multiple tables
+     * const sheets = workbook.readMarkdownAll(markdownDoc);
+     * console.log(`Created ${sheets.length} worksheets`);
+     *
+     * // With a naming prefix
+     * const sheets = workbook.readMarkdownAll(markdownDoc, { sheetName: "Table" });
+     * // Creates "Table", "Table_2", "Table_3", ...
+     * ```
+     */
+    readMarkdownAll(input: string, options?: MarkdownOptions): Worksheet[];
+    /**
+     * Write worksheet as a Markdown table string.
+     *
+     * @example
+     * ```ts
+     * // Write first worksheet
+     * const markdownText = workbook.writeMarkdown();
+     *
+     * // Write specific worksheet with options
+     * const markdownText = workbook.writeMarkdown({ sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdown(options?: MarkdownOptions): string;
+    /**
+     * Write worksheet to Markdown buffer (Uint8Array).
+     *
+     * @example
+     * ```ts
+     * const buffer = workbook.writeMarkdownBuffer();
+     * ```
+     */
+    writeMarkdownBuffer(options?: MarkdownOptions): Uint8Array;
+    /**
+     * Read Markdown from file (Node.js only - throws in browser)
+     */
+    readMarkdownFile(_filename: string, _options?: MarkdownOptions): Promise<Worksheet>;
+    /**
+     * Read all Markdown tables from file (Node.js only - throws in browser)
+     */
+    readMarkdownAllFile(_filename: string, _options?: MarkdownOptions): Promise<Worksheet[]>;
+    /**
+     * Write Markdown to file (Node.js only - throws in browser)
+     */
+    writeMarkdownFile(_filename: string, _options?: MarkdownOptions): Promise<void>;
     /**
      * Create a streaming workbook writer for large files.
      * This is more memory-efficient than using Workbook for large datasets.

package/dist/types/modules/excel/workbook.d.ts

@@ -1,10 +1,11 @@
 /**
  * Workbook - Node.js Version
  *
- * Extends browser Workbook with Node.js file system support for CSV operations.
+ * Extends browser Workbook with Node.js file system support for CSV and Markdown operations.
  */
 import { Workbook as WorkbookBrowser, type CsvOptions } from "./workbook.browser.js";
 import type { Worksheet } from "./worksheet.js";
+import type { MarkdownOptions } from "../markdown/types.js";
 declare class Workbook extends WorkbookBrowser {
     /**
      * Read CSV from file (Node.js only)
@@ -27,6 +28,36 @@ declare class Workbook extends WorkbookBrowser {
      * ```
      */
     writeCsvFile(filename: string, options?: CsvOptions): Promise<void>;
+    /**
+     * Read Markdown table from file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownFile("table.md");
+     * await workbook.readMarkdownFile("table.md", { sheetName: "Data" });
+     * ```
+     */
+    readMarkdownFile(filename: string, options?: MarkdownOptions): Promise<Worksheet>;
+    /**
+     * Read all Markdown tables from file, each as a separate worksheet (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownAllFile("doc.md");
+     * await workbook.readMarkdownAllFile("doc.md", { sheetName: "Table" });
+     * ```
+     */
+    readMarkdownAllFile(filename: string, options?: MarkdownOptions): Promise<Worksheet[]>;
+    /**
+     * Write Markdown table to file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.writeMarkdownFile("output.md");
+     * await workbook.writeMarkdownFile("output.md", { sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdownFile(filename: string, options?: MarkdownOptions): Promise<void>;
 }
 export { Workbook };
 export type { CsvOptions, CsvInput, WorkbookModel, WorkbookMedia } from "./workbook.browser.js";

package/dist/types/modules/markdown/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Markdown Module Constants
+ *
+ * Shared constants used across the Markdown module.
+ */
+/**
+ * Pre-compiled regex for line splitting (matches CR, LF, or CRLF)
+ */
+export declare const LINEBREAK_REGEX: RegExp;
+/**
+ * Characters that need escaping in Markdown table cells.
+ * Also matches CRLF/CR/LF so that escaping + newline conversion
+ * can be done in a single `replace()` call.
+ * Note: `\r\n` must come before `\r` to match CRLF as a single unit.
+ */
+export declare const ESCAPE_AND_NEWLINE: RegExp;
+/**
+ * Regex to unescape Markdown table cell content (`\|` → `|`, `\\` → `\`)
+ */
+export declare const UNESCAPE_REGEX: RegExp;
+/**
+ * Regex to match `<br>`, `<br/>`, or `<br />` tags (case-insensitive).
+ * Used to convert multiline cell representations back to newlines during parsing.
+ */
+export declare const BR_TAG_REGEX: RegExp;
+/**
+ * Regex to match literal newlines (CR, LF, or CRLF) in cell content.
+ * Used when escaping is disabled but newline conversion is still needed.
+ */
+export declare const NEWLINE_IN_CELL: RegExp;

package/dist/types/modules/markdown/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Markdown module error types.
+ */
+import { BaseError } from "../../utils/errors.js";
+/**
+ * Base class for all Markdown-related errors.
+ */
+export declare class MarkdownError extends BaseError {
+    name: string;
+}
+/**
+ * Error thrown when Markdown parsing fails.
+ */
+export declare class MarkdownParseError extends MarkdownError {
+    name: string;
+    /** 1-based line number where the error occurred */
+    readonly line: number;
+    constructor(message: string, line: number, options?: {
+        cause?: unknown;
+    });
+}

package/dist/types/modules/markdown/format/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Markdown Table Formatter
+ *
+ * Formats data into well-formed Markdown table strings.
+ *
+ * Features:
+ * - Auto column width calculation with padding
+ * - Column alignment (left, center, right, none)
+ * - Proper escaping of pipe characters and backslashes
+ * - Compact mode (disable column-width alignment) for minimal output
+ * - Configurable column definitions
+ * - Multiline cell content (newlines converted to `<br>`)
+ *
+ * @example
+ * ```ts
+ * // Simple array data with headers
+ * formatMarkdown(["Name", "Age"], [["Alice", "30"], ["Bob", "25"]]);
+ * // | Name  | Age |
+ * // | ----- | --- |
+ * // | Alice | 30  |
+ * // | Bob   | 25  |
+ *
+ * // With alignment
+ * formatMarkdown(["Left", "Center", "Right"], data, {
+ *   alignment: "left",
+ *   columns: [
+ *     { header: "Left", alignment: "left" },
+ *     { header: "Center", alignment: "center" },
+ *     { header: "Right", alignment: "right" }
+ *   ]
+ * });
+ * ```
+ */
+import type { MarkdownFormatOptions } from "../types.js";
+/**
+ * Format data as a Markdown table string.
+ *
+ * @param headers - Column header strings
+ * @param rows - Data rows (each row is an array of cell values)
+ * @param options - Formatting options
+ * @returns Formatted Markdown table string
+ *
+ * @example
+ * ```ts
+ * formatMarkdown(
+ *   ["Name", "Age", "City"],
+ *   [
+ *     ["Alice", 30, "New York"],
+ *     ["Bob", 25, "London"]
+ *   ]
+ * );
+ * ```
+ */
+export declare function formatMarkdown(headers: string[], rows: unknown[][], options?: MarkdownFormatOptions): string;

package/dist/types/modules/markdown/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Markdown Module - Public API
+ *
+ * Pure Markdown table parsing/formatting functionality with no Excel dependencies.
+ * For Markdown-Worksheet integration, use Workbook.readMarkdown/writeMarkdown methods instead.
+ *
+ * Design principles:
+ * - Only export types and functions that are part of the PUBLIC API
+ * - Internal utilities are used internally but not exported
+ * - This reduces bundle size and simplifies the public interface
+ */
+export type { MarkdownAlignment, MarkdownParseResult, MarkdownParseOptions, MarkdownColumnConfig, MarkdownFormatOptions, MarkdownOptions } from "./types.js";
+export { parseMarkdown, parseMarkdownAll } from "./parse/index.js";
+export { formatMarkdown } from "./format/index.js";
+export { MarkdownError, MarkdownParseError } from "./errors.js";

package/dist/types/modules/markdown/parse/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Markdown Table Parser
+ *
+ * Parses Markdown tables into structured data.
+ *
+ * Supports:
+ * - Standard GFM (GitHub Flavored Markdown) table syntax
+ * - Column alignment detection via separator row
+ * - Escaped pipes (`\|`) in cell content
+ * - Tables with or without leading/trailing pipes
+ * - Tolerant parsing (mismatched column counts, extra whitespace)
+ * - Multiline cell content via `<br>` / `<br/>` / `<br />` tags
+ *
+ * @example
+ * ```ts
+ * const result = parseMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+ * // result.headers = ["Name", "Age"]
+ * // result.rows = [["Alice", "30"]]
+ * // result.alignments = ["none", "none"]
+ * ```
+ */
+import type { MarkdownParseOptions, MarkdownParseResult } from "../types.js";
+/**
+ * Parse a Markdown table string into structured data.
+ *
+ * The parser looks for the GFM table pattern:
+ * 1. A header row (pipe-delimited cells)
+ * 2. A separator row (dashes with optional colons for alignment)
+ * 3. Zero or more data rows
+ *
+ * Non-table content before and after the table is ignored.
+ *
+ * @param input - Markdown string containing a table
+ * @param options - Parse options
+ * @returns Parsed table data with headers, rows, and alignments
+ *
+ * @throws {MarkdownParseError} When no valid table is found in the input
+ *
+ * @example
+ * ```ts
+ * // Basic table
+ * const result = parseMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+ *
+ * // With alignment
+ * const result = parseMarkdown("| Left | Center | Right |\n|:---|:---:|---:|\n|a|b|c|");
+ * // result.alignments = ["left", "center", "right"]
+ *
+ * // From a larger Markdown document
+ * const result = parseMarkdown(markdownDoc); // Finds the first table
+ *
+ * // With options
+ * const result = parseMarkdown(input, { trim: false, maxRows: 100 });
+ * ```
+ */
+export declare function parseMarkdown(input: string, options?: MarkdownParseOptions): MarkdownParseResult;
+/**
+ * Parse all Markdown tables from a document.
+ *
+ * @param input - Markdown string containing one or more tables
+ * @param options - Parse options (maxRows applies per table)
+ * @returns Array of parsed tables
+ *
+ * @example
+ * ```ts
+ * const tables = parseMarkdownAll(markdownDoc);
+ * console.log(`Found ${tables.length} tables`);
+ * tables.forEach((t, i) => console.log(`Table ${i}: ${t.headers.join(", ")}`));
+ * ```
+ */
+export declare function parseMarkdownAll(input: string, options?: MarkdownParseOptions): MarkdownParseResult[];

package/dist/types/modules/markdown/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Markdown Types
+ *
+ * Centralized type definitions for the Markdown module.
+ */
+/**
+ * Column alignment in a Markdown table.
+ * Determined by colon placement in the separator row:
+ * - `:---`  = left
+ * - `:---:` = center
+ * - `---:`  = right
+ * - `---`   = none (defaults to left in most renderers)
+ */
+export type MarkdownAlignment = "left" | "center" | "right" | "none";
+/**
+ * Result of parsing a Markdown table.
+ */
+export interface MarkdownParseResult {
+    /** Parsed header row (column names) */
+    headers: string[];
+    /** Parsed data rows (each row is an array of cell values) */
+    rows: string[][];
+    /** Column alignments extracted from the separator row */
+    alignments: MarkdownAlignment[];
+}
+/**
+ * Markdown parsing options.
+ */
+export interface MarkdownParseOptions {
+    /**
+     * Trim whitespace from cell values.
+     * @default true
+     */
+    trim?: boolean;
+    /**
+     * Unescape Markdown escape sequences in cell values (e.g. `\|` -> `|`).
+     * @default true
+     */
+    unescape?: boolean;
+    /**
+     * Skip empty rows in the output.
+     * @default true
+     */
+    skipEmptyRows?: boolean;
+    /**
+     * Maximum number of data rows to parse (excludes header).
+     * Useful for previewing large tables.
+     */
+    maxRows?: number;
+    /**
+     * Convert `<br>`, `<br/>`, `<br />` tags in cell content to newline characters.
+     * Useful for round-tripping multiline cell content through Markdown.
+     * @default false
+     */
+    convertBr?: boolean;
+}
+/**
+ * Column configuration for Markdown formatting.
+ */
+export interface MarkdownColumnConfig {
+    /** Column header text */
+    header: string;
+    /**
+     * Column alignment.
+     * @default "left"
+     */
+    alignment?: MarkdownAlignment;
+    /**
+     * Minimum column width (in characters, excluding padding).
+     * The actual width will be the maximum of this value and the widest cell content.
+     * @default 3 (minimum for separator `---`)
+     */
+    minWidth?: number;
+}
+/**
+ * Markdown formatting options.
+ */
+export interface MarkdownFormatOptions {
+    /**
+     * Column configuration. When provided, overrides auto-detected headers and alignment.
+     * Can be an array of strings (header names) or MarkdownColumnConfig objects.
+     */
+    columns?: (string | MarkdownColumnConfig)[];
+    /**
+     * Default alignment for columns without explicit alignment.
+     * @default "left"
+     */
+    alignment?: MarkdownAlignment;
+    /**
+     * Align columns to equal width by padding cell content with spaces.
+     * When false, disables width-alignment padding but retains the single space
+     * around cell content required by most Markdown renderers (`| value |`).
+     * @default true
+     */
+    padding?: boolean;
+    /**
+     * Include a trailing newline at the end of the output.
+     * @default true
+     */
+    trailingNewline?: boolean;
+    /**
+     * Escape pipe characters (`|`) and backslashes (`\`) in cell content.
+     * @default true
+     */
+    escapeContent?: boolean;
+    /**
+     * Custom value-to-string converter.
+     * Called for each cell value before formatting.
+     * Return value is used as the cell text.
+     */
+    stringify?: (value: unknown) => string;
+}
+/**
+ * Unified Markdown options for Workbook integration.
+ * Combines parse and format options with worksheet-specific settings.
+ */
+export interface MarkdownOptions extends MarkdownParseOptions, MarkdownFormatOptions {
+    /** Name of the worksheet to read from or write to */
+    sheetName?: string;
+    /** ID of the worksheet to read from or write to */
+    sheetId?: number;
+    /** Custom value mapper for parsing (MD string -> cell value) */
+    map?: (value: string, column: number) => unknown;
+    /** Date format string for formatting Date values */
+    dateFormat?: string;
+    /** Use UTC for date formatting */
+    dateUTC?: boolean;
+    /** Include empty rows in output */
+    includeEmptyRows?: boolean;
+}