web-csv-toolbox 0.5.3 → 0.6.0

package/dist/web-csv-toolbox.d.ts

@@ -1,982 +0,0 @@
-/**
- * CSV Parsing Options for binary.
- * @category Types
- */
-export declare 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;
-}
-
-/**
- * CSV Common Options.
- * @category Types
- */
-export declare interface CommonOptions {
-    /**
-     * CSV field delimiter.
-     *
-     * @remarks
-     * If you want to parse TSV, specify `'\t'`.
-     *
-     * This library supports multi-character delimiters.
-     * @default ','
-     */
-    delimiter?: string;
-    /**
-     * CSV field quotation.
-     *
-     * @remarks
-     * This library supports multi-character quotations.
-     *
-     * @default '"'
-     */
-    quotation?: string;
-}
-
-/**
- * CSV.
- *
- * @category Types
- */
-export declare type CSV = CSVString | CSVBinary;
-
-/**
- * CSV Binary.
- *
- * @category Types
- */
-export declare type CSVBinary = ReadableStream<Uint8Array> | Response | ArrayBuffer | Uint8Array;
-
-/**
- * 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",
- * };
- * ```
- */
-export declare type CSVRecord<Header extends ReadonlyArray<string>> = Record<Header[number], string>;
-
-/**
- * CSV String.
- *
- * @category Types
- */
-export declare type CSVString = string | ReadableStream<string>;
-
-/**
- * Field is a symbol for field of CSV.
- * @category Constants
- */
-export declare const Field: unique symbol;
-
-/**
- * FiledDelimiter is a symbol for field delimiter of CSV.
- * @category Constants
- */
-export declare const FieldDelimiter: unique symbol;
-
-/**
- * Field delimiter token type.
- * @category Types
- */
-export declare interface FieldDelimiterToken {
-    type: typeof FieldDelimiter;
-}
-
-/**
- * Field token type.
- * @category Types
- */
-export declare interface FieldToken {
-    type: typeof Field;
-    value: string;
-}
-
-/**
- * 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(tokens) {
- *     for (const token of tokens) {
- *       console.log(token);
- *     }
- *   }}));
- * // { type: Field, value: "name" }
- * // FieldDelimiter
- * // { type: Field, value: "age" }
- * // RecordDelimiter
- * // { type: Field, value: "Alice" }
- * // FieldDelimiter
- * // { type: Field, value: "20" }
- * // RecordDelimiter
- * ```
- */
-export declare class LexerTransformer extends TransformStream<string, Token[]> {
-    constructor(options?: CommonOptions);
-}
-
-/**
- * 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 parseBinary}, {@link parseUint8ArrayStream},
- * {@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...                        | Options...                 |
- * | -------------------------------------------- | ----------------------------- | -------------------------- |
- * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |
- * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |
- * | {@link !Uint8Array} \| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |
- * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |
- * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |
- *
- * @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' }
- * ```
- */
-export 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',
- * })) {
- *   // ...
- * }
- * ```
- */
-export declare function parse<Header extends ReadonlyArray<string>>(csv: CSVBinary, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export 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' } ]
-     * ```
-     */
-    export 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);
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(csv: CSVBinary, options?: ParseBinaryOptions<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);
- * }
- * ```
- */
-export declare function parseBinary<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export declare namespace parseBinary {
-    /**
-     * 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);
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * 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 = parseUint8Array.toArraySync(csv);
-     * ```
-     */
-    export function toArraySync<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): CSVRecord<Header>[];
-    /**
-     * Parse a binary from an {@link !Uint8Array} to an iterable iterator of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Async iterable iterator of records.
-     * @example
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * for (const record of parseUint8Array.toIterableIterator(csv)) {
-     *   console.log(record);
-     * }
-     * ```
-     */
-    export function toIterableIterator<Header extends ReadonlyArray<string>>(bytes: Uint8Array, options?: ParseBinaryOptions<Header>): IterableIterator<CSVRecord<Header>>;
-    /**
-     * Parse a binary from an {@link !Uint8Array} to a stream of records.
-     *
-     * @param bytes CSV bytes to parse.
-     * @param options Parsing options
-     * @returns Stream of records.
-     *
-     * @example
-     *
-     * ```ts
-     * import { parseUint8Array } from 'web-csv-toolbox';
-     *
-     * const csv = Uint8Array.from([
-     *  // ...
-     * ]);
-     *
-     * const stream = parseUint8Array.toStream(csv);
-     *
-     * await stream.pipeTo(
-     *   new WritableStream({
-     *     write(record) {
-     *       console.log(record);
-     *     },
-     *   }),
-     * );
-     * ```
-     */
-    export function toStream<Header extends ReadonlyArray<string>>(bytes: Uint8Array, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
-}
-
-/**
- * Parse options for CSV binary.
- * @category Types
- */
-export declare interface ParseBinaryOptions<Header extends ReadonlyArray<string>> extends ParseOptions<Header>, BinaryOptions {
-}
-
-/**
- * Parse options for CSV string.
- * @category Types
- */
-export declare interface ParseOptions<Header extends ReadonlyArray<string>> extends CommonOptions, RecordAssemblerOptions<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);
- * }
- * ```
- */
-export declare function parseResponse<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export 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);
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV Response to stream of records.
-     *
-     * @param response Response to parse
-     * @returns Stream of records
-     *
-     * @example Parsing CSV Response
-     *
-     * ```ts
-     * import { parseResponse } from 'web-csv-toolbox';
-     *
-     * const response = await fetch('https://example.com/data.csv');
-     *
-     * await parseResponse.toStream(response)
-     *   .pipeTo(
-     *     new WritableStream({
-     *       write(record) {
-     *         console.log(record);
-     *       },
-     *    }),
-     * );
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    export function toStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): ReadableStream<CSVRecord<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' }
- * ```
- */
-export declare function parseString<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export 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' } ]
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * 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 = parseString.toArraySync(csv);
-     * console.log(records);
-     * // Prints:
-     * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]
-     * ```
-     */
-    export function toArraySync<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): CSVRecord<Header>[];
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Async iterable iterator of records
-     *
-     * @example
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * for (const record of parseString.toIterableIterator(csv)) {
-     *   console.log(record);
-     * }
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    export function toIterableIterator<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): IterableIterator<CSVRecord<Header>>;
-    /**
-     * Parse CSV string to records.
-     *
-     * @returns Readable stream of records
-     *
-     * @example
-     * ```ts
-     * import { parseString } from 'web-csv-toolbox';
-     *
-     * const csv = `name,age
-     * Alice,42
-     * Bob,69`;
-     *
-     * await parseString.toStream(csv)
-     *   .pipeTo(
-     *      new WritableStream({
-     *        write(record) {
-     *          console.log(record);
-     *        },
-     *      }),
-     *   );
-     * // Prints:
-     * // { name: 'Alice', age: '42' }
-     * // { name: 'Bob', age: '69' }
-     * ```
-     */
-    export function toStream<Header extends ReadonlyArray<string>>(csv: string, options?: ParseOptions<Header>): ReadableStream<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' }
- * ```
- */
-export declare function parseStringStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export 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' } ]
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * 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();
-     *   },
-     * });
-     *
-     * await parseStringStream.toStream(stream)
-     *   .pipeTo(
-     *     new WritableStream({
-     *       write(record) {
-     *       console.log(record);
-     *     },
-     *   }),
-     * );
-     * ```
-     */
-    export function toStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<string>, options?: ParseOptions<Header>): ReadableStream<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);
- * }
- * ```
- */
-export declare function parseUint8ArrayStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<Uint8Array>, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
-
-export 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);
-     * ```
-     */
-    export function toArray<Header extends ReadonlyArray<string>>(stream: ReadableStream<Uint8Array>, options?: ParseBinaryOptions<Header>): Promise<CSVRecord<Header>[]>;
-    /**
-     * Parse CSV binary to array of records.
-     *
-     * @returns Stream 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();
-     * },
-     * });
-     *
-     * await parseUint8ArrayStream.toStream(stream)
-     *   .pipeTo(new WritableStream({
-     *     write(record) {
-     *       console.log(record);
-     *     },
-     *   }),
-     * );
-     * ```
-     */
-    export function toStream<Header extends ReadonlyArray<string>>(stream: ReadableStream<Uint8Array>, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>[]>;
-}
-
-/**
- * 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.
- */
-export declare 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;
-}
-
-/**
- * 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 RecordAssemblerTransformer())
- *   .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 RecordAssemblerTransformer({ header: ["name", "age"] }))
- * .pipeTo(new WritableStream({ write(row) { console.log(row); }}));
- * // { name: "Alice", age: "20" }
- * // { name: "Bob", age: "25" }
- * // { name: "Charlie", age: "30" }
- * ```
- */
-export declare class RecordAssemblerTransformer<Header extends ReadonlyArray<string>> extends TransformStream<Token[], CSVRecord<Header>> {
-    constructor(options?: RecordAssemblerOptions<Header>);
-}
-
-/**
- * RecordDelimiter is a symbol for record delimiter of CSV.
- * @category Constants
- */
-export declare const RecordDelimiter: unique symbol;
-
-/**
- * Record delimiter token type.
- */
-export declare interface RecordDelimiterToken {
-    type: typeof RecordDelimiter;
-}
-
-/**
- * Token is a atomic unit of a CSV file.
- * It can be a field, field delimiter, or record delimiter.
- * @category Types
- */
-export declare type Token = FieldToken | typeof FieldDelimiter | typeof RecordDelimiter;
-
-export { }