web-csv-toolbox 0.7.3 → 0.7.5

package/dist/cjs/parse.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parse.cjs","sources":["../../src/parse.ts"],"sourcesContent":["import {\n  CSV,\n  CSVBinary,\n  CSVRecord,\n  CSVString,\n  ParseBinaryOptions,\n  ParseOptions,\n} from \"./common/types.ts\";\nimport { parseBinary } from \"./parseBinary.ts\";\nimport { parseResponse } from \"./parseResponse.ts\";\nimport { parseString } from \"./parseString.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV to records.\n *\n * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.\n *\n *\n * @typeParam Header Header type like `['name', 'age']`.\n *\n * @param csv CSV string to parse.\n * @param options Parsing options for CSV string parsing.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parse.toArray} function.\n * @category High-level API\n *\n * @remarks\n * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},\n * {@link parseStringStream} and {@link parseResponse} are used internally.\n *\n * If you known the type of the CSV, it performs better to use them directly.\n *\n * | If you want to parse a...                    | Use...                        | Options...                 |\n * | -------------------------------------------- | ----------------------------- | -------------------------- |\n * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |\n * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |\n * | {@link !Uint8Array} \\| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |\n * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |\n * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files from streams\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   }\n * });\n *\n * for await (const record of parse(stream)) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n *\n * @example Parsing CSV files with headers\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV has no header.\n * const csv = `Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv, { header: ['name', 'age'] })) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files with different delimiters characters\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name\\tage\n * Alice\\t42\n * Bob\\t69`;\n *\n * for await (const record of parse(csv, { delimiter: '\\t' })) {\n * console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parse<Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\n/**\n * Parse CSV binary to records.\n *\n * @param csv CSV binary to parse.\n * @param options Parsing options for CSV binary parsing.\n *\n * @example Parsing CSV files from responses\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is not gzipped and encoded in utf-8.\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parse(response)) {\n *   // ...\n * }\n * ```\n *\n * @example Parsing CSV files with options spcialized for binary\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is gzipped and encoded in shift-jis and has BOM.\n * const response = await fetch('https://example.com/data.csv.gz');\n *\n * for await (const record of parse(response, {\n *   charset: 'shift-jis',\n *   ignoreBOM: true,\n *   decomposition: 'gzip',\n * })) {\n *   // ...\n * }\n * ```\n */\nexport function parse<Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<Header extends ReadonlyArray<string>>(\n  csv: CSV,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  if (typeof csv === \"string\") {\n    yield* parseString(csv, options);\n  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {\n    yield* parseBinary(csv, options);\n  } else if (csv instanceof ReadableStream) {\n    const [branch1, branch2] = csv.tee();\n    const reader1 = branch1.getReader();\n    const { value: firstChunk } = await reader1.read();\n    reader1.releaseLock();\n    if (typeof firstChunk === \"string\") {\n      yield* parseStringStream(branch2 as ReadableStream<string>, options);\n    } else if (firstChunk instanceof Uint8Array) {\n      yield* parseUint8ArrayStream(\n        branch2 as ReadableStream<Uint8Array>,\n        options,\n      );\n    }\n  } else if (csv instanceof Response) {\n    yield* parseResponse(csv, options);\n  }\n}\n\nexport declare namespace parse {\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parse.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVString,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVBinary,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n});\n"],"names":["async","parse","csv","options","parseString","Uint8Array","ArrayBuffer","parseBinary","ReadableStream","branch1","branch2","tee","reader1","getReader","value","firstChunk","read","releaseLock","parseStringStream","parseUint8ArrayStream","Response","parseResponse","Object","defineProperties","toArray","enumerable","writable","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray"],"mappings":"oUAoKuBA,eAAAC,EACrBC,EACAC,GAEI,GAAe,iBAARD,QACFE,EAAAA,YAAYF,EAAKC,QACf,GAAAD,aAAeG,YAAcH,aAAeI,kBAC9CC,EAAAA,YAAYL,EAAKC,QAC1B,GAAWD,aAAeM,eAAgB,CACxC,MAAOC,EAASC,GAAWR,EAAIS,MACzBC,EAAUH,EAAQI,aAChBC,MAAOC,SAAqBH,EAAQI,OAC5CJ,EAAQK,cACkB,iBAAfF,QACFG,EAAAA,kBAAkBR,EAAmCP,GACnDY,aAAsBV,mBACxBc,EAAAA,sBACLT,EACAP,GAEJ,MACSD,aAAekB,iBACjBC,EAAAA,cAAcnB,EAAKC,GAE9B,CA+CAmB,OAAOC,iBAAiBtB,EAAO,CAC7BuB,QAAS,CACPC,YAAY,EACZC,UAAU,EACVZ,MAAOa,EAASC"}
+{"version":3,"file":"parse.cjs","sources":["../../src/parse.ts"],"sourcesContent":["import type {\n  CSV,\n  CSVBinary,\n  CSVRecord,\n  CSVString,\n  ParseBinaryOptions,\n  ParseOptions,\n} from \"./common/types.ts\";\nimport { parseBinary } from \"./parseBinary.ts\";\nimport { parseResponse } from \"./parseResponse.ts\";\nimport { parseString } from \"./parseString.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV to records.\n *\n * {@link !String}, {@link !ReadableStream}<string | {@link !Uint8Array}> and {@link !Response} are supported.\n *\n *\n * @typeParam Header Header type like `['name', 'age']`.\n *\n * @param csv CSV string to parse.\n * @param options Parsing options for CSV string parsing.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parse.toArray} function.\n * @category High-level API\n *\n * @remarks\n * {@link parseString}, {@link parseBinary}, {@link parseUint8ArrayStream},\n * {@link parseStringStream} and {@link parseResponse} are used internally.\n *\n * If you known the type of the CSV, it performs better to use them directly.\n *\n * | If you want to parse a...                    | Use...                        | Options...                 |\n * | -------------------------------------------- | ----------------------------- | -------------------------- |\n * | {@link !String}                              | {@link parseString}           | {@link ParseOptions}       |\n * | {@link !ReadableStream}<{@link !String}>     | {@link parseStringStream}     | {@link ParseOptions}       |\n * | {@link !Uint8Array} \\| {@link !ArrayBuffer}  | {@link parseBinary}           | {@link ParseBinaryOptions} |\n * | {@link !ReadableStream}<{@link !Uint8Array}> | {@link parseUint8ArrayStream} | {@link ParseBinaryOptions} |\n * | {@link !Response}                            | {@link parseResponse}         | {@link ParseBinaryOptions} |\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files from streams\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   }\n * });\n *\n * for await (const record of parse(stream)) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n *\n * @example Parsing CSV files with headers\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV has no header.\n * const csv = `Alice,42\n * Bob,69`;\n *\n * for await (const record of parse(csv, { header: ['name', 'age'] })) {\n *  console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n *\n * @example Parsing CSV files with different delimiters characters\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * const csv = `name\\tage\n * Alice\\t42\n * Bob\\t69`;\n *\n * for await (const record of parse(csv, { delimiter: '\\t' })) {\n * console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parse<Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\n/**\n * Parse CSV binary to records.\n *\n * @param csv CSV binary to parse.\n * @param options Parsing options for CSV binary parsing.\n *\n * @example Parsing CSV files from responses\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is not gzipped and encoded in utf-8.\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parse(response)) {\n *   // ...\n * }\n * ```\n *\n * @example Parsing CSV files with options spcialized for binary\n *\n * ```ts\n * import { parse } from 'web-csv-toolbox';\n *\n * // This CSV data is gzipped and encoded in shift-jis and has BOM.\n * const response = await fetch('https://example.com/data.csv.gz');\n *\n * for await (const record of parse(response, {\n *   charset: 'shift-jis',\n *   ignoreBOM: true,\n *   decomposition: 'gzip',\n * })) {\n *   // ...\n * }\n * ```\n */\nexport function parse<Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<Header extends ReadonlyArray<string>>(\n  csv: CSV,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  if (typeof csv === \"string\") {\n    yield* parseString(csv, options);\n  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {\n    yield* parseBinary(csv, options);\n  } else if (csv instanceof ReadableStream) {\n    const [branch1, branch2] = csv.tee();\n    const reader1 = branch1.getReader();\n    const { value: firstChunk } = await reader1.read();\n    reader1.releaseLock();\n    if (typeof firstChunk === \"string\") {\n      yield* parseStringStream(branch2 as ReadableStream<string>, options);\n    } else if (firstChunk instanceof Uint8Array) {\n      yield* parseUint8ArrayStream(\n        branch2 as ReadableStream<Uint8Array>,\n        options,\n      );\n    }\n  } else if (csv instanceof Response) {\n    yield* parseResponse(csv, options);\n  }\n}\n\nexport declare namespace parse {\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parse.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVString,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @example Parse a CSV as array of records\n   *\n   * ```ts\n   * import { parse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: CSVBinary,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n});\n"],"names":["async","parse","csv","options","parseString","Uint8Array","ArrayBuffer","parseBinary","ReadableStream","branch1","branch2","tee","reader1","getReader","value","firstChunk","read","releaseLock","parseStringStream","parseUint8ArrayStream","Response","parseResponse","Object","defineProperties","toArray","enumerable","writable","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray"],"mappings":"oUAoKuBA,eAAAC,EACrBC,EACAC,GAEI,GAAe,iBAARD,QACFE,EAAAA,YAAYF,EAAKC,QACf,GAAAD,aAAeG,YAAcH,aAAeI,kBAC9CC,EAAAA,YAAYL,EAAKC,QAC1B,GAAWD,aAAeM,eAAgB,CACxC,MAAOC,EAASC,GAAWR,EAAIS,MACzBC,EAAUH,EAAQI,aAChBC,MAAOC,SAAqBH,EAAQI,OAC5CJ,EAAQK,cACkB,iBAAfF,QACFG,EAAAA,kBAAkBR,EAAmCP,GACnDY,aAAsBV,mBACxBc,EAAAA,sBACLT,EACAP,GAEJ,MACSD,aAAekB,iBACjBC,EAAAA,cAAcnB,EAAKC,GAE9B,CA+CAmB,OAAOC,iBAAiBtB,EAAO,CAC7BuB,QAAS,CACPC,YAAY,EACZC,UAAU,EACVZ,MAAOa,EAASC"}

