web-csv-toolbox 0.5.2 → 0.6.0

package/dist/es/parseResponseToStream.js

@@ -0,0 +1,13 @@
+import { getOptionsFromResponse } from './getOptionsFromResponse.js';
+import { parseUint8ArrayStreamToStream } from './parseUint8ArrayStreamToStream.js';
+
+function parseResponseToStream(response, options) {
+  const options_ = getOptionsFromResponse(response, options);
+  if (response.body === null) {
+    throw new Error("Response body is null");
+  }
+  return parseUint8ArrayStreamToStream(response.body, options_);
+}
+
+export { parseResponseToStream };
+//# sourceMappingURL=parseResponseToStream.js.map

package/dist/es/parseResponseToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseResponseToStream.js","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":[],"mappings":";;;AAIgB,SAAA,qBAAA,CACd,UACA,OACmC,EAAA;AACnC,EAAM,MAAA,QAAA,GAAW,sBAAuB,CAAA,QAAA,EAAU,OAAO,CAAA,CAAA;AACzD,EAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,IAAM,MAAA,IAAI,MAAM,uBAAuB,CAAA,CAAA;AAAA,GACzC;AACA,EAAO,OAAA,6BAAA,CAA8B,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAC9D;;;;"}

package/dist/es/parseString.js

@@ -0,0 +1,33 @@
+import { parseStringToArraySync } from './parseStringToArraySync.js';
+import { parseStringToIterableIterator } from './parseStringToIterableIterator.js';
+import { parseStringToStream } from './parseStringToStream.js';
+import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
+
+async function* parseString(csv, options) {
+  yield* parseStringToIterableIterator(csv, options);
+}
+Object.defineProperties(parseString, {
+  toArray: {
+    enumerable: true,
+    writable: false,
+    value: convertThisAsyncIterableIteratorToArray
+  },
+  toArraySync: {
+    enumerable: true,
+    writable: false,
+    value: parseStringToArraySync
+  },
+  toIterableIterator: {
+    enumerable: true,
+    writable: false,
+    value: parseStringToIterableIterator
+  },
+  toStream: {
+    enumerable: true,
+    writable: false,
+    value: parseStringToStream
+  }
+});
+
+export { parseString };
+//# sourceMappingURL=parseString.js.map

package/dist/es/parseString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseString.js","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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;AAgCuB,gBAAA,WAAA,CACrB,KACA,OAC0C,EAAA;AAC1C,EAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA,CAAA;AACnD,CAAA;AAyGA,MAAA,CAAO,iBAAiB,WAAa,EAAA;AAAA,EACnC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,WAAa,EAAA;AAAA,IACX,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,sBAAA;AAAA,GACT;AAAA,EACA,kBAAoB,EAAA;AAAA,IAClB,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,6BAAA;AAAA,GACT;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,mBAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}

package/dist/es/parseStringStream.js

@@ -0,0 +1,23 @@
+import { parseStringStreamToStream } from './parseStringStreamToStream.js';
+import { convertStreamToAsyncIterableIterator } from './utils/convertStreamToAsyncIterableIterator.js';
+import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
+
+function parseStringStream(stream, options) {
+  const recordStream = parseStringStreamToStream(stream, options);
+  return convertStreamToAsyncIterableIterator(recordStream);
+}
+Object.defineProperties(parseStringStream, {
+  toArray: {
+    enumerable: true,
+    writable: false,
+    value: convertThisAsyncIterableIteratorToArray
+  },
+  toStream: {
+    enumerable: true,
+    writable: false,
+    value: parseStringStreamToStream
+  }
+});
+
+export { parseStringStream };
+//# sourceMappingURL=parseStringStream.js.map

package/dist/es/parseStringStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseStringStream.js","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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;AAuCgB,SAAA,iBAAA,CACd,QACA,OAC0C,EAAA;AAC1C,EAAM,MAAA,YAAA,GAAe,yBAA0B,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AAC9D,EAAA,OAAO,qCAAqC,YAAY,CAAA,CAAA;AAC1D,CAAA;AAuEA,MAAA,CAAO,iBAAiB,iBAAmB,EAAA;AAAA,EACzC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,yBAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}

