web-csv-toolbox 0.4.0 → 0.5.1

package/lib/index.d.ts

@@ -1,952 +0,0 @@
-/**
- * FiledDelimiter is a symbol for field delimiter of CSV.
- * @category Constants
- */
-declare const FieldDelimiter: unique symbol;
-/**
- * RecordDelimiter is a symbol for record delimiter of CSV.
- * @category Constants
- */
-declare const RecordDelimiter: unique symbol;
-/**
- * Field is a symbol for field of CSV.
- * @category Constants
- */
-declare const Field: unique symbol;
-
-/**
- * Token is a atomic unit of a CSV file.
- * It can be a field, field delimiter, or record delimiter.
- * @category Types
- *
- * @example
- * ```ts
- * const fieldToken: Token = { type: Field, value: "foo" };
- * const fieldDelimiterToken: Token = { type: FieldDelimiter, value: "," };
- * const recordDelimiterToken: Token = { type: RecordDelimiter, value: "\n" };
- * ```
- */
-interface Token<T extends TokenType = TokenType> {
-  type: T;
-  value: string;
-}
-/**
- * Type of a token for CSV.
- * @category Types
- */
-type TokenType = typeof FieldDelimiter | typeof RecordDelimiter | typeof Field;
-/**
- * CSV Common Options.
- * @category Types
- */
-interface CommonOptions {
-  /**
-   * CSV field delimiter.
-   *
-   * @remarks
-   * If you want to parse TSV, specify `'\t'`.
-   *
-   * This library supports multi-character delimiters.
-   * @default ','
-   */
-  demiliter?: string;
-  /**
-   * CSV field quotation.
-   *
-   * @remarks
-   * This library supports multi-character quotations.
-   *
-   * @default '"'
-   */
-  quotation?: string;
-}
-/**
- * CSV Parsing Options for binary.
- * @category Types
- */
-interface BinaryOptions {
-  /**
-   * If the binary is compressed by a compression algorithm,
-   * the decompressed CSV can be parsed by specifying the algorithm.
-   *
-   * @remarks
-   * Make sure the runtime you are running supports stream decompression.
-   *
-   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream#browser_compatibility | DecompressionStream Compatibility}.
-   */
-  decomposition?: CompressionFormat;
-  /**
-   * You can specify the character encoding of the binary.
-   *
-   * @remarks
-   * {@link !TextDecoderStream} is used internally.
-   *
-   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API/Encodings | Encoding API Compatibility}
-   * for the encoding formats that can be specified.
-   *
-   * @default 'utf-8'
-   */
-  charset?: string;
-  /**
-   * If the binary has a BOM, you can specify whether to ignore it.
-   *
-   * @remarks
-   * If you specify true, the BOM will be ignored.
-   * If you specify false or not specify it, the BOM will be treated as a normal character.
-   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/TextDecoderStream/ignoreBOM | TextDecoderOptions.ignoreBOM} for more information about the BOM.
-   * @default false
-   */
-  ignoreBOM?: boolean;
-  /**
-   * If the binary has a invalid character, you can specify whether to throw an error.
-   *
-   * @remarks
-   * If the property is `true` then a decoder will throw a {@link !TypeError}
-   * if it encounters malformed data while decoding.
-   *
-   * If `false` the decoder will substitute the invalid data
-   * with the replacement character `U+FFFD` (�).
-   *
-   * See {@link https://developer.mozilla.org/en-US/docs/Web/API/TextDecoderStream/fatal | TextDecoderOptions.fatal} for more information.
-   *
-   * @default false
-   */
-  fatal?: boolean;
-}
-/**
- * Record Assembler Options for CSV.
- * @category Types
- *
- * @remarks
- * If you specify `header: ['foo', 'bar']`,
- * the first record will be treated as a normal record.
- *
- * If you don't specify `header`,
- * the first record will be treated as a header.
- */
-interface RecordAssemblerOptions<Header extends ReadonlyArray<string>> {
-  /**
-   * CSV header.
-   *
-   * @remarks
-   * If you specify this option,
-   * the first record will be treated as a normal record.
-   *
-   * If you don't specify this option,
-   * the first record will be treated as a header.
-   *
-   * @default undefined
-   */
-  header?: Header;
-}
-/**
- * Parse options for CSV string.
- * @category Types
- */
-interface ParseOptions<Header extends ReadonlyArray<string>>
-  extends CommonOptions,
-    RecordAssemblerOptions<Header> {}
-/**
- * Parse options for CSV binary.
- * @category Types
- */
-interface ParseBinaryOptions<Header extends ReadonlyArray<string>>
-  extends ParseOptions<Header>,
-    BinaryOptions {}
-/**
- * CSV Record.
- * @category Types
- * @template Header Header of the CSV.
- *
- * @example Header is ["foo", "bar"]
- * ```ts
- * const record: CSVRecord<["foo", "bar"]> = {
- *   foo: "1",
- *   bar: "2",
- * };
- * ```
- */
-type CSVRecord<Header extends ReadonlyArray<string>> = Record<
-  Header[number],
-  string
->;
-/**
- * CSV String.
- *
- * @category Types
- */
-type CSVString = string | ReadableStream<string>;
-/**
- * CSV Binary.
- *
- * @category Types
- */
-type CSVBinary =
-  | ReadableStream<Uint8Array>
-  | Response
-  | ArrayBuffer
-  | Uint8Array;
-/**
- * CSV.
- *
- * @category Types
- */
-type CSV = CSVString | CSVBinary;
-
-/**
- * A transform stream that converts a stream of tokens into a stream of rows.
- *
- * @category Low-level API
- *
- * @example Parse a CSV with headers by data
- * ```ts
- * new ReadableStream({
- *  start(controller) {
- *   controller.enqueue("name,age\r\n");
- *  controller.enqueue("Alice,20\r\n");
- * controller.close();
- * }
- * })
- * .pipeThrough(new LexerTransformer())
- * .pipeTo(new WritableStream({ write(token) { console.log(token); }}));
- * // { type: Field, value: "name" }
- * // { type: FieldDelimiter, value: "," }
- * // { type: Field, value: "age" }
- * // { type: RecordDelimiter, value: "\r\n" }
- * // { type: Field, value: "Alice" }
- * // { type: FieldDelimiter, value: "," }
- * // { type: Field, value: "20" }
- * // { type: RecordDelimiter, value: "\r\n" }
- * ```
- */
-declare class LexerTransformer extends TransformStream<string, Token> {
-  #private;
-  get demiliter(): string;
-  get quotation(): string;
-  constructor({ demiliter, quotation }?: CommonOptions);
-  private extractQuotedString;
-}
-
-/**
- * A transform stream that converts a stream of tokens into a stream of rows.
- * @template Header The type of the header row.
- * @param options The options for the parser.
- *
- * @category Low-level API
- *
- * @example Parse a CSV with headers by data
- *  ```ts
- * new ReadableStream({
- *   start(controller) {
- *     controller.enqueue("name,age\r\n");
- *     controller.enqueue("Alice,20\r\n");
- *     controller.enqueue("Bob,25\r\n");
- *     controller.enqueue("Charlie,30\r\n");
- *     controller.close();
- *   })
- *   .pipeThrough(new LexerTransformer())
- *   .pipeThrough(new RecordAssemblerTransformar())
- *   .pipeTo(new WritableStream({ write(row) { console.log(row); }}));
- * // { name: "Alice", age: "20" }
- * // { name: "Bob", age: "25" }
- * // { name: "Charlie", age: "30" }
- * ```
- *
- * @example Parse a CSV with headers by options
- * ```ts
- * new ReadableStream({
- *   start(controller) {
- *     controller.enqueue("Alice,20\r\n");
- *     controller.enqueue("Bob,25\r\n");
- *     controller.enqueue("Charlie,30\r\n");
- *     controller.close();
- *   }
- * })
- * .pipeThrough(new LexerTransformer())
- * .pipeThrough(new RecordAssemblerTransformar({ header: ["name", "age"] }))
- * .pipeTo(new WritableStream({ write(row) { console.log(row); }}));
- * // { name: "Alice", age: "20" }
- * // { name: "Bob", age: "25" }
- * // { name: "Charlie", age: "30" }
- * ```
- */
-declare class RecordAssemblerTransformar<
-  Header extends ReadonlyArray<string>,
-> extends TransformStream<Token, Record<Header[number], string | undefined>> {
-  #private;
-  constructor(options?: RecordAssemblerOptions<Header>);
-}
-
-/**
- * Parse CSV string to records.
- *
- * @category Middle-level API
- * @param csv CSV string to parse
- * @param options Parsing options. See {@link ParseOptions}.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseString.toArray} function.
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parseString } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * for await (const record of parseString(csv)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-declare function parseString<Header extends ReadonlyArray<string>>(
-  csv: string,
-  options?: ParseOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseString {
-  /**
-   * Parse CSV string to records.
-   *
-   * @returns Array of records
-   *
-   * @example
-   * ```ts
-   * import { parseString } from 'web-csv-toolbox';
-   *
-   * const csv = `name,age
-   * Alice,42
-   * Bob,69`;
-   *
-   * const records = await parseString.toArray(csv);
-   * console.log(records);
-   * // Prints:
-   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    csv: string,
-    options?: ParseOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse a binary from an {@link !Uint8Array}.
- *
- * @category Middle-level API
- *
- * @param bytes CSV bytes to parse.
- * @param options Parsing options
- * @returns Async iterable iterator of records.
- *
- * @example Parsing CSV binary
- *
- * ```ts
- * import { parseUint8Array } from 'web-csv-toolbox';
- *
- * const csv = Uint8Array.from([
- *   // ...
- * ]);
- *
- * for await (const record of parseUint8Array(csv)) {
- *   console.log(record);
- * }
- * ```
- */
-declare function parseUint8Array<Header extends ReadonlyArray<string>>(
-  bytes: Uint8Array,
-  options?: ParseBinaryOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseUint8Array {
-  /**
-   * Parse a binary from an {@link !Uint8Array} to an array of records.
-   *
-   * @param bytes CSV bytes to parse.
-   * @param options Parsing options
-   * @returns Array of records
-   *
-   * @example
-   * ```ts
-   * import { parseUint8Array } from 'web-csv-toolbox';
-   *
-   * const csv = Uint8Array.from([
-   *  // ...
-   * ]);
-   *
-   * const records = await parseUint8Array.toArray(csv);
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    bytes: Uint8Array,
-    options?: ParseBinaryOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse CSV to records.
- * This function is for parsing a binary stream.
- *
- * @category Middle-level API
- * @remarks
- * If you want to parse a string, use {@link parseStringStream}.
- * @param stream CSV string to parse
- * @param options Parsing options.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseUint8ArrayStream.toArray} function.
- *
- * @example Parsing CSV binary
- *
- * ```ts
- * import { parseUint8ArrayStream } from 'web-csv-toolbox';
- *
- * const csv = Uint8Array.from([
- *  // ...
- * ]);
- *
- * const stream = new ReadableStream({
- *   start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   },
- * });
- *
- * for await (const record of parseUint8ArrayStream(csv)) {
- *   console.log(record);
- * }
- * ```
- */
-declare function parseUint8ArrayStream<Header extends ReadonlyArray<string>>(
-  stream: ReadableStream<Uint8Array>,
-  options?: ParseBinaryOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseUint8ArrayStream {
-  /**
-   * Parse CSV binary to array of records,
-   * ideal for smaller data sets.
-   *
-   * @returns Array of records
-   *
-   * @example Parsing CSV binary
-   * ```ts
-   * import { parseUint8ArrayStream } from 'web-csv-toolbox';
-   *
-   * const csv = Uint8Array.from([
-   *   // ...
-   * ]);
-   *
-   * const stream = new ReadableStream({
-   *   start(controller) {
-   *     controller.enqueue(csv);
-   *     controller.close();
-   *   },
-   * });
-   *
-   * const records = await parseUint8ArrayStream.toArray(stream);
-   * console.log(records);
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    stream: ReadableStream<Uint8Array>,
-    options?: ParseBinaryOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse a binary from an {@link !ArrayBuffer}.
- *
- * @category Middle-level API
-
- * @param buffer CSV ArrayBuffer to parse.
- * @param options Parsing options
- * @returns Async iterable iterator of records.
- *
- * @example Parsing CSV files from ArrayBuffers
- *
- * ```ts
- * import { parseArrayBuffer } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const buffer = new TextEncoder().encode(csv).buffer;
- *
- * for await (const record of parseArrayBuffer(buffer)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-declare function parseArrayBuffer<Header extends ReadonlyArray<string>>(
-  buffer: ArrayBuffer,
-  options?: ParseBinaryOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseArrayBuffer {
-  /**
-   * Parse a binary from an {@link !ArrayBuffer} to an array of records.
-   * @param buffer CSV ArrayBuffer to parse.
-   * @param options Parsing options
-   * @returns Array of records
-   * @example
-   * ```ts
-   * import { parseArrayBuffer } from 'web-csv-toolbox';
-   *
-   * const csv = `name,age
-   * Alice,42
-   * Bob,69`;
-   *
-   * const buffer = new TextEncoder().encode(csv).buffer;
-   *
-   * const records = await parseArrayBuffer.toArray(buffer);
-   * console.log(records);
-   * // Prints:
-   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    buffer: ArrayBuffer,
-    options?: ParseBinaryOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse CSV string stream to records.
- *
- * @category Middle-level API
- * @param stream CSV string stream to parse
- * @param options Parsing options.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseStringStream.toArray} function.
- *
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parseStringStream } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const stream = new ReadableStream({
- *  start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   },
- * });
- *
- * for await (const record of parseStringStream(csv)) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-declare function parseStringStream<Header extends ReadonlyArray<string>>(
-  stream: ReadableStream<string>,
-  options?: ParseOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseStringStream {
-  /**
-   * Parse CSV string stream to records.
-   *
-   * @returns Array of records
-   *
-   * @example
-   *
-   * ```ts
-   * import { parseStringStream } from 'web-csv-toolbox';
-   *
-   * const csv = `name,age
-   * Alice,42
-   * Bob,69`;
-   *
-   * const stream = new ReadableStream({
-   *   start(controller) {
-   *     controller.enqueue(csv);
-   *     controller.close();
-   *   },
-   * });
-   *
-   * const records = await parseStringStream.toArray(stream);
-   * console.log(records);
-   * // Prints:
-   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    stream: ReadableStream<string>,
-    options?: ParseOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse HTTP Response what contains CSV to records,
- * ideal for smaller data sets.
- *
- * @remarks
- * This function automatically treats response headers.
- *
- * - If `Content-Type` header is not set, it assumes `text/csv`.
- * - If `Content-Type` header is not `text/csv`, it throws an error.
- * - If `Content-Type` header has charset parameter, it uses it for decoding.
- * - If `Content-Encoding` header is set, it decompresses the response.
- * - Should there be any conflicting information between the header and the options, the option's value will take precedence.
- *
- * @category Middle-level API
- * @param response
- * @param options
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseResponse.toArray} function.
- *
- * @example Parsing CSV Response
- *
- * ```ts
- * import { parseResponse } from 'web-csv-toolbox';
- *
- * const response = await fetch('https://example.com/data.csv');
- *
- * for await (const record of parseResponse(response)) {
- *   console.log(record);
- * }
- * ```
- */
-declare function parseResponse<Header extends ReadonlyArray<string>>(
-  response: Response,
-  options?: ParseOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseResponse {
-  /**
-   * Parse CSV Response to array of records.
-   *
-   * @returns Array of records
-   *
-   * @example Parsing CSV Response
-   *
-   * ```ts
-   * import { parseResponse } from 'web-csv-toolbox';
-   *
-   * const response = await fetch('https://example.com/data.csv');
-   *
-   * const records = await parseResponse.toArray(response);
-   * console.log(records);
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    response: Response,
-    options?: ParseOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse CSV Stream to records,
- * ideal for smaller data sets.
- *
- * {@link !ReadableStream} of {@link !String} and {@link !Uint8Array} are supported.
- *
- * @remarks
- * {@link parseStringStream} and {@link parseUint8ArrayStream} are used internally.
- * If you known the type of the stream, it performs better to use them directly.
- *
- * If you want to parse a string, use {@link parseStringStream}.
- * If you want to parse a Uint8Array, use {@link parseUint8ArrayStream}.
- *
- * @category Middle-level API
- * @param csv CSV string to parse
- * @param options Parsing options. See {@link ParseOptions}.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parseStream.toArray} function.
- *
- * @example Parsing CSV string stream
- *
- * ```ts
- *
- * import { parseStream } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const stream = new ReadableStream({
- *  start(controller) {
- *    controller.enqueue(csv);
- *   controller.close();
- * },
- * });
- *
- * for await (const record of parseStream(stream)) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- * @example Parsing CSV binary stream
- *
- * ```ts
- * import { parseStream } from 'web-csv-toolbox';
- *
- * const csv = Uint8Array.from([
- *   // ...
- * ]);
- *
- * const stream = new ReadableStream({
- *   start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   },
- * });
- *
- * for await (const record of parseStream(stream)) {
- *   console.log(record);
- * }
- * ```
- */
-declare function parseStream<Header extends ReadonlyArray<string>>(
-  stream: ReadableStream<Uint8Array | string>,
-  options?: ParseBinaryOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parseStream {
-  /**
-   * Parse CSV Stream to array of records.
-   *
-   * @returns Array of records
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    stream: ReadableStream<Uint8Array>,
-    options?: ParseBinaryOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-/**
- * Parse CSV to records.
- *
- * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.
- *
- *
- * @typeParam Header Header type like `['name', 'age']`.
- *
- * @param csv CSV string to parse.
- * @param options Parsing options for CSV string parsing.
- * @returns Async iterable iterator of records.
- *
- * If you want array of records, use {@link parse.toArray} function.
- * @category High-level API
- *
- * @remarks
- * {@link parseString}, {@link parseUint8ArrayStream},
- * {@link parseArrayBuffer}, {@link parseUint8Array},
- * {@link parseStringStream} and {@link parseResponse} are used internally.
- *
- * If you known the type of the CSV, it performs better to use them directly.
- *
- * | If you want to parse a...           | Use...                        | Data are treated as... |
- * | ----------------------------------- | ----------------------------- | ---------------------- |
- * | {@link !String}                     | {@link parseString}           | String                 |
- * | {@link !ReadableStream}<string>     | {@link parseStringStream}     | String                 |
- * | {@link !ReadableStream}<Uint8Array> | {@link parseUint8ArrayStream} | Binary                 |
- * | {@link !Response}                   | {@link parseResponse}         | Binary                 |
- * | {@link !ArrayBuffer}                | {@link parseArrayBuffer}      | Binary                 |
- * | {@link !Uint8Array}                 | {@link parseUint8Array}       | Binary                 |
- *
- * @example Parsing CSV files from strings
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * for await (const record of parse(csv)) {
- *   console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- * @example Parsing CSV files from streams
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name,age
- * Alice,42
- * Bob,69`;
- *
- * const stream = new ReadableStream({
- *   start(controller) {
- *     controller.enqueue(csv);
- *     controller.close();
- *   }
- * });
- *
- * for await (const record of parse(stream)) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- *
- * @example Parsing CSV files with headers
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV has no header.
- * const csv = `Alice,42
- * Bob,69`;
- *
- * for await (const record of parse(csv, { header: ['name', 'age'] })) {
- *  console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- *
- * @example Parsing CSV files with different delimiters characters
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * const csv = `name\tage
- * Alice\t42
- * Bob\t69`;
- *
- * for await (const record of parse(csv, { delimiter: '\t' })) {
- * console.log(record);
- * }
- * // Prints:
- * // { name: 'Alice', age: '42' }
- * // { name: 'Bob', age: '69' }
- * ```
- */
-declare function parse<Header extends ReadonlyArray<string>>(
-  csv: CSVString,
-  options?: ParseOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-/**
- * Parse CSV binary to records.
- *
- * @param csv CSV binary to parse.
- * @param options Parsing options for CSV binary parsing.
- *
- * @example Parsing CSV files from responses
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV data is not gzipped and encoded in utf-8.
- * const response = await fetch('https://example.com/data.csv');
- *
- * for await (const record of parse(response)) {
- *   // ...
- * }
- * ```
- *
- * @example Parsing CSV files with options spcialized for binary
- *
- * ```ts
- * import { parse } from 'web-csv-toolbox';
- *
- * // This CSV data is gzipped and encoded in shift-jis and has BOM.
- * const response = await fetch('https://example.com/data.csv.gz');
- *
- * for await (const record of parse(response, {
- *   charset: 'shift-jis',
- *   ignoreBOM: true,
- *   decomposition: 'gzip',
- * })) {
- *   // ...
- * }
- * ```
- */
-declare function parse<Header extends ReadonlyArray<string>>(
-  csv: CSVBinary,
-  options?: ParseBinaryOptions<Header>,
-): AsyncIterableIterator<CSVRecord<Header>>;
-declare namespace parse {
-  /**
-   * Parse CSV string to array of records,
-   * ideal for smaller data sets.
-   *
-   * @example Parse a CSV as array of records
-   *
-   * ```ts
-   * import { parse } from 'web-csv-toolbox';
-   *
-   * const csv = `name,age
-   * Alice,42
-   * Bob,69`;
-   *
-   * const records = await parse.toArray(csv);
-   * console.log(records);
-   * // Prints:
-   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    csv: CSVString,
-    options?: ParseOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-  /**
-   * Parse CSV string to array of records,
-   * ideal for smaller data sets.
-   *
-   * @example Parse a CSV as array of records
-   *
-   * ```ts
-   * import { parse } from 'web-csv-toolbox';
-   *
-   * const response = await fetch('https://example.com/data.csv');
-   *
-   * const records = await parse.toArray(response);
-   * console.log(records);
-   * ```
-   */
-  function toArray<Header extends ReadonlyArray<string>>(
-    csv: CSVBinary,
-    options?: ParseBinaryOptions<Header>,
-  ): Promise<CSVRecord<Header>[]>;
-}
-
-export {
-  type BinaryOptions,
-  type CSV,
-  type CSVBinary,
-  type CSVRecord,
-  type CSVString,
-  type CommonOptions,
-  Field,
-  FieldDelimiter,
-  LexerTransformer,
-  type ParseBinaryOptions,
-  type ParseOptions,
-  type RecordAssemblerOptions,
-  RecordAssemblerTransformar,
-  RecordDelimiter,
-  type Token,
-  type TokenType,
-  parse,
-  parseArrayBuffer,
-  parseResponse,
-  parseStream,
-  parseString,
-  parseStringStream,
-  parseUint8Array,
-  parseUint8ArrayStream,
-};