package/dist/cjs/parseBinary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinary.cjs","sources":["../../src/parseBinary.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseBinaryToArraySync } from \"./parseBinaryToArraySync.ts\";\nimport { parseBinaryToIterableIterator } from \"./parseBinaryToIterableIterator.ts\";\nimport { parseBinaryToStream } from \"./parseBinaryToStream.ts\";\nimport { convertIterableIteratorToAsync } from \"./utils/convertIterableIteratorToAsync.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse a binary from an {@link !Uint8Array}.\n *\n * @category Middle-level API\n *\n * @param bytes CSV bytes to parse.\n * @param options Parsing options\n * @returns Async iterable iterator of records.\n *\n * @example Parsing CSV binary\n *\n * ```ts\n * import { parseUint8Array } from 'web-csv-toolbox';\n *\n * const csv = Uint8Array.from([\n *   // ...\n * ]);\n *\n * for await (const record of parseUint8Array(csv)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseBinary<Header extends ReadonlyArray<string>>(\n  bytes: Uint8Array | ArrayBuffer,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const iterator = parseBinaryToIterableIterator(bytes, options);\n  return convertIterableIteratorToAsync(iterator);\n}\n\nexport declare namespace parseBinary {\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an array of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const records = await parseUint8Array.toArray(csv);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array | ArrayBuffer,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an array of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Array of records\n   * @example\n   *\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const records = parseUint8Array.toArraySync(csv);\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array | ArrayBuffer,\n    options?: ParseBinaryOptions<Header>,\n  ): CSVRecord<Header>[];\n\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an iterable iterator of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Async iterable iterator of records.\n   * @example\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * for (const record of parseUint8Array.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array,\n    options?: ParseBinaryOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n\n  /**\n   * Parse a binary from an {@link !Uint8Array} to a stream of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Stream of records.\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const stream = parseUint8Array.toStream(csv);\n   *\n   * await stream.pipeTo(\n   *   new WritableStream({\n   *     write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseBinary, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToStream,\n  },\n});\n"],"names":["parseBinary","bytes","options","iterator","parseBinaryToIterableIterator","convertIterableIteratorToAsync","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toArraySync","parseBinaryToArraySync","toIterableIterator","toStream","parseBinaryToStream"],"mappings":"iVA8BgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAWC,EAAAA,8BAA8BH,EAAOC,GACtD,OAAOG,EAAAA,+BAA+BF,EACxC,CAyGAG,OAAOC,iBAAiBP,EAAa,CACnCQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,YAAa,CACXL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA,wBAETC,mBAAoB,CAClBP,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA,+BAETa,SAAU,CACRR,YAAY,EACZC,UAAU,EACVC,MAAOO,EAAAA"}
+{"version":3,"file":"parseBinary.cjs","sources":["../../src/parseBinary.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseBinaryToArraySync } from \"./parseBinaryToArraySync.ts\";\nimport { parseBinaryToIterableIterator } from \"./parseBinaryToIterableIterator.ts\";\nimport { parseBinaryToStream } from \"./parseBinaryToStream.ts\";\nimport { convertIterableIteratorToAsync } from \"./utils/convertIterableIteratorToAsync.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse a binary from an {@link !Uint8Array}.\n *\n * @category Middle-level API\n *\n * @param bytes CSV bytes to parse.\n * @param options Parsing options\n * @returns Async iterable iterator of records.\n *\n * @example Parsing CSV binary\n *\n * ```ts\n * import { parseUint8Array } from 'web-csv-toolbox';\n *\n * const csv = Uint8Array.from([\n *   // ...\n * ]);\n *\n * for await (const record of parseUint8Array(csv)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseBinary<Header extends ReadonlyArray<string>>(\n  bytes: Uint8Array | ArrayBuffer,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const iterator = parseBinaryToIterableIterator(bytes, options);\n  return convertIterableIteratorToAsync(iterator);\n}\n\nexport declare namespace parseBinary {\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an array of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const records = await parseUint8Array.toArray(csv);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array | ArrayBuffer,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an array of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Array of records\n   * @example\n   *\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const records = parseUint8Array.toArraySync(csv);\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array | ArrayBuffer,\n    options?: ParseBinaryOptions<Header>,\n  ): CSVRecord<Header>[];\n\n  /**\n   * Parse a binary from an {@link !Uint8Array} to an iterable iterator of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Async iterable iterator of records.\n   * @example\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * for (const record of parseUint8Array.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array,\n    options?: ParseBinaryOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n\n  /**\n   * Parse a binary from an {@link !Uint8Array} to a stream of records.\n   *\n   * @param bytes CSV bytes to parse.\n   * @param options Parsing options\n   * @returns Stream of records.\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseUint8Array } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const stream = parseUint8Array.toStream(csv);\n   *\n   * await stream.pipeTo(\n   *   new WritableStream({\n   *     write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    bytes: Uint8Array,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseBinary, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseBinaryToStream,\n  },\n});\n"],"names":["parseBinary","bytes","options","iterator","parseBinaryToIterableIterator","convertIterableIteratorToAsync","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toArraySync","parseBinaryToArraySync","toIterableIterator","toStream","parseBinaryToStream"],"mappings":"iVA8BgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAWC,EAAAA,8BAA8BH,EAAOC,GACtD,OAAOG,EAAAA,+BAA+BF,EACxC,CAyGAG,OAAOC,iBAAiBP,EAAa,CACnCQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,YAAa,CACXL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA,wBAETC,mBAAoB,CAClBP,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA,+BAETa,SAAU,CACRR,YAAY,EACZC,UAAU,EACVC,MAAOO,EAAAA"}

package/dist/cjs/parseBinaryToArraySync.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToArraySync.cjs","sources":["../../src/parseBinaryToArraySync.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\n\nexport function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): CSVRecord<Header>[] {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToArraySync(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToArraySync"],"mappings":"wMAIO,SACLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,uBAAuBF,EAAKD,EACrC"}
+{"version":3,"file":"parseBinaryToArraySync.cjs","sources":["../../src/parseBinaryToArraySync.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\n\nexport function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): CSVRecord<Header>[] {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToArraySync(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToArraySync"],"mappings":"wMAIO,SACLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,uBAAuBF,EAAKD,EACrC"}

package/dist/cjs/parseBinaryToIterableIterator.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToIterableIterator.cjs","sources":["../../src/parseBinaryToIterableIterator.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\n\nexport function parseBinaryToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): IterableIterator<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToIterableIterator(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToIterableIterator"],"mappings":"sNAIO,SAGLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,8BAA8BF,EAAKD,EAC5C"}
+{"version":3,"file":"parseBinaryToIterableIterator.cjs","sources":["../../src/parseBinaryToIterableIterator.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\n\nexport function parseBinaryToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): IterableIterator<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToIterableIterator(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToIterableIterator"],"mappings":"sNAIO,SAGLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,8BAA8BF,EAAKD,EAC5C"}

package/dist/cjs/parseBinaryToStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToStream.cjs","sources":["../../src/parseBinaryToStream.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\n\nexport function parseBinaryToStream<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): ReadableStream<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToStream(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToStream"],"mappings":"kMAIO,SACLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,oBAAoBF,EAAKD,EAClC"}
+{"version":3,"file":"parseBinaryToStream.cjs","sources":["../../src/parseBinaryToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\n\nexport function parseBinaryToStream<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): ReadableStream<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToStream(csv, options);\n}\n"],"names":["binary","options","csv","convertBinaryToString","parseStringToStream"],"mappings":"kMAIO,SACLA,EACAC,EAAsC,IAEhC,MAAAC,EAAMC,EAAAA,sBAAsBH,EAAQC,GACnC,OAAAG,EAAAA,oBAAoBF,EAAKD,EAClC"}

package/dist/cjs/parseResponse.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponse.cjs","sources":["../../src/parseResponse.ts"],"sourcesContent":["import { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseResponseToStream } from \"./parseResponseToStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse HTTP Response what contains CSV to records,\n * ideal for smaller data sets.\n *\n * @remarks\n * This function automatically treats response headers.\n *\n * - If `Content-Type` header is not set, it assumes `text/csv`.\n * - If `Content-Type` header is not `text/csv`, it throws an error.\n * - If `Content-Type` header has charset parameter, it uses it for decoding.\n * - If `Content-Encoding` header is set, it decompresses the response.\n * - Should there be any conflicting information between the header and the options, the option's value will take precedence.\n *\n * @category Middle-level API\n * @param response\n * @param options\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseResponse.toArray} function.\n *\n * @example Parsing CSV Response\n *\n * ```ts\n * import { parseResponse } from 'web-csv-toolbox';\n *\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parseResponse(response)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseResponse<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStream(response.body, options_);\n}\n\nexport declare namespace parseResponse {\n  /**\n   * Parse CSV Response to array of records.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parseResponse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV Response to stream of records.\n   *\n   * @param response Response to parse\n   * @returns Stream of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * await parseResponse.toStream(response)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *         console.log(record);\n   *       },\n   *    }),\n   * );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parseResponse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStreamSync: {\n    enumerable: true,\n    writable: false,\n    value: parseResponseToStream,\n  },\n});\n"],"names":["parseResponse","response","options","options_","getOptionsFromResponse","body","Error","parseUint8ArrayStream","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStreamSync","parseResponseToStream"],"mappings":"mRAsCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAWC,EAAAA,uBAAuBH,EAAUC,GAC9C,GAAkB,OAAlBD,EAASI,KACL,MAAA,IAAIC,MAAM,yBAEX,OAAAC,wBAAsBN,EAASI,KAAMF,EAC9C,CAuDAK,OAAOC,iBAAiBT,EAAe,CACrCU,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,aAAc,CACZL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA"}
+{"version":3,"file":"parseResponse.cjs","sources":["../../src/parseResponse.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseResponseToStream } from \"./parseResponseToStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse HTTP Response what contains CSV to records,\n * ideal for smaller data sets.\n *\n * @remarks\n * This function automatically treats response headers.\n *\n * - If `Content-Type` header is not set, it assumes `text/csv`.\n * - If `Content-Type` header is not `text/csv`, it throws an error.\n * - If `Content-Type` header has charset parameter, it uses it for decoding.\n * - If `Content-Encoding` header is set, it decompresses the response.\n * - Should there be any conflicting information between the header and the options, the option's value will take precedence.\n *\n * @category Middle-level API\n * @param response\n * @param options\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseResponse.toArray} function.\n *\n * @example Parsing CSV Response\n *\n * ```ts\n * import { parseResponse } from 'web-csv-toolbox';\n *\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parseResponse(response)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseResponse<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStream(response.body, options_);\n}\n\nexport declare namespace parseResponse {\n  /**\n   * Parse CSV Response to array of records.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parseResponse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV Response to stream of records.\n   *\n   * @param response Response to parse\n   * @returns Stream of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * await parseResponse.toStream(response)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *         console.log(record);\n   *       },\n   *    }),\n   * );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parseResponse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStreamSync: {\n    enumerable: true,\n    writable: false,\n    value: parseResponseToStream,\n  },\n});\n"],"names":["parseResponse","response","options","options_","getOptionsFromResponse","body","Error","parseUint8ArrayStream","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStreamSync","parseResponseToStream"],"mappings":"mRAsCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAWC,EAAAA,uBAAuBH,EAAUC,GAC9C,GAAkB,OAAlBD,EAASI,KACL,MAAA,IAAIC,MAAM,yBAEX,OAAAC,wBAAsBN,EAASI,KAAMF,EAC9C,CAuDAK,OAAOC,iBAAiBT,EAAe,CACrCU,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,aAAc,CACZL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA"}