package/dist/es/parseStringStreamToStream.js

@@ -0,0 +1,14 @@
+import { LexerTransformer } from './LexerTransformer.js';
+import { RecordAssemblerTransformer } from './RecordAssemblerTransformer.js';
+import { pipeline } from './utils/pipeline.js';
+
+function parseStringStreamToStream(stream, options) {
+  return pipeline(
+    stream,
+    new LexerTransformer(options),
+    new RecordAssemblerTransformer(options)
+  );
+}
+
+export { parseStringStreamToStream };
+//# sourceMappingURL=parseStringStreamToStream.js.map

package/dist/es/parseStringStreamToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseStringStreamToStream.js","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":[],"mappings":";;;;AAKgB,SAAA,yBAAA,CACd,QACA,OACmC,EAAA;AACnC,EAAO,OAAA,QAAA;AAAA,IACL,MAAA;AAAA,IACA,IAAI,iBAAiB,OAAO,CAAA;AAAA,IAC5B,IAAI,2BAA2B,OAAO,CAAA;AAAA,GACxC,CAAA;AACF;;;;"}

package/dist/es/parseStringToArraySync.js

@@ -0,0 +1,12 @@
+import { Lexer } from './Lexer.js';
+import { RecordAssembler } from './RecordAssembler.js';
+
+function parseStringToArraySync(csv, options) {
+  const lexer = new Lexer(options);
+  const assembler = new RecordAssembler(options);
+  const tokens = lexer.lex(csv);
+  return [...assembler.assemble(tokens)];
+}
+
+export { parseStringToArraySync };
+//# sourceMappingURL=parseStringToArraySync.js.map

package/dist/es/parseStringToArraySync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseStringToArraySync.js","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":[],"mappings":";;;AAIgB,SAAA,sBAAA,CACd,KACA,OACqB,EAAA;AACrB,EAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,EAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,EAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,EAAA,OAAO,CAAC,GAAG,SAAU,CAAA,QAAA,CAAS,MAAM,CAAC,CAAA,CAAA;AACvC;;;;"}

package/dist/es/parseStringToIterableIterator.js

@@ -0,0 +1,12 @@
+import { Lexer } from './Lexer.js';
+import { RecordAssembler } from './RecordAssembler.js';
+
+function parseStringToIterableIterator(csv, options) {
+  const lexer = new Lexer(options);
+  const assembler = new RecordAssembler(options);
+  const tokens = lexer.lex(csv);
+  return assembler.assemble(tokens);
+}
+
+export { parseStringToIterableIterator };
+//# sourceMappingURL=parseStringToIterableIterator.js.map

package/dist/es/parseStringToIterableIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseStringToIterableIterator.js","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":[],"mappings":";;;AAIgB,SAAA,6BAAA,CAGd,KACA,OACqC,EAAA;AACrC,EAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,EAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,EAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,EAAO,OAAA,SAAA,CAAU,SAAS,MAAM,CAAA,CAAA;AAClC;;;;"}

package/dist/es/parseStringToStream.js

@@ -0,0 +1,19 @@
+import { Lexer } from './Lexer.js';
+import { RecordAssembler } from './RecordAssembler.js';
+
+function parseStringToStream(csv, options) {
+  const lexer = new Lexer(options);
+  const assembler = new RecordAssembler(options);
+  return new ReadableStream({
+    start(controller) {
+      const tokens = lexer.lex(csv);
+      for (const record of assembler.assemble(tokens)) {
+        controller.enqueue(record);
+      }
+      controller.close();
+    }
+  });
+}
+
+export { parseStringToStream };
+//# sourceMappingURL=parseStringToStream.js.map

package/dist/es/parseStringToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseStringToStream.js","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":[],"mappings":";;;AAIgB,SAAA,mBAAA,CACd,KACA,OACmC,EAAA;AACnC,EAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,EAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,EAAA,OAAO,IAAI,cAAe,CAAA;AAAA,IACxB,MAAM,UAAY,EAAA;AAChB,MAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,MAAA,KAAA,MAAW,MAAU,IAAA,SAAA,CAAU,QAAS,CAAA,MAAM,CAAG,EAAA;AAC/C,QAAA,UAAA,CAAW,QAAQ,MAAM,CAAA,CAAA;AAAA,OAC3B;AACA,MAAA,UAAA,CAAW,KAAM,EAAA,CAAA;AAAA,KACnB;AAAA,GACD,CAAA,CAAA;AACH;;;;"}

package/dist/es/parseUint8ArrayStream.js

@@ -0,0 +1,23 @@
+import { parseUint8ArrayStreamToStream } from './parseUint8ArrayStreamToStream.js';
+import { convertStreamToAsyncIterableIterator } from './utils/convertStreamToAsyncIterableIterator.js';
+import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
+
+function parseUint8ArrayStream(stream, options) {
+  const recordStream = parseUint8ArrayStreamToStream(stream, options);
+  return convertStreamToAsyncIterableIterator(recordStream);
+}
+Object.defineProperties(parseUint8ArrayStream, {
+  toArray: {
+    enumerable: true,
+    writable: false,
+    value: convertThisAsyncIterableIteratorToArray
+  },
+  toStream: {
+    enumerable: true,
+    writable: false,
+    value: parseUint8ArrayStreamToStream
+  }
+});
+
+export { parseUint8ArrayStream };
+//# sourceMappingURL=parseUint8ArrayStream.js.map

package/dist/es/parseUint8ArrayStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseUint8ArrayStream.js","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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;AAwCgB,SAAA,qBAAA,CACd,QACA,OAC0C,EAAA;AAC1C,EAAM,MAAA,YAAA,GAAe,6BAA8B,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AAClE,EAAA,OAAO,qCAAqC,YAAY,CAAA,CAAA;AAC1D,CAAA;AAkEA,MAAA,CAAO,iBAAiB,qBAAuB,EAAA;AAAA,EAC7C,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,6BAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}

package/dist/es/parseUint8ArrayStreamToStream.js

@@ -0,0 +1,22 @@
+import { LexerTransformer } from './LexerTransformer.js';
+import { RecordAssemblerTransformer } from './RecordAssemblerTransformer.js';
+import { pipeline } from './utils/pipeline.js';
+
+function parseUint8ArrayStreamToStream(stream, options) {
+  const { charset, fatal, ignoreBOM, decomposition } = options ?? {};
+  return decomposition ? pipeline(
+    stream,
+    new DecompressionStream(decomposition),
+    new TextDecoderStream(charset, { fatal, ignoreBOM }),
+    new LexerTransformer(options),
+    new RecordAssemblerTransformer(options)
+  ) : pipeline(
+    stream,
+    new TextDecoderStream(charset, { fatal, ignoreBOM }),
+    new LexerTransformer(options),
+    new RecordAssemblerTransformer(options)
+  );
+}
+
+export { parseUint8ArrayStreamToStream };
+//# sourceMappingURL=parseUint8ArrayStreamToStream.js.map

package/dist/es/parseUint8ArrayStreamToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseUint8ArrayStreamToStream.js","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":[],"mappings":";;;;AAKgB,SAAA,6BAAA,CACd,QACA,OACmC,EAAA;AACnC,EAAA,MAAM,EAAE,OAAS,EAAA,KAAA,EAAO,WAAW,aAAc,EAAA,GAAI,WAAW,EAAC,CAAA;AACjE,EAAA,OAAO,aACH,GAAA,QAAA;AAAA,IACE,MAAA;AAAA,IACA,IAAI,oBAAoB,aAAa,CAAA;AAAA,IACrC,IAAI,iBAAkB,CAAA,OAAA,EAAS,EAAE,KAAA,EAAO,WAAW,CAAA;AAAA,IACnD,IAAI,iBAAiB,OAAO,CAAA;AAAA,IAC5B,IAAI,2BAA2B,OAAO,CAAA;AAAA,GAExC,GAAA,QAAA;AAAA,IACE,MAAA;AAAA,IACA,IAAI,iBAAkB,CAAA,OAAA,EAAS,EAAE,KAAA,EAAO,WAAW,CAAA;AAAA,IACnD,IAAI,iBAAiB,OAAO,CAAA;AAAA,IAC5B,IAAI,2BAA2B,OAAO,CAAA;AAAA,GACxC,CAAA;AACN;;;;"}