package/dist/cjs/parseResponseToStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponseToStream.cjs","sources":["../../src/parseResponseToStream.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\n\nexport function parseResponseToStream<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStreamToStream(response.body, options_);\n}\n"],"names":["response","options","options_","getOptionsFromResponse","body","Error","parseUint8ArrayStreamToStream"],"mappings":"+MAIgB,SACdA,EACAC,GAEM,MAAAC,EAAWC,EAAAA,uBAAuBH,EAAUC,GAC9C,GAAkB,OAAlBD,EAASI,KACL,MAAA,IAAIC,MAAM,yBAEX,OAAAC,gCAA8BN,EAASI,KAAMF,EACtD"}
+{"version":3,"file":"parseResponseToStream.cjs","sources":["../../src/parseResponseToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\n\nexport function parseResponseToStream<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStreamToStream(response.body, options_);\n}\n"],"names":["response","options","options_","getOptionsFromResponse","body","Error","parseUint8ArrayStreamToStream"],"mappings":"+MAIgB,SACdA,EACAC,GAEM,MAAAC,EAAWC,EAAAA,uBAAuBH,EAAUC,GAC9C,GAAkB,OAAlBD,EAASI,KACL,MAAA,IAAIC,MAAM,yBAEX,OAAAC,gCAA8BN,EAASI,KAAMF,EACtD"}

package/dist/cjs/parseString.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseString.cjs","sources":["../../src/parseString.ts"],"sourcesContent":["import { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string to records.\n *\n * @category Middle-level API\n * @param csv CSV string to parse\n * @param options Parsing options. See {@link ParseOptions}.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseString.toArray} function.\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseString } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parseString(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport async function* parseString<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  yield* parseStringToIterableIterator(csv, options);\n}\nexport declare namespace parseString {\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parseString.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = parseString.toArraySync(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): CSVRecord<Header>[];\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Async iterable iterator of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * for (const record of parseString.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Readable stream of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * await parseString.toStream(csv)\n   *   .pipeTo(\n   *      new WritableStream({\n   *        write(record) {\n   *          console.log(record);\n   *        },\n   *      }),\n   *   );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\nObject.defineProperties(parseString, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToStream,\n  },\n});\n"],"names":["async","parseString","csv","options","parseStringToIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toArraySync","parseStringToArraySync","toIterableIterator","toStream","parseStringToStream"],"mappings":"yRAgCuBA,eAAAC,EACrBC,EACAC,SAEOC,EAAAA,8BAA8BF,EAAKC,EAC5C,CAyGAE,OAAOC,iBAAiBL,EAAa,CACnCM,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,YAAa,CACXL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA,wBAETC,mBAAoB,CAClBP,YAAY,EACZC,UAAU,EACVC,MAAON,EAAAA,+BAETY,SAAU,CACRR,YAAY,EACZC,UAAU,EACVC,MAAOO,EAAAA"}
+{"version":3,"file":"parseString.cjs","sources":["../../src/parseString.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string to records.\n *\n * @category Middle-level API\n * @param csv CSV string to parse\n * @param options Parsing options. See {@link ParseOptions}.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseString.toArray} function.\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseString } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parseString(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport async function* parseString<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  yield* parseStringToIterableIterator(csv, options);\n}\nexport declare namespace parseString {\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parseString.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = parseString.toArraySync(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): CSVRecord<Header>[];\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Async iterable iterator of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * for (const record of parseString.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Readable stream of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * await parseString.toStream(csv)\n   *   .pipeTo(\n   *      new WritableStream({\n   *        write(record) {\n   *          console.log(record);\n   *        },\n   *      }),\n   *   );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\nObject.defineProperties(parseString, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToStream,\n  },\n});\n"],"names":["async","parseString","csv","options","parseStringToIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toArraySync","parseStringToArraySync","toIterableIterator","toStream","parseStringToStream"],"mappings":"yRAgCuBA,eAAAC,EACrBC,EACAC,SAEOC,EAAAA,8BAA8BF,EAAKC,EAC5C,CAyGAE,OAAOC,iBAAiBL,EAAa,CACnCM,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,YAAa,CACXL,YAAY,EACZC,UAAU,EACVC,MAAOI,EAAAA,wBAETC,mBAAoB,CAClBP,YAAY,EACZC,UAAU,EACVC,MAAON,EAAAA,+BAETY,SAAU,CACRR,YAAY,EACZC,UAAU,EACVC,MAAOO,EAAAA"}

package/dist/cjs/parseStringStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringStream.cjs","sources":["../../src/parseStringStream.ts"],"sourcesContent":["import { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { parseStringStreamToStream } from \"./parseStringStreamToStream.ts\";\nimport { convertStreamToAsyncIterableIterator } from \"./utils/convertStreamToAsyncIterableIterator.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string stream to records.\n *\n * @category Middle-level API\n * @param stream CSV string stream to parse\n * @param options Parsing options.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseStringStream.toArray} function.\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseStringStream } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *  start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   },\n * });\n *\n * for await (const record of parseStringStream(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parseStringStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<string>,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const recordStream = parseStringStreamToStream(stream, options);\n  return convertStreamToAsyncIterableIterator(recordStream);\n}\n\nexport declare namespace parseStringStream {\n  /**\n   * Parse CSV string stream to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseStringStream } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * const records = await parseStringStream.toArray(stream);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<string>,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string stream to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseStringStream } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * await parseStringStream.toStream(stream)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<string>,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseStringStream, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringStreamToStream,\n  },\n});\n"],"names":["parseStringStream","stream","options","recordStream","parseStringStreamToStream","convertStreamToAsyncIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStream"],"mappings":"kQAuCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAeC,EAAAA,0BAA0BH,EAAQC,GACvD,OAAOG,EAAAA,qCAAqCF,EAC9C,CAuEAG,OAAOC,iBAAiBP,EAAmB,CACzCQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,SAAU,CACRL,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA"}
+{"version":3,"file":"parseStringStream.cjs","sources":["../../src/parseStringStream.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { parseStringStreamToStream } from \"./parseStringStreamToStream.ts\";\nimport { convertStreamToAsyncIterableIterator } from \"./utils/convertStreamToAsyncIterableIterator.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string stream to records.\n *\n * @category Middle-level API\n * @param stream CSV string stream to parse\n * @param options Parsing options.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseStringStream.toArray} function.\n *\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseStringStream } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * const stream = new ReadableStream({\n *  start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   },\n * });\n *\n * for await (const record of parseStringStream(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport function parseStringStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<string>,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const recordStream = parseStringStreamToStream(stream, options);\n  return convertStreamToAsyncIterableIterator(recordStream);\n}\n\nexport declare namespace parseStringStream {\n  /**\n   * Parse CSV string stream to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseStringStream } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * const records = await parseStringStream.toArray(stream);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<string>,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string stream to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseStringStream } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * await parseStringStream.toStream(stream)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<string>,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\n\nObject.defineProperties(parseStringStream, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringStreamToStream,\n  },\n});\n"],"names":["parseStringStream","stream","options","recordStream","parseStringStreamToStream","convertStreamToAsyncIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStream"],"mappings":"kQAuCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAeC,EAAAA,0BAA0BH,EAAQC,GACvD,OAAOG,EAAAA,qCAAqCF,EAC9C,CAuEAG,OAAOC,iBAAiBP,EAAmB,CACzCQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,SAAU,CACRL,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA"}

package/dist/cjs/parseStringStreamToStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringStreamToStream.cjs","sources":["../../src/parseStringStreamToStream.ts"],"sourcesContent":["import { LexerTransformer } from \"./LexerTransformer.ts\";\nimport { RecordAssemblerTransformer } from \"./RecordAssemblerTransformer.ts\";\nimport { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { pipeline } from \"./utils/pipeline.ts\";\n\nexport function parseStringStreamToStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<string>,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  return pipeline(\n    stream,\n    new LexerTransformer(options),\n    new RecordAssemblerTransformer(options),\n  );\n}\n"],"names":["stream","options","pipeline","LexerTransformer","RecordAssemblerTransformer"],"mappings":"4OAKgB,SACdA,EACAC,GAEO,OAAAC,EAAAA,SACLF,EACA,IAAIG,EAAAA,iBAAiBF,GACrB,IAAIG,EAAAA,2BAA2BH,GAEnC"}
+{"version":3,"file":"parseStringStreamToStream.cjs","sources":["../../src/parseStringStreamToStream.ts"],"sourcesContent":["import { LexerTransformer } from \"./LexerTransformer.ts\";\nimport { RecordAssemblerTransformer } from \"./RecordAssemblerTransformer.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { pipeline } from \"./utils/pipeline.ts\";\n\nexport function parseStringStreamToStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<string>,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  return pipeline(\n    stream,\n    new LexerTransformer(options),\n    new RecordAssemblerTransformer(options),\n  );\n}\n"],"names":["stream","options","pipeline","LexerTransformer","RecordAssemblerTransformer"],"mappings":"4OAKgB,SACdA,EACAC,GAEO,OAAAC,EAAAA,SACLF,EACA,IAAIG,EAAAA,iBAAiBF,GACrB,IAAIG,EAAAA,2BAA2BH,GAEnC"}

package/dist/cjs/parseStringToArraySync.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToArraySync.cjs","sources":["../../src/parseStringToArraySync.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToArraySync<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): CSVRecord<Header>[] {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return [...assembler.assemble(tokens)];\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","tokens","lex","assemble"],"mappings":"iLAIgB,SACdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GAChCK,EAASJ,EAAMK,IAAIP,GACzB,MAAO,IAAII,EAAUI,SAASF,GAChC"}
+{"version":3,"file":"parseStringToArraySync.cjs","sources":["../../src/parseStringToArraySync.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToArraySync<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): CSVRecord<Header>[] {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return [...assembler.assemble(tokens)];\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","tokens","lex","assemble"],"mappings":"iLAIgB,SACdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GAChCK,EAASJ,EAAMK,IAAIP,GACzB,MAAO,IAAII,EAAUI,SAASF,GAChC"}

package/dist/cjs/parseStringToArraySyncWASM.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToArraySyncWASM.cjs","sources":["../../src/parseStringToArraySyncWASM.ts"],"sourcesContent":["import { parseStringToArraySync } from \"web-csv-toolbox-wasm\";\nimport { CSVRecord, CommonOptions } from \"./common/types.ts\";\nimport { COMMA, DOUBLE_QUOTE } from \"./constants.ts\";\nimport { type loadWASM } from \"./loadWASM.ts\";\n\n/**\n * Parse CSV string to record of arrays.\n *\n * @param csv CSV string\n * @param options Parse options\n * @returns Record of arrays\n *\n * @remarks\n * This function uses WebAssembly to parse CSV string.\n * Before calling this function, you must call {@link loadWASM} function.\n *\n * This function only supports UTF-8 string.\n * If you pass a string that is not UTF-8, like UTF-16, it throws an error.\n * This function only supports double quote as quotation.\n * So, `options.quotation` must be `\"` (double quote). Otherwise, it throws an error.\n *\n * And this function only supports single character as delimiter.\n * So, `options.delimiter` must be a single character. Otherwise, it throws an error.\n *\n * @example\n *\n * ```ts\n * import { loadWASM, parseStringWASM } from \"web-csv-toolbox\";\n *\n * await loadWASM();\n *\n * const csv = \"a,b,c\\n1,2,3\";\n *\n * const result = parseStringToArraySyncWASM(csv);\n * console.log(result);\n * // Prints:\n * // [{ a: \"1\", b: \"2\", c: \"3\" }]\n * ```\n * @beta\n */\nexport function parseStringToArraySyncWASM<Header extends readonly string[]>(\n  csv: string,\n  options: CommonOptions = {},\n): CSVRecord<Header>[] {\n  const { delimiter = COMMA, quotation = DOUBLE_QUOTE } = options;\n  if (typeof delimiter !== \"string\" || delimiter.length !== 1) {\n    throw new Error(\"Invalid delimiter, must be a single character on WASM.\");\n  }\n  if (quotation !== DOUBLE_QUOTE) {\n    throw new Error(\"Invalid quotation, must be double quote on WASM.\");\n  }\n  const demiliterCode = delimiter.charCodeAt(0);\n  return JSON.parse(parseStringToArraySync(csv, demiliterCode));\n}\n"],"names":["csv","options","delimiter","COMMA","quotation","DOUBLE_QUOTE","length","Error","demiliterCode","charCodeAt","JSON","parse","parseStringToArraySync"],"mappings":"wMAwCO,SACLA,EACAC,EAAyB,IAEzB,MAAMC,UAAEA,EAAYC,EAAOA,MAAAC,UAAAA,EAAYC,gBAAiBJ,EACxD,GAAyB,iBAAdC,GAA+C,IAArBA,EAAUI,OACvC,MAAA,IAAIC,MAAM,0DAElB,GAAIH,IAAcC,EAAAA,aACV,MAAA,IAAIE,MAAM,oDAEZ,MAAAC,EAAgBN,EAAUO,WAAW,GAC3C,OAAOC,KAAKC,MAAMC,EAAAA,uBAAuBZ,EAAKQ,GAChD"}
+{"version":3,"file":"parseStringToArraySyncWASM.cjs","sources":["../../src/parseStringToArraySyncWASM.ts"],"sourcesContent":["import { parseStringToArraySync } from \"web-csv-toolbox-wasm\";\nimport type { CSVRecord, CommonOptions } from \"./common/types.ts\";\nimport { COMMA, DOUBLE_QUOTE } from \"./constants.ts\";\nimport type { loadWASM } from \"./loadWASM.ts\";\n\n/**\n * Parse CSV string to record of arrays.\n *\n * @param csv CSV string\n * @param options Parse options\n * @returns Record of arrays\n *\n * @remarks\n * This function uses WebAssembly to parse CSV string.\n * Before calling this function, you must call {@link loadWASM} function.\n *\n * This function only supports UTF-8 string.\n * If you pass a string that is not UTF-8, like UTF-16, it throws an error.\n * This function only supports double quote as quotation.\n * So, `options.quotation` must be `\"` (double quote). Otherwise, it throws an error.\n *\n * And this function only supports single character as delimiter.\n * So, `options.delimiter` must be a single character. Otherwise, it throws an error.\n *\n * @example\n *\n * ```ts\n * import { loadWASM, parseStringWASM } from \"web-csv-toolbox\";\n *\n * await loadWASM();\n *\n * const csv = \"a,b,c\\n1,2,3\";\n *\n * const result = parseStringToArraySyncWASM(csv);\n * console.log(result);\n * // Prints:\n * // [{ a: \"1\", b: \"2\", c: \"3\" }]\n * ```\n * @beta\n */\nexport function parseStringToArraySyncWASM<Header extends readonly string[]>(\n  csv: string,\n  options: CommonOptions = {},\n): CSVRecord<Header>[] {\n  const { delimiter = COMMA, quotation = DOUBLE_QUOTE } = options;\n  if (typeof delimiter !== \"string\" || delimiter.length !== 1) {\n    throw new Error(\"Invalid delimiter, must be a single character on WASM.\");\n  }\n  if (quotation !== DOUBLE_QUOTE) {\n    throw new Error(\"Invalid quotation, must be double quote on WASM.\");\n  }\n  const demiliterCode = delimiter.charCodeAt(0);\n  return JSON.parse(parseStringToArraySync(csv, demiliterCode));\n}\n"],"names":["csv","options","delimiter","COMMA","quotation","DOUBLE_QUOTE","length","Error","demiliterCode","charCodeAt","JSON","parse","parseStringToArraySync"],"mappings":"wMAwCO,SACLA,EACAC,EAAyB,IAEzB,MAAMC,UAAEA,EAAYC,EAAOA,MAAAC,UAAAA,EAAYC,gBAAiBJ,EACxD,GAAyB,iBAAdC,GAA+C,IAArBA,EAAUI,OACvC,MAAA,IAAIC,MAAM,0DAElB,GAAIH,IAAcC,EAAAA,aACV,MAAA,IAAIE,MAAM,oDAEZ,MAAAC,EAAgBN,EAAUO,WAAW,GAC3C,OAAOC,KAAKC,MAAMC,EAAAA,uBAAuBZ,EAAKQ,GAChD"}

package/dist/cjs/parseStringToIterableIterator.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToIterableIterator.cjs","sources":["../../src/parseStringToIterableIterator.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): IterableIterator<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return assembler.assemble(tokens);\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","tokens","lex","assemble"],"mappings":"wLAIgB,SAGdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GAChCK,EAASJ,EAAMK,IAAIP,GAClB,OAAAI,EAAUI,SAASF,EAC5B"}
+{"version":3,"file":"parseStringToIterableIterator.cjs","sources":["../../src/parseStringToIterableIterator.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): IterableIterator<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return assembler.assemble(tokens);\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","tokens","lex","assemble"],"mappings":"wLAIgB,SAGdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GAChCK,EAASJ,EAAMK,IAAIP,GAClB,OAAAI,EAAUI,SAASF,EAC5B"}

package/dist/cjs/parseStringToStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToStream.cjs","sources":["../../src/parseStringToStream.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToStream<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  return new ReadableStream({\n    start(controller) {\n      const tokens = lexer.lex(csv);\n      for (const record of assembler.assemble(tokens)) {\n        controller.enqueue(record);\n      }\n      controller.close();\n    },\n  });\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","ReadableStream","start","controller","tokens","lex","record","assemble","enqueue","close"],"mappings":"8KAIgB,SACdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GACtC,OAAO,IAAIK,eAAe,CACxB,KAAAC,CAAMC,GACE,MAAAC,EAASP,EAAMQ,IAAIV,GACzB,IAAA,MAAWW,KAAUP,EAAUQ,SAASH,GACtCD,EAAWK,QAAQF,GAErBH,EAAWM,OACb,GAEJ"}
+{"version":3,"file":"parseStringToStream.cjs","sources":["../../src/parseStringToStream.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToStream<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  return new ReadableStream({\n    start(controller) {\n      const tokens = lexer.lex(csv);\n      for (const record of assembler.assemble(tokens)) {\n        controller.enqueue(record);\n      }\n      controller.close();\n    },\n  });\n}\n"],"names":["csv","options","lexer","Lexer","assembler","RecordAssembler","ReadableStream","start","controller","tokens","lex","record","assemble","enqueue","close"],"mappings":"8KAIgB,SACdA,EACAC,GAEM,MAAAC,EAAQ,IAAIC,QAAMF,GAClBG,EAAY,IAAIC,kBAAgBJ,GACtC,OAAO,IAAIK,eAAe,CACxB,KAAAC,CAAMC,GACE,MAAAC,EAASP,EAAMQ,IAAIV,GACzB,IAAA,MAAWW,KAAUP,EAAUQ,SAASH,GACtCD,EAAWK,QAAQF,GAErBH,EAAWM,OACb,GAEJ"}