package/dist/es/utils/convertIterableIteratorToAsync.js

@@ -0,0 +1,14 @@
+function convertIterableIteratorToAsync(iterator) {
+  return {
+    async next() {
+      const result = iterator.next();
+      return Promise.resolve(result);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+
+export { convertIterableIteratorToAsync };
+//# sourceMappingURL=convertIterableIteratorToAsync.js.map

package/dist/es/utils/convertIterableIteratorToAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertIterableIteratorToAsync.js","sources":["../../../src/utils/convertIterableIteratorToAsync.ts"],"sourcesContent":["export function convertIterableIteratorToAsync<T>(\n  iterator: IterableIterator<T>,\n): AsyncIterableIterator<T> {\n  return {\n    async next() {\n      const result = iterator.next();\n      return Promise.resolve(result);\n    },\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n  };\n}\n"],"names":[],"mappings":"AAAO,SAAS,+BACd,QAC0B,EAAA;AAC1B,EAAO,OAAA;AAAA,IACL,MAAM,IAAO,GAAA;AACX,MAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA,CAAA;AAC7B,MAAO,OAAA,OAAA,CAAQ,QAAQ,MAAM,CAAA,CAAA;AAAA,KAC/B;AAAA,IACA,CAAC,MAAO,CAAA,aAAa,CAAI,GAAA;AACvB,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAAA,GACF,CAAA;AACF;;;;"}

package/dist/es/utils/convertStreamToAsyncIterableIterator.js

@@ -0,0 +1,12 @@
+async function* convertStreamToAsyncIterableIterator(stream) {
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    yield value;
+  }
+}
+
+export { convertStreamToAsyncIterableIterator };
+//# sourceMappingURL=convertStreamToAsyncIterableIterator.js.map

package/dist/es/utils/convertStreamToAsyncIterableIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertStreamToAsyncIterableIterator.js","sources":["../../../src/utils/convertStreamToAsyncIterableIterator.ts"],"sourcesContent":["export async function* convertStreamToAsyncIterableIterator<T>(\n  stream: ReadableStream<T>,\n): AsyncIterableIterator<T> {\n  const reader = stream.getReader();\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    yield value;\n  }\n}\n"],"names":[],"mappings":"AAAA,gBAAuB,qCACrB,MAC0B,EAAA;AAC1B,EAAM,MAAA,MAAA,GAAS,OAAO,SAAU,EAAA,CAAA;AAChC,EAAA,OAAO,IAAM,EAAA;AACX,IAAA,MAAM,EAAE,IAAM,EAAA,KAAA,EAAU,GAAA,MAAM,OAAO,IAAK,EAAA,CAAA;AAC1C,IAAI,IAAA,IAAA;AAAM,MAAA,MAAA;AACV,IAAM,MAAA,KAAA,CAAA;AAAA,GACR;AACF;;;;"}

package/dist/es/utils/convertThisAsyncIterableIteratorToArray.js

@@ -0,0 +1,10 @@
+async function convertThisAsyncIterableIteratorToArray(...args) {
+  const rows = [];
+  for await (const row of this(...args)) {
+    rows.push(row);
+  }
+  return rows;
+}
+
+export { convertThisAsyncIterableIteratorToArray };
+//# sourceMappingURL=convertThisAsyncIterableIteratorToArray.js.map

package/dist/es/utils/convertThisAsyncIterableIteratorToArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertThisAsyncIterableIteratorToArray.js","sources":["../../../src/utils/convertThisAsyncIterableIteratorToArray.ts"],"sourcesContent":["export async function convertThisAsyncIterableIteratorToArray<\n  O,\n  T extends (...args: any[]) => AsyncGenerator<O>,\n>(this: T, ...args: Parameters<T>): Promise<O[]> {\n  const rows: O[] = [];\n  for await (const row of this(...args)) {\n    rows.push(row);\n  }\n  return rows;\n}\n"],"names":[],"mappings":"AAAA,eAAsB,2CAGR,IAAmC,EAAA;AAC/C,EAAA,MAAM,OAAY,EAAC,CAAA;AACnB,EAAA,WAAA,MAAiB,GAAO,IAAA,IAAA,CAAK,GAAG,IAAI,CAAG,EAAA;AACrC,IAAA,IAAA,CAAK,KAAK,GAAG,CAAA,CAAA;AAAA,GACf;AACA,EAAO,OAAA,IAAA,CAAA;AACT;;;;"}

package/dist/es/utils/escapeRegExp.js

@@ -0,0 +1,6 @@
+function escapeRegExp(v) {
+  return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { escapeRegExp };
+//# sourceMappingURL=escapeRegExp.js.map

package/dist/es/utils/escapeRegExp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escapeRegExp.js","sources":["../../../src/utils/escapeRegExp.ts"],"sourcesContent":["/**\n * Escape a string for use in a regular expression.\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping Regular expressions#Escaping | MDN}\n * @param v string to escape\n * @returns escaped string\n */\nexport function escapeRegExp(v: string) {\n  return v.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n"],"names":[],"mappings":"AAOO,SAAS,aAAa,CAAW,EAAA;AACtC,EAAO,OAAA,CAAA,CAAE,OAAQ,CAAA,qBAAA,EAAuB,MAAM,CAAA,CAAA;AAChD;;;;"}

package/dist/es/utils/parseMime.js

@@ -0,0 +1,15 @@
+function parseMime(contentType) {
+  const [type, ...parameters] = contentType.split(";");
+  const result = {
+    type: type.trim(),
+    parameters: {}
+  };
+  for (const paramator of parameters) {
+    const [key, value] = paramator.split("=");
+    result.parameters[key.trim()] = value.trim();
+  }
+  return result;
+}
+
+export { parseMime };
+//# sourceMappingURL=parseMime.js.map

package/dist/es/utils/parseMime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseMime.js","sources":["../../../src/utils/parseMime.ts"],"sourcesContent":["export interface ParseMimeResult {\n  type: string;\n  parameters: {\n    [key: string]: string;\n  };\n}\n\nexport function parseMime(contentType: string) {\n  const [type, ...parameters] = contentType.split(\";\");\n  const result: ParseMimeResult = {\n    type: type.trim(),\n    parameters: {},\n  };\n  for (const paramator of parameters) {\n    const [key, value] = paramator.split(\"=\");\n    result.parameters[key.trim()] = value.trim();\n  }\n  return result;\n}\n"],"names":[],"mappings":"AAOO,SAAS,UAAU,WAAqB,EAAA;AAC7C,EAAA,MAAM,CAAC,IAAM,EAAA,GAAG,UAAU,CAAI,GAAA,WAAA,CAAY,MAAM,GAAG,CAAA,CAAA;AACnD,EAAA,MAAM,MAA0B,GAAA;AAAA,IAC9B,IAAA,EAAM,KAAK,IAAK,EAAA;AAAA,IAChB,YAAY,EAAC;AAAA,GACf,CAAA;AACA,EAAA,KAAA,MAAW,aAAa,UAAY,EAAA;AAClC,IAAA,MAAM,CAAC,GAAK,EAAA,KAAK,CAAI,GAAA,SAAA,CAAU,MAAM,GAAG,CAAA,CAAA;AACxC,IAAA,MAAA,CAAO,WAAW,GAAI,CAAA,IAAA,EAAM,CAAA,GAAI,MAAM,IAAK,EAAA,CAAA;AAAA,GAC7C;AACA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

package/dist/es/utils/pipeline.js

@@ -0,0 +1,18 @@
+function pipeline(stream, ...transformers) {
+  return new ReadableStream({
+    start: (controller) => {
+      (() => transformers.reduce(
+        (stream2, transformer) => stream2.pipeThrough(transformer),
+        stream
+      ).pipeTo(
+        new WritableStream({
+          write: (v) => controller.enqueue(v),
+          close: () => controller.close()
+        })
+      ))();
+    }
+  });
+}
+
+export { pipeline };
+//# sourceMappingURL=pipeline.js.map

package/dist/es/utils/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sources":["../../../src/utils/pipeline.ts"],"sourcesContent":["export function pipeline<I, T, O>(\n  stream: ReadableStream<I>,\n  transformer1: TransformStream<I, T>,\n  transformer2: TransformStream<T, O>,\n): ReadableStream<O>;\nexport function pipeline<I, T1, T2, O>(\n  stream: ReadableStream<I>,\n  transformer1: TransformStream<I, T1>,\n  transformer2: TransformStream<T1, T2>,\n  transformer3: TransformStream<T2, O>,\n): ReadableStream<O>;\nexport function pipeline<I, T1, T2, T3, O>(\n  stream: ReadableStream<I>,\n  transformer1: TransformStream<I, T1>,\n  transformer2: TransformStream<T1, T2>,\n  transformer3: TransformStream<T2, T3>,\n  transformer4: TransformStream<T3, O>,\n): ReadableStream<O>;\nexport function pipeline<I, O>(\n  stream: ReadableStream<I>,\n  ...transformers: TransformStream[]\n): ReadableStream<O> {\n  return new ReadableStream({\n    start: (controller) => {\n      (() =>\n        transformers\n          .reduce<ReadableStream>(\n            (stream, transformer) => stream.pipeThrough(transformer),\n            stream,\n          )\n          .pipeTo(\n            new WritableStream({\n              write: (v) => controller.enqueue(v),\n              close: () => controller.close(),\n            }),\n          ))();\n    },\n  });\n}\n"],"names":["stream"],"mappings":"AAkBgB,SAAA,QAAA,CACd,WACG,YACgB,EAAA;AACnB,EAAA,OAAO,IAAI,cAAe,CAAA;AAAA,IACxB,KAAA,EAAO,CAAC,UAAe,KAAA;AACrB,MAAA,CAAC,MACC,YACG,CAAA,MAAA;AAAA,QACC,CAACA,OAAAA,EAAQ,WAAgBA,KAAAA,OAAAA,CAAO,YAAY,WAAW,CAAA;AAAA,QACvD,MAAA;AAAA,OAED,CAAA,MAAA;AAAA,QACC,IAAI,cAAe,CAAA;AAAA,UACjB,KAAO,EAAA,CAAC,CAAM,KAAA,UAAA,CAAW,QAAQ,CAAC,CAAA;AAAA,UAClC,KAAA,EAAO,MAAM,UAAA,CAAW,KAAM,EAAA;AAAA,SAC/B,CAAA;AAAA,OACA,GAAA,CAAA;AAAA,KACT;AAAA,GACD,CAAA,CAAA;AACH;;;;"}

package/dist/es/web-csv-toolbox.js

@@ -0,0 +1,10 @@
+export { Field, FieldDelimiter, RecordDelimiter } from './common/constants.js';
+export { LexerTransformer } from './LexerTransformer.js';
+export { RecordAssemblerTransformer } from './RecordAssemblerTransformer.js';
+export { parseString } from './parseString.js';
+export { parseBinary } from './parseBinary.js';
+export { parseUint8ArrayStream } from './parseUint8ArrayStream.js';
+export { parseStringStream } from './parseStringStream.js';
+export { parseResponse } from './parseResponse.js';
+export { parse } from './parse.js';
+//# sourceMappingURL=web-csv-toolbox.js.map

package/dist/es/web-csv-toolbox.js.map

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

package/dist/types/Lexer.d.ts

@@ -0,0 +1,7 @@
+import { CommonOptions, Token } from "./common/types.ts";
+export declare class Lexer {
+    #private;
+    constructor({ delimiter, quotation, }?: CommonOptions);
+    lex(chunk: string | null, buffering?: boolean): IterableIterator<Token>;
+    flush(): Token[];
+}

package/dist/types/LexerTransformer.d.ts

@@ -0,0 +1,34 @@
+import { CommonOptions, Token } from "./common/types.ts";
+/**
+ * A transform stream that converts a stream of tokens into a stream of rows.
+ *
+ * @category Low-level API
+ *
+ * @example Parse a CSV with headers by data
+ * ```ts
+ * new ReadableStream({
+ *   start(controller) {
+ *     controller.enqueue("name,age\r\n");
+ *     controller.enqueue("Alice,20\r\n");
+ *     controller.close();
+ *   }
+ * })
+ *   .pipeThrough(new LexerTransformer())
+ *   .pipeTo(new WritableStream({ write(tokens) {
+ *     for (const token of tokens) {
+ *       console.log(token);
+ *     }
+ *   }}));
+ * // { type: Field, value: "name" }
+ * // FieldDelimiter
+ * // { type: Field, value: "age" }
+ * // RecordDelimiter
+ * // { type: Field, value: "Alice" }
+ * // FieldDelimiter
+ * // { type: Field, value: "20" }
+ * // RecordDelimiter
+ * ```
+ */
+export declare class LexerTransformer extends TransformStream<string, Token[]> {
+    constructor(options?: CommonOptions);
+}

package/dist/types/RecordAssembler.d.ts

@@ -0,0 +1,7 @@
+import { CSVRecord, RecordAssemblerOptions, Token } from "./common/types.ts";
+export declare class RecordAssembler<Header extends ReadonlyArray<string>> {
+    #private;
+    constructor(options?: RecordAssemblerOptions<Header>);
+    assemble(tokens: Iterable<Token>, flush?: boolean): IterableIterator<CSVRecord<Header>>;
+    flush(): Generator<CSVRecord<Header>>;
+}

package/dist/types/RecordAssemblerTransformer.d.ts

@@ -0,0 +1,47 @@
+import { CSVRecord, RecordAssemblerOptions, Token } from "./common/types.ts";
+/**
+ * A transform stream that converts a stream of tokens into a stream of rows.
+ * @template Header The type of the header row.
+ * @param options The options for the parser.
+ *
+ * @category Low-level API
+ *
+ * @example Parse a CSV with headers by data
+ *  ```ts
+ * new ReadableStream({
+ *   start(controller) {
+ *     controller.enqueue("name,age\r\n");
+ *     controller.enqueue("Alice,20\r\n");
+ *     controller.enqueue("Bob,25\r\n");
+ *     controller.enqueue("Charlie,30\r\n");
+ *     controller.close();
+ *   })
+ *   .pipeThrough(new LexerTransformer())
+ *   .pipeThrough(new RecordAssemblerTransformer())
+ *   .pipeTo(new WritableStream({ write(row) { console.log(row); }}));
+ * // { name: "Alice", age: "20" }
+ * // { name: "Bob", age: "25" }
+ * // { name: "Charlie", age: "30" }
+ * ```
+ *
+ * @example Parse a CSV with headers by options
+ * ```ts
+ * new ReadableStream({
+ *   start(controller) {
+ *     controller.enqueue("Alice,20\r\n");
+ *     controller.enqueue("Bob,25\r\n");
+ *     controller.enqueue("Charlie,30\r\n");
+ *     controller.close();
+ *   }
+ * })
+ * .pipeThrough(new LexerTransformer())
+ * .pipeThrough(new RecordAssemblerTransformer({ header: ["name", "age"] }))
+ * .pipeTo(new WritableStream({ write(row) { console.log(row); }}));
+ * // { name: "Alice", age: "20" }
+ * // { name: "Bob", age: "25" }
+ * // { name: "Charlie", age: "30" }
+ * ```
+ */
+export declare class RecordAssemblerTransformer<Header extends ReadonlyArray<string>> extends TransformStream<Token[], CSVRecord<Header>> {
+    constructor(options?: RecordAssemblerOptions<Header>);
+}

package/dist/types/assertCommonOptions.d.ts

@@ -0,0 +1,7 @@
+import { CommonOptions } from "./common/types.ts";
+/**
+ * Assert that the options are valid.
+ *
+ * @param options The options to assert.
+ */
+export declare function assertCommonOptions(options: Required<CommonOptions>): void;

package/dist/types/common/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * FiledDelimiter is a symbol for field delimiter of CSV.
+ * @category Constants
+ */
+export declare const FieldDelimiter: unique symbol;
+/**
+ * RecordDelimiter is a symbol for record delimiter of CSV.
+ * @category Constants
+ */
+export declare const RecordDelimiter: unique symbol;
+/**
+ * Field is a symbol for field of CSV.
+ * @category Constants
+ */
+export declare const Field: unique symbol;