package/dist/cjs/parseUint8ArrayStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseUint8ArrayStream.cjs","sources":["../../src/parseUint8ArrayStream.ts"],"sourcesContent":["import { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\nimport { convertStreamToAsyncIterableIterator } from \"./utils/convertStreamToAsyncIterableIterator.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV to records.\n * This function is for parsing a binary stream.\n *\n * @category Middle-level API\n * @remarks\n * If you want to parse a string, use {@link parseStringStream}.\n * @param stream CSV string to parse\n * @param options Parsing options.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseUint8ArrayStream.toArray} function.\n *\n * @example Parsing CSV binary\n *\n * ```ts\n * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n *\n * const csv = Uint8Array.from([\n *  // ...\n * ]);\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   },\n * });\n *\n * for await (const record of parseUint8ArrayStream(csv)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseUint8ArrayStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<Uint8Array>,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const recordStream = parseUint8ArrayStreamToStream(stream, options);\n  return convertStreamToAsyncIterableIterator(recordStream);\n}\n\nexport declare namespace parseUint8ArrayStream {\n  /**\n   * Parse CSV binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV binary\n   * ```ts\n   * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *   // ...\n   * ]);\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * const records = await parseUint8ArrayStream.toArray(stream);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<Uint8Array>,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV binary to array of records.\n   *\n   * @returns Stream of records\n   *\n   * @example Parsing CSV binary\n   * ```ts\n   * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const stream = new ReadableStream({\n   *  start(controller) {\n   *   controller.enqueue(csv);\n   *  controller.close();\n   * },\n   * });\n   *\n   * await parseUint8ArrayStream.toStream(stream)\n   *   .pipeTo(new WritableStream({\n   *     write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<Uint8Array>,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>[]>;\n}\nObject.defineProperties(parseUint8ArrayStream, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseUint8ArrayStreamToStream,\n  },\n});\n"],"names":["parseUint8ArrayStream","stream","options","recordStream","parseUint8ArrayStreamToStream","convertStreamToAsyncIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStream"],"mappings":"sQAwCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAeC,EAAAA,8BAA8BH,EAAQC,GAC3D,OAAOG,EAAAA,qCAAqCF,EAC9C,CAkEAG,OAAOC,iBAAiBP,EAAuB,CAC7CQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,SAAU,CACRL,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA"}
+{"version":3,"file":"parseUint8ArrayStream.cjs","sources":["../../src/parseUint8ArrayStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseStringStream } from \"./parseStringStream.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\nimport { convertStreamToAsyncIterableIterator } from \"./utils/convertStreamToAsyncIterableIterator.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV to records.\n * This function is for parsing a binary stream.\n *\n * @category Middle-level API\n * @remarks\n * If you want to parse a string, use {@link parseStringStream}.\n * @param stream CSV string to parse\n * @param options Parsing options.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseUint8ArrayStream.toArray} function.\n *\n * @example Parsing CSV binary\n *\n * ```ts\n * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n *\n * const csv = Uint8Array.from([\n *  // ...\n * ]);\n *\n * const stream = new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(csv);\n *     controller.close();\n *   },\n * });\n *\n * for await (const record of parseUint8ArrayStream(csv)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseUint8ArrayStream<Header extends ReadonlyArray<string>>(\n  stream: ReadableStream<Uint8Array>,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const recordStream = parseUint8ArrayStreamToStream(stream, options);\n  return convertStreamToAsyncIterableIterator(recordStream);\n}\n\nexport declare namespace parseUint8ArrayStream {\n  /**\n   * Parse CSV binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV binary\n   * ```ts\n   * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *   // ...\n   * ]);\n   *\n   * const stream = new ReadableStream({\n   *   start(controller) {\n   *     controller.enqueue(csv);\n   *     controller.close();\n   *   },\n   * });\n   *\n   * const records = await parseUint8ArrayStream.toArray(stream);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<Uint8Array>,\n    options?: ParseBinaryOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV binary to array of records.\n   *\n   * @returns Stream of records\n   *\n   * @example Parsing CSV binary\n   * ```ts\n   * import { parseUint8ArrayStream } from 'web-csv-toolbox';\n   *\n   * const csv = Uint8Array.from([\n   *  // ...\n   * ]);\n   *\n   * const stream = new ReadableStream({\n   *  start(controller) {\n   *   controller.enqueue(csv);\n   *  controller.close();\n   * },\n   * });\n   *\n   * await parseUint8ArrayStream.toStream(stream)\n   *   .pipeTo(new WritableStream({\n   *     write(record) {\n   *       console.log(record);\n   *     },\n   *   }),\n   * );\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    stream: ReadableStream<Uint8Array>,\n    options?: ParseBinaryOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>[]>;\n}\nObject.defineProperties(parseUint8ArrayStream, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseUint8ArrayStreamToStream,\n  },\n});\n"],"names":["parseUint8ArrayStream","stream","options","recordStream","parseUint8ArrayStreamToStream","convertStreamToAsyncIterableIterator","Object","defineProperties","toArray","enumerable","writable","value","internal.convertThisAsyncIterableIteratorToArray","convertThisAsyncIterableIteratorToArray","toStream"],"mappings":"sQAwCgB,SAAAA,EACdC,EACAC,GAEM,MAAAC,EAAeC,EAAAA,8BAA8BH,EAAQC,GAC3D,OAAOG,EAAAA,qCAAqCF,EAC9C,CAkEAG,OAAOC,iBAAiBP,EAAuB,CAC7CQ,QAAS,CACPC,YAAY,EACZC,UAAU,EACVC,MAAOC,EAASC,yCAElBC,SAAU,CACRL,YAAY,EACZC,UAAU,EACVC,MAAOP,EAAAA"}

package/dist/cjs/parseUint8ArrayStreamToStream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseUint8ArrayStreamToStream.cjs","sources":["../../src/parseUint8ArrayStreamToStream.ts"],"sourcesContent":["import { LexerTransformer } from \"./LexerTransformer.ts\";\nimport { RecordAssemblerTransformer } from \"./RecordAssemblerTransformer.ts\";\nimport { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { pipeline } from \"./utils/pipeline.ts\";\n\nexport function parseUint8ArrayStreamToStream<Header extends readonly string[]>(\n  stream: ReadableStream<Uint8Array>,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const { charset, fatal, ignoreBOM, decomposition } = options ?? {};\n  return decomposition\n    ? pipeline(\n        stream,\n        new DecompressionStream(decomposition),\n        new TextDecoderStream(charset, { fatal, ignoreBOM }),\n        new LexerTransformer(options),\n        new RecordAssemblerTransformer(options),\n      )\n    : pipeline(\n        stream,\n        new TextDecoderStream(charset, { fatal, ignoreBOM }),\n        new LexerTransformer(options),\n        new RecordAssemblerTransformer(options),\n      );\n}\n"],"names":["stream","options","charset","fatal","ignoreBOM","decomposition","pipeline","DecompressionStream","TextDecoderStream","LexerTransformer","RecordAssemblerTransformer"],"mappings":"gPAKgB,SACdA,EACAC,GAEA,MAAMC,QAAEA,EAASC,MAAAA,EAAAC,UAAOA,gBAAWC,GAAkBJ,GAAW,GAChE,OAAOI,EACHC,EAAAA,SACEN,EACA,IAAIO,oBAAoBF,GACxB,IAAIG,kBAAkBN,EAAS,CAAEC,QAAOC,cACxC,IAAIK,EAAAA,iBAAiBR,GACrB,IAAIS,EAAAA,2BAA2BT,IAEjCK,EAAAA,SACEN,EACA,IAAIQ,kBAAkBN,EAAS,CAAEC,QAAOC,cACxC,IAAIK,EAAAA,iBAAiBR,GACrB,IAAIS,EAAAA,2BAA2BT,GAEvC"}
+{"version":3,"file":"parseUint8ArrayStreamToStream.cjs","sources":["../../src/parseUint8ArrayStreamToStream.ts"],"sourcesContent":["import { LexerTransformer } from \"./LexerTransformer.ts\";\nimport { RecordAssemblerTransformer } from \"./RecordAssemblerTransformer.ts\";\nimport type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { pipeline } from \"./utils/pipeline.ts\";\n\nexport function parseUint8ArrayStreamToStream<Header extends readonly string[]>(\n  stream: ReadableStream<Uint8Array>,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const { charset, fatal, ignoreBOM, decomposition } = options ?? {};\n  return decomposition\n    ? pipeline(\n        stream,\n        new DecompressionStream(decomposition),\n        new TextDecoderStream(charset, { fatal, ignoreBOM }),\n        new LexerTransformer(options),\n        new RecordAssemblerTransformer(options),\n      )\n    : pipeline(\n        stream,\n        new TextDecoderStream(charset, { fatal, ignoreBOM }),\n        new LexerTransformer(options),\n        new RecordAssemblerTransformer(options),\n      );\n}\n"],"names":["stream","options","charset","fatal","ignoreBOM","decomposition","pipeline","DecompressionStream","TextDecoderStream","LexerTransformer","RecordAssemblerTransformer"],"mappings":"gPAKgB,SACdA,EACAC,GAEA,MAAMC,QAAEA,EAASC,MAAAA,EAAAC,UAAOA,gBAAWC,GAAkBJ,GAAW,GAChE,OAAOI,EACHC,EAAAA,SACEN,EACA,IAAIO,oBAAoBF,GACxB,IAAIG,kBAAkBN,EAAS,CAAEC,QAAOC,cACxC,IAAIK,EAAAA,iBAAiBR,GACrB,IAAIS,EAAAA,2BAA2BT,IAEjCK,EAAAA,SACEN,EACA,IAAIQ,kBAAkBN,EAAS,CAAEC,QAAOC,cACxC,IAAIK,EAAAA,iBAAiBR,GACrB,IAAIS,EAAAA,2BAA2BT,GAEvC"}

package/dist/es/Lexer.js

@@ -65,7 +65,11 @@ class Lexer {
           yield token;
           break;
         default:
-          currentField = token;
+          if (currentField) {
+            currentField.value += token.value;
+          } else {
+            currentField = token;
+          }
           break;
       }
     }

package/dist/es/Lexer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Lexer.js","sources":["../../src/Lexer.ts"],"sourcesContent":["import { assertCommonOptions } from \"./assertCommonOptions.ts\";\nimport { Field, FieldDelimiter, RecordDelimiter } from \"./common/constants.ts\";\nimport { CommonOptions, Token } from \"./common/types.ts\";\nimport { COMMA, CRLF, DOUBLE_QUOTE, LF } from \"./constants.ts\";\nimport { escapeRegExp } from \"./utils/escapeRegExp.ts\";\n\nexport class Lexer {\n  #delimiter: string;\n  #delimiterLength: number;\n  #quotation: string;\n  #quotationLength: number;\n  #matcher: RegExp;\n  #buffer = \"\";\n  #flush = false;\n\n  constructor({\n    delimiter = COMMA,\n    quotation = DOUBLE_QUOTE,\n  }: CommonOptions = {}) {\n    assertCommonOptions({ delimiter, quotation });\n    this.#delimiter = delimiter;\n    this.#delimiterLength = delimiter.length;\n    this.#quotation = quotation;\n    this.#quotationLength = quotation.length;\n\n    const d = escapeRegExp(delimiter);\n    const q = escapeRegExp(quotation);\n    this.#matcher = new RegExp(\n      `^(?:(?!${q})(?!${d})(?![\\\\r\\\\n]))([\\\\S\\\\s\\\\uFEFF\\\\xA0]+?)(?=${q}|${d}|\\\\r|\\\\n|$)`,\n    );\n  }\n\n  public lex(chunk: string | null, buffering = false): IterableIterator<Token> {\n    if (!buffering) {\n      this.#flush = true;\n    }\n    if (typeof chunk === \"string\" && chunk.length !== 0) {\n      this.#buffer += chunk;\n    }\n\n    return this.#tokens();\n  }\n\n  public flush(): Token[] {\n    this.#flush = true;\n    return [...this.#tokens()];\n  }\n\n  *#tokens(): Generator<Token> {\n    if (this.#flush) {\n      // Trim the last CRLF or LF\n      if (this.#buffer.endsWith(CRLF)) {\n        this.#buffer = this.#buffer.slice(0, -CRLF.length);\n      } else if (this.#buffer.endsWith(LF)) {\n        this.#buffer = this.#buffer.slice(0, -LF.length);\n      }\n    }\n    let currentField: Token | null = null;\n    for (let token: Token | null; (token = this.#nextToken()); ) {\n      switch (token) {\n        case FieldDelimiter:\n          if (currentField) {\n            yield currentField;\n            currentField = null;\n          }\n          yield token;\n          break;\n        case RecordDelimiter:\n          if (currentField) {\n            yield currentField;\n            currentField = null;\n          }\n          yield token;\n          break;\n        default:\n          currentField = token;\n          break;\n      }\n    }\n    if (currentField) {\n      yield currentField;\n    }\n  }\n\n  #nextToken(): Token | null {\n    if (this.#buffer.length === 0) {\n      return null;\n    }\n    // Buffer is Record Delimiter, defer to the next iteration.\n    if (\n      this.#flush === false &&\n      (this.#buffer === CRLF || this.#buffer === LF)\n    ) {\n      return null;\n    }\n\n    // Check for CRLF\n    if (this.#buffer.startsWith(CRLF)) {\n      this.#buffer = this.#buffer.slice(2);\n      return RecordDelimiter;\n    }\n\n    // Check for LF\n    if (this.#buffer.startsWith(LF)) {\n      this.#buffer = this.#buffer.slice(1);\n      return RecordDelimiter;\n    }\n\n    // Check for Delimiter\n    if (this.#buffer.startsWith(this.#delimiter)) {\n      this.#buffer = this.#buffer.slice(this.#delimiterLength);\n      return FieldDelimiter;\n    }\n\n    // Check for Quoted String\n    if (this.#buffer.startsWith(this.#quotation)) {\n      // If not flushing and the buffer doesn't end with a quote, then return null.\n      if (this.#flush === false && this.#buffer.endsWith(this.#quotation)) {\n        return null;\n      }\n      return this.#extractQuotedString();\n    }\n\n    // Check for Unquoted String\n    const match = this.#matcher.exec(this.#buffer);\n    if (match) {\n      // If we're flushing and the match doesn't consume the entire buffer,\n      // then return null\n      if (this.#flush === false && match[0].length === this.#buffer.length) {\n        return null;\n      }\n      this.#buffer = this.#buffer.slice(match[0].length);\n      return { type: Field, value: match[0] };\n    }\n\n    // Otherwise, return null\n    return null;\n  }\n\n  #extractQuotedString(): Token | null {\n    let end = this.#quotationLength; // Skip the opening quote\n    let value = \"\";\n\n    while (end < this.#buffer.length) {\n      // Escaped quote\n      if (\n        this.#buffer.slice(end, end + this.#quotationLength) ===\n          this.#quotation &&\n        this.#buffer.slice(\n          end + this.#quotationLength,\n          end + this.#quotationLength * 2,\n        ) === this.#quotation\n      ) {\n        value += this.#quotation;\n        end += this.#quotationLength * 2;\n        continue;\n      }\n\n      // Closing quote\n      if (\n        this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation\n      ) {\n        // If flushing and the buffer doesn't end with a quote, then return null\n        if (\n          this.#flush === false &&\n          end + this.#quotationLength < this.#buffer.length &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            this.#delimiterLength,\n          ) !== this.#delimiter &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            end + this.#quotationLength + 2 /** CRLF.length */,\n          ) !== CRLF &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            end + this.#quotationLength + 1 /** LF.length */,\n          ) !== LF\n        ) {\n          return null;\n        }\n\n        // Otherwise, return the quoted string\n        this.#buffer = this.#buffer.slice(end + this.#quotationLength);\n        return { type: Field, value };\n      }\n\n      value += this.#buffer[end];\n      end++;\n    }\n\n    // If we get here, we've reached the end of the buffer\n    return null;\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"Lexer.js","sources":["../../src/Lexer.ts"],"sourcesContent":["import { assertCommonOptions } from \"./assertCommonOptions.ts\";\nimport { Field, FieldDelimiter, RecordDelimiter } from \"./common/constants.ts\";\nimport type { CommonOptions, Token } from \"./common/types.ts\";\nimport { COMMA, CRLF, DOUBLE_QUOTE, LF } from \"./constants.ts\";\nimport { escapeRegExp } from \"./utils/escapeRegExp.ts\";\n\nexport class Lexer {\n  #delimiter: string;\n  #delimiterLength: number;\n  #quotation: string;\n  #quotationLength: number;\n  #matcher: RegExp;\n  #buffer = \"\";\n  #flush = false;\n\n  constructor({\n    delimiter = COMMA,\n    quotation = DOUBLE_QUOTE,\n  }: CommonOptions = {}) {\n    assertCommonOptions({ delimiter, quotation });\n    this.#delimiter = delimiter;\n    this.#delimiterLength = delimiter.length;\n    this.#quotation = quotation;\n    this.#quotationLength = quotation.length;\n\n    const d = escapeRegExp(delimiter);\n    const q = escapeRegExp(quotation);\n    this.#matcher = new RegExp(\n      `^(?:(?!${q})(?!${d})(?![\\\\r\\\\n]))([\\\\S\\\\s\\\\uFEFF\\\\xA0]+?)(?=${q}|${d}|\\\\r|\\\\n|$)`,\n    );\n  }\n\n  public lex(chunk: string | null, buffering = false): IterableIterator<Token> {\n    if (!buffering) {\n      this.#flush = true;\n    }\n    if (typeof chunk === \"string\" && chunk.length !== 0) {\n      this.#buffer += chunk;\n    }\n\n    return this.#tokens();\n  }\n\n  public flush(): Token[] {\n    this.#flush = true;\n    return [...this.#tokens()];\n  }\n\n  *#tokens(): Generator<Token> {\n    if (this.#flush) {\n      // Trim the last CRLF or LF\n      if (this.#buffer.endsWith(CRLF)) {\n        this.#buffer = this.#buffer.slice(0, -CRLF.length);\n      } else if (this.#buffer.endsWith(LF)) {\n        this.#buffer = this.#buffer.slice(0, -LF.length);\n      }\n    }\n    let currentField: Token | null = null;\n    for (let token: Token | null; (token = this.#nextToken()); ) {\n      switch (token) {\n        case FieldDelimiter:\n          if (currentField) {\n            yield currentField;\n            currentField = null;\n          }\n          yield token;\n          break;\n        case RecordDelimiter:\n          if (currentField) {\n            yield currentField;\n            currentField = null;\n          }\n          yield token;\n          break;\n        default:\n          // If currentField is not null, append the new token's value to it\n          if (currentField) {\n            currentField.value += token.value;\n          } else {\n            currentField = token;\n          }\n          break;\n      }\n    }\n    if (currentField) {\n      yield currentField;\n    }\n  }\n\n  #nextToken(): Token | null {\n    if (this.#buffer.length === 0) {\n      return null;\n    }\n    // Buffer is Record Delimiter, defer to the next iteration.\n    if (\n      this.#flush === false &&\n      (this.#buffer === CRLF || this.#buffer === LF)\n    ) {\n      return null;\n    }\n\n    // Check for CRLF\n    if (this.#buffer.startsWith(CRLF)) {\n      this.#buffer = this.#buffer.slice(2);\n      return RecordDelimiter;\n    }\n\n    // Check for LF\n    if (this.#buffer.startsWith(LF)) {\n      this.#buffer = this.#buffer.slice(1);\n      return RecordDelimiter;\n    }\n\n    // Check for Delimiter\n    if (this.#buffer.startsWith(this.#delimiter)) {\n      this.#buffer = this.#buffer.slice(this.#delimiterLength);\n      return FieldDelimiter;\n    }\n\n    // Check for Quoted String\n    if (this.#buffer.startsWith(this.#quotation)) {\n      // If not flushing and the buffer doesn't end with a quote, then return null.\n      if (this.#flush === false && this.#buffer.endsWith(this.#quotation)) {\n        return null;\n      }\n      return this.#extractQuotedString();\n    }\n\n    // Check for Unquoted String\n    const match = this.#matcher.exec(this.#buffer);\n    if (match) {\n      // If we're flushing and the match doesn't consume the entire buffer,\n      // then return null\n      if (this.#flush === false && match[0].length === this.#buffer.length) {\n        return null;\n      }\n      this.#buffer = this.#buffer.slice(match[0].length);\n      return { type: Field, value: match[0] };\n    }\n\n    // Otherwise, return null\n    return null;\n  }\n\n  #extractQuotedString(): Token | null {\n    let end = this.#quotationLength; // Skip the opening quote\n    let value = \"\";\n\n    while (end < this.#buffer.length) {\n      // Escaped quote\n      if (\n        this.#buffer.slice(end, end + this.#quotationLength) ===\n          this.#quotation &&\n        this.#buffer.slice(\n          end + this.#quotationLength,\n          end + this.#quotationLength * 2,\n        ) === this.#quotation\n      ) {\n        value += this.#quotation;\n        end += this.#quotationLength * 2;\n        continue;\n      }\n\n      // Closing quote\n      if (\n        this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation\n      ) {\n        // If flushing and the buffer doesn't end with a quote, then return null\n        if (\n          this.#flush === false &&\n          end + this.#quotationLength < this.#buffer.length &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            this.#delimiterLength,\n          ) !== this.#delimiter &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            end + this.#quotationLength + 2 /** CRLF.length */,\n          ) !== CRLF &&\n          this.#buffer.slice(\n            end + this.#quotationLength,\n            end + this.#quotationLength + 1 /** LF.length */,\n          ) !== LF\n        ) {\n          return null;\n        }\n\n        // Otherwise, return the quoted string\n        this.#buffer = this.#buffer.slice(end + this.#quotationLength);\n        return { type: Field, value };\n      }\n\n      value += this.#buffer[end];\n      end++;\n    }\n\n    // If we get here, we've reached the end of the buffer\n    return null;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/es/LexerTransformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"LexerTransformer.js","sources":["../../src/LexerTransformer.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { CommonOptions, Token } from \"./common/types.ts\";\n\n/**\n * A transform stream that converts a stream of tokens into a stream of rows.\n *\n * @category Low-level API\n *\n * @example Parse a CSV with headers by data\n * ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"name,age\\r\\n\");\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.close();\n *   }\n * })\n *   .pipeThrough(new LexerTransformer())\n *   .pipeTo(new WritableStream({ write(tokens) {\n *     for (const token of tokens) {\n *       console.log(token);\n *     }\n *   }}));\n * // { type: Field, value: \"name\" }\n * // FieldDelimiter\n * // { type: Field, value: \"age\" }\n * // RecordDelimiter\n * // { type: Field, value: \"Alice\" }\n * // FieldDelimiter\n * // { type: Field, value: \"20\" }\n * // RecordDelimiter\n * ```\n */\nexport class LexerTransformer extends TransformStream<string, Token[]> {\n  constructor(options: CommonOptions = {}) {\n    const lexer = new Lexer(options);\n    super({\n      transform: (chunk, controller) => {\n        if (chunk.length !== 0) {\n          controller.enqueue([...lexer.lex(chunk, true)]);\n        }\n      },\n      flush: (controller) => {\n        controller.enqueue(lexer.flush());\n      },\n    });\n  }\n}\n"],"names":[],"mappings":";;AAiCO,MAAM,yBAAyB,eAAiC,CAAA;AAAA,EACrE,WAAA,CAAY,OAAyB,GAAA,EAAI,EAAA;AACvC,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,IAAM,KAAA,CAAA;AAAA,MACJ,SAAA,EAAW,CAAC,KAAA,EAAO,UAAe,KAAA;AAChC,QAAI,IAAA,KAAA,CAAM,WAAW,CAAG,EAAA;AACtB,UAAW,UAAA,CAAA,OAAA,CAAQ,CAAC,GAAG,KAAA,CAAM,IAAI,KAAO,EAAA,IAAI,CAAC,CAAC,CAAA,CAAA;AAAA,SAChD;AAAA,OACF;AAAA,MACA,KAAA,EAAO,CAAC,UAAe,KAAA;AACrB,QAAW,UAAA,CAAA,OAAA,CAAQ,KAAM,CAAA,KAAA,EAAO,CAAA,CAAA;AAAA,OAClC;AAAA,KACD,CAAA,CAAA;AAAA,GACH;AACF;;;;"}
+{"version":3,"file":"LexerTransformer.js","sources":["../../src/LexerTransformer.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport type { CommonOptions, Token } from \"./common/types.ts\";\n\n/**\n * A transform stream that converts a stream of tokens into a stream of rows.\n *\n * @category Low-level API\n *\n * @example Parse a CSV with headers by data\n * ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"name,age\\r\\n\");\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.close();\n *   }\n * })\n *   .pipeThrough(new LexerTransformer())\n *   .pipeTo(new WritableStream({ write(tokens) {\n *     for (const token of tokens) {\n *       console.log(token);\n *     }\n *   }}));\n * // { type: Field, value: \"name\" }\n * // FieldDelimiter\n * // { type: Field, value: \"age\" }\n * // RecordDelimiter\n * // { type: Field, value: \"Alice\" }\n * // FieldDelimiter\n * // { type: Field, value: \"20\" }\n * // RecordDelimiter\n * ```\n */\nexport class LexerTransformer extends TransformStream<string, Token[]> {\n  constructor(options: CommonOptions = {}) {\n    const lexer = new Lexer(options);\n    super({\n      transform: (chunk, controller) => {\n        if (chunk.length !== 0) {\n          controller.enqueue([...lexer.lex(chunk, true)]);\n        }\n      },\n      flush: (controller) => {\n        controller.enqueue(lexer.flush());\n      },\n    });\n  }\n}\n"],"names":[],"mappings":";;AAiCO,MAAM,yBAAyB,eAAiC,CAAA;AAAA,EACrE,WAAA,CAAY,OAAyB,GAAA,EAAI,EAAA;AACvC,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,IAAM,KAAA,CAAA;AAAA,MACJ,SAAA,EAAW,CAAC,KAAA,EAAO,UAAe,KAAA;AAChC,QAAI,IAAA,KAAA,CAAM,WAAW,CAAG,EAAA;AACtB,UAAW,UAAA,CAAA,OAAA,CAAQ,CAAC,GAAG,KAAA,CAAM,IAAI,KAAO,EAAA,IAAI,CAAC,CAAC,CAAA,CAAA;AAAA,SAChD;AAAA,OACF;AAAA,MACA,KAAA,EAAO,CAAC,UAAe,KAAA;AACrB,QAAW,UAAA,CAAA,OAAA,CAAQ,KAAM,CAAA,KAAA,EAAO,CAAA,CAAA;AAAA,OAClC;AAAA,KACD,CAAA,CAAA;AAAA,GACH;AACF;;;;"}

package/dist/es/RecordAssembler.js.map

@@ -1 +1 @@
-{"version":3,"file":"RecordAssembler.js","sources":["../../src/RecordAssembler.ts"],"sourcesContent":["import { FieldDelimiter, RecordDelimiter } from \"./common/constants.ts\";\nimport { CSVRecord, RecordAssemblerOptions, Token } from \"./common/types.ts\";\n\nexport class RecordAssembler<Header extends ReadonlyArray<string>> {\n  #fieldIndex = 0;\n  #row: string[] = [];\n  #header: Header | undefined;\n  #dirty = false;\n\n  constructor(options: RecordAssemblerOptions<Header> = {}) {\n    if (options.header !== undefined && Array.isArray(options.header)) {\n      this.#setHeader(options.header);\n    }\n  }\n\n  public *assemble(\n    tokens: Iterable<Token>,\n    flush = true,\n  ): IterableIterator<CSVRecord<Header>> {\n    for (const token of tokens) {\n      switch (token) {\n        case FieldDelimiter:\n          this.#fieldIndex++;\n          this.#dirty = true;\n          break;\n        case RecordDelimiter:\n          if (this.#header === undefined) {\n            this.#setHeader(this.#row as unknown as Header);\n          } else {\n            if (this.#dirty) {\n              yield Object.fromEntries(\n                this.#header.map((header, index) => [\n                  header,\n                  this.#row.at(index),\n                ]),\n              ) as unknown as CSVRecord<Header>;\n            } else {\n              yield Object.fromEntries(\n                this.#header.map((header) => [header, \"\"]),\n              ) as CSVRecord<Header>;\n            }\n          }\n          // Reset the row fields buffer.\n          this.#fieldIndex = 0;\n          this.#row = new Array(this.#header?.length).fill(\"\");\n          this.#dirty = false;\n          break;\n        default:\n          this.#dirty = true;\n          this.#row[this.#fieldIndex] = token.value;\n          break;\n      }\n    }\n\n    if (flush) {\n      yield* this.flush();\n    }\n  }\n\n  public *flush(): Generator<CSVRecord<Header>> {\n    if (this.#header !== undefined) {\n      if (this.#dirty) {\n        yield Object.fromEntries(\n          this.#header\n            .filter((v) => v)\n            .map((header, index) => [header, this.#row.at(index)]),\n        ) as unknown as CSVRecord<Header>;\n      }\n    }\n  }\n\n  #setHeader(header: Header) {\n    this.#header = header;\n    if (this.#header.length === 0) {\n      throw new Error(\"The header must not be empty.\");\n    }\n    if (new Set(this.#header).size !== this.#header.length) {\n      throw new Error(\"The header must not contain duplicate fields.\");\n    }\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"RecordAssembler.js","sources":["../../src/RecordAssembler.ts"],"sourcesContent":["import { FieldDelimiter, RecordDelimiter } from \"./common/constants.ts\";\nimport type {\n  CSVRecord,\n  RecordAssemblerOptions,\n  Token,\n} from \"./common/types.ts\";\n\nexport class RecordAssembler<Header extends ReadonlyArray<string>> {\n  #fieldIndex = 0;\n  #row: string[] = [];\n  #header: Header | undefined;\n  #dirty = false;\n\n  constructor(options: RecordAssemblerOptions<Header> = {}) {\n    if (options.header !== undefined && Array.isArray(options.header)) {\n      this.#setHeader(options.header);\n    }\n  }\n\n  public *assemble(\n    tokens: Iterable<Token>,\n    flush = true,\n  ): IterableIterator<CSVRecord<Header>> {\n    for (const token of tokens) {\n      switch (token) {\n        case FieldDelimiter:\n          this.#fieldIndex++;\n          this.#dirty = true;\n          break;\n        case RecordDelimiter:\n          if (this.#header === undefined) {\n            this.#setHeader(this.#row as unknown as Header);\n          } else {\n            if (this.#dirty) {\n              yield Object.fromEntries(\n                this.#header.map((header, index) => [\n                  header,\n                  this.#row.at(index),\n                ]),\n              ) as unknown as CSVRecord<Header>;\n            } else {\n              yield Object.fromEntries(\n                this.#header.map((header) => [header, \"\"]),\n              ) as CSVRecord<Header>;\n            }\n          }\n          // Reset the row fields buffer.\n          this.#fieldIndex = 0;\n          this.#row = new Array(this.#header?.length).fill(\"\");\n          this.#dirty = false;\n          break;\n        default:\n          this.#dirty = true;\n          this.#row[this.#fieldIndex] = token.value;\n          break;\n      }\n    }\n\n    if (flush) {\n      yield* this.flush();\n    }\n  }\n\n  public *flush(): Generator<CSVRecord<Header>> {\n    if (this.#header !== undefined) {\n      if (this.#dirty) {\n        yield Object.fromEntries(\n          this.#header\n            .filter((v) => v)\n            .map((header, index) => [header, this.#row.at(index)]),\n        ) as unknown as CSVRecord<Header>;\n      }\n    }\n  }\n\n  #setHeader(header: Header) {\n    this.#header = header;\n    if (this.#header.length === 0) {\n      throw new Error(\"The header must not be empty.\");\n    }\n    if (new Set(this.#header).size !== this.#header.length) {\n      throw new Error(\"The header must not contain duplicate fields.\");\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/es/RecordAssemblerTransformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"RecordAssemblerTransformer.js","sources":["../../src/RecordAssemblerTransformer.ts"],"sourcesContent":["import { RecordAssembler } from \"./RecordAssembler.ts\";\nimport { CSVRecord, RecordAssemblerOptions, Token } from \"./common/types.ts\";\n\n/**\n * A transform stream that converts a stream of tokens into a stream of rows.\n * @template Header The type of the header row.\n * @param options The options for the parser.\n *\n * @category Low-level API\n *\n * @example Parse a CSV with headers by data\n *  ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"name,age\\r\\n\");\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.enqueue(\"Bob,25\\r\\n\");\n *     controller.enqueue(\"Charlie,30\\r\\n\");\n *     controller.close();\n *   })\n *   .pipeThrough(new LexerTransformer())\n *   .pipeThrough(new RecordAssemblerTransformer())\n *   .pipeTo(new WritableStream({ write(row) { console.log(row); }}));\n * // { name: \"Alice\", age: \"20\" }\n * // { name: \"Bob\", age: \"25\" }\n * // { name: \"Charlie\", age: \"30\" }\n * ```\n *\n * @example Parse a CSV with headers by options\n * ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.enqueue(\"Bob,25\\r\\n\");\n *     controller.enqueue(\"Charlie,30\\r\\n\");\n *     controller.close();\n *   }\n * })\n * .pipeThrough(new LexerTransformer())\n * .pipeThrough(new RecordAssemblerTransformer({ header: [\"name\", \"age\"] }))\n * .pipeTo(new WritableStream({ write(row) { console.log(row); }}));\n * // { name: \"Alice\", age: \"20\" }\n * // { name: \"Bob\", age: \"25\" }\n * // { name: \"Charlie\", age: \"30\" }\n * ```\n */\nexport class RecordAssemblerTransformer<\n  Header extends ReadonlyArray<string>,\n> extends TransformStream<Token[], CSVRecord<Header>> {\n  constructor(options: RecordAssemblerOptions<Header> = {}) {\n    const assembler = new RecordAssembler(options);\n    super({\n      transform: (tokens, controller) => {\n        for (const token of assembler.assemble(tokens, false)) {\n          controller.enqueue(token);\n        }\n      },\n      flush: (controller) => {\n        for (const token of assembler.flush()) {\n          controller.enqueue(token);\n        }\n      },\n    });\n  }\n}\n"],"names":[],"mappings":";;AA8CO,MAAM,mCAEH,eAA4C,CAAA;AAAA,EACpD,WAAA,CAAY,OAA0C,GAAA,EAAI,EAAA;AACxD,IAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,IAAM,KAAA,CAAA;AAAA,MACJ,SAAA,EAAW,CAAC,MAAA,EAAQ,UAAe,KAAA;AACjC,QAAA,KAAA,MAAW,KAAS,IAAA,SAAA,CAAU,QAAS,CAAA,MAAA,EAAQ,KAAK,CAAG,EAAA;AACrD,UAAA,UAAA,CAAW,QAAQ,KAAK,CAAA,CAAA;AAAA,SAC1B;AAAA,OACF;AAAA,MACA,KAAA,EAAO,CAAC,UAAe,KAAA;AACrB,QAAW,KAAA,MAAA,KAAA,IAAS,SAAU,CAAA,KAAA,EAAS,EAAA;AACrC,UAAA,UAAA,CAAW,QAAQ,KAAK,CAAA,CAAA;AAAA,SAC1B;AAAA,OACF;AAAA,KACD,CAAA,CAAA;AAAA,GACH;AACF;;;;"}
+{"version":3,"file":"RecordAssemblerTransformer.js","sources":["../../src/RecordAssemblerTransformer.ts"],"sourcesContent":["import { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type {\n  CSVRecord,\n  RecordAssemblerOptions,\n  Token,\n} from \"./common/types.ts\";\n\n/**\n * A transform stream that converts a stream of tokens into a stream of rows.\n * @template Header The type of the header row.\n * @param options The options for the parser.\n *\n * @category Low-level API\n *\n * @example Parse a CSV with headers by data\n *  ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"name,age\\r\\n\");\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.enqueue(\"Bob,25\\r\\n\");\n *     controller.enqueue(\"Charlie,30\\r\\n\");\n *     controller.close();\n *   })\n *   .pipeThrough(new LexerTransformer())\n *   .pipeThrough(new RecordAssemblerTransformer())\n *   .pipeTo(new WritableStream({ write(row) { console.log(row); }}));\n * // { name: \"Alice\", age: \"20\" }\n * // { name: \"Bob\", age: \"25\" }\n * // { name: \"Charlie\", age: \"30\" }\n * ```\n *\n * @example Parse a CSV with headers by options\n * ```ts\n * new ReadableStream({\n *   start(controller) {\n *     controller.enqueue(\"Alice,20\\r\\n\");\n *     controller.enqueue(\"Bob,25\\r\\n\");\n *     controller.enqueue(\"Charlie,30\\r\\n\");\n *     controller.close();\n *   }\n * })\n * .pipeThrough(new LexerTransformer())\n * .pipeThrough(new RecordAssemblerTransformer({ header: [\"name\", \"age\"] }))\n * .pipeTo(new WritableStream({ write(row) { console.log(row); }}));\n * // { name: \"Alice\", age: \"20\" }\n * // { name: \"Bob\", age: \"25\" }\n * // { name: \"Charlie\", age: \"30\" }\n * ```\n */\nexport class RecordAssemblerTransformer<\n  Header extends ReadonlyArray<string>,\n> extends TransformStream<Token[], CSVRecord<Header>> {\n  constructor(options: RecordAssemblerOptions<Header> = {}) {\n    const assembler = new RecordAssembler(options);\n    super({\n      transform: (tokens, controller) => {\n        for (const token of assembler.assemble(tokens, false)) {\n          controller.enqueue(token);\n        }\n      },\n      flush: (controller) => {\n        for (const token of assembler.flush()) {\n          controller.enqueue(token);\n        }\n      },\n    });\n  }\n}\n"],"names":[],"mappings":";;AAkDO,MAAM,mCAEH,eAA4C,CAAA;AAAA,EACpD,WAAA,CAAY,OAA0C,GAAA,EAAI,EAAA;AACxD,IAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,IAAM,KAAA,CAAA;AAAA,MACJ,SAAA,EAAW,CAAC,MAAA,EAAQ,UAAe,KAAA;AACjC,QAAA,KAAA,MAAW,KAAS,IAAA,SAAA,CAAU,QAAS,CAAA,MAAA,EAAQ,KAAK,CAAG,EAAA;AACrD,UAAA,UAAA,CAAW,QAAQ,KAAK,CAAA,CAAA;AAAA,SAC1B;AAAA,OACF;AAAA,MACA,KAAA,EAAO,CAAC,UAAe,KAAA;AACrB,QAAW,KAAA,MAAA,KAAA,IAAS,SAAU,CAAA,KAAA,EAAS,EAAA;AACrC,UAAA,UAAA,CAAW,QAAQ,KAAK,CAAA,CAAA;AAAA,SAC1B;AAAA,OACF;AAAA,KACD,CAAA,CAAA;AAAA,GACH;AACF;;;;"}

package/dist/es/_virtual/_web-csv-toolbox-wasm.js

@@ -81,6 +81,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         const ret = encodeString(arg, view);
 
         offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
 
     WASM_VECTOR_LEN = offset;

package/dist/es/_virtual/_web-csv-toolbox-wasm.js.map

@@ -1 +1 @@
-{"version":3,"file":"_web-csv-toolbox-wasm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"_web-csv-toolbox-wasm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}