web-csv-toolbox 0.0.0-next-20240116142901 → 0.0.0-next-20240116161004

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;

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

@@ -0,0 +1,163 @@
+import { Field, FieldDelimiter, RecordDelimiter } from "./constants.ts";
+/**
+ * Field token type.
+ * @category Types
+ */
+export interface FieldToken {
+    type: typeof Field;
+    value: string;
+}
+/**
+ * Token is a atomic unit of a CSV file.
+ * It can be a field, field delimiter, or record delimiter.
+ * @category Types
+ */
+export type Token = FieldToken | typeof FieldDelimiter | typeof RecordDelimiter;
+/**
+ * CSV Common Options.
+ * @category Types
+ */
+export interface CommonOptions {
+    /**
+     * CSV field delimiter.
+     *
+     * @remarks
+     * If you want to parse TSV, specify `'\t'`.
+     *
+     * This library supports multi-character delimiters.
+     * @default ','
+     */
+    delimiter?: string;
+    /**
+     * CSV field quotation.
+     *
+     * @remarks
+     * This library supports multi-character quotations.
+     *
+     * @default '"'
+     */
+    quotation?: string;
+}
+/**
+ * CSV Parsing Options for binary.
+ * @category Types
+ */
+export interface BinaryOptions {
+    /**
+     * If the binary is compressed by a compression algorithm,
+     * the decompressed CSV can be parsed by specifying the algorithm.
+     *
+     * @remarks
+     * Make sure the runtime you are running supports stream decompression.
+     *
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream#browser_compatibility | DecompressionStream Compatibility}.
+     */
+    decomposition?: CompressionFormat;
+    /**
+     * You can specify the character encoding of the binary.
+     *
+     * @remarks
+     * {@link !TextDecoderStream} is used internally.
+     *
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API/Encodings | Encoding API Compatibility}
+     * for the encoding formats that can be specified.
+     *
+     * @default 'utf-8'
+     */
+    charset?: string;
+    /**
+     * If the binary has a BOM, you can specify whether to ignore it.
+     *
+     * @remarks
+     * If you specify true, the BOM will be ignored.
+     * If you specify false or not specify it, the BOM will be treated as a normal character.
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/TextDecoderStream/ignoreBOM | TextDecoderOptions.ignoreBOM} for more information about the BOM.
+     * @default false
+     */
+    ignoreBOM?: boolean;
+    /**
+     * If the binary has a invalid character, you can specify whether to throw an error.
+     *
+     * @remarks
+     * If the property is `true` then a decoder will throw a {@link !TypeError}
+     * if it encounters malformed data while decoding.
+     *
+     * If `false` the decoder will substitute the invalid data
+     * with the replacement character `U+FFFD` (�).
+     *
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/TextDecoderStream/fatal | TextDecoderOptions.fatal} for more information.
+     *
+     * @default false
+     */
+    fatal?: boolean;
+}
+/**
+ * Record Assembler Options for CSV.
+ * @category Types
+ *
+ * @remarks
+ * If you specify `header: ['foo', 'bar']`,
+ * the first record will be treated as a normal record.
+ *
+ * If you don't specify `header`,
+ * the first record will be treated as a header.
+ */
+export interface RecordAssemblerOptions<Header extends ReadonlyArray<string>> {
+    /**
+     * CSV header.
+     *
+     * @remarks
+     * If you specify this option,
+     * the first record will be treated as a normal record.
+     *
+     * If you don't specify this option,
+     * the first record will be treated as a header.
+     *
+     * @default undefined
+     */
+    header?: Header;
+}
+/**
+ * Parse options for CSV string.
+ * @category Types
+ */
+export interface ParseOptions<Header extends ReadonlyArray<string>> extends CommonOptions, RecordAssemblerOptions<Header> {
+}
+/**
+ * Parse options for CSV binary.
+ * @category Types
+ */
+export interface ParseBinaryOptions<Header extends ReadonlyArray<string>> extends ParseOptions<Header>, BinaryOptions {
+}
+/**
+ * CSV Record.
+ * @category Types
+ * @template Header Header of the CSV.
+ *
+ * @example Header is ["foo", "bar"]
+ * ```ts
+ * const record: CSVRecord<["foo", "bar"]> = {
+ *   foo: "1",
+ *   bar: "2",
+ * };
+ * ```
+ */
+export type CSVRecord<Header extends ReadonlyArray<string>> = Record<Header[number], string>;
+/**
+ * CSV String.
+ *
+ * @category Types
+ */
+export type CSVString = string | ReadableStream<string>;
+/**
+ * CSV Binary.
+ *
+ * @category Types
+ */
+export type CSVBinary = ReadableStream<Uint8Array> | Response | ArrayBuffer | Uint8Array;
+/**
+ * CSV.
+ *
+ * @category Types
+ */
+export type CSV = CSVString | CSVBinary;

package/dist/types/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const CR = "\r";
+export declare const CRLF = "\r\n";
+export declare const LF = "\n";
+/**
+ * COMMA is a symbol for comma(,).
+ */
+export declare const COMMA = ",";
+/**
+ * DOUBLE_QUOTE is a symbol for double quote(").
+ */
+export declare const DOUBLE_QUOTE = "\"";

package/dist/types/convertBinaryToString.d.ts

@@ -0,0 +1,2 @@
+import { ParseBinaryOptions } from "./common/types.ts";
+export declare function convertBinaryToString<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options: ParseBinaryOptions<Header>): string;

package/dist/types/escapeField.d.ts

@@ -0,0 +1,13 @@
+import { CommonOptions } from "./common/types.ts";
+export interface EscapeFieldOptions extends CommonOptions {
+    quote?: true;
+}
+/**
+ * Escape the field.
+ *
+ * DO NOT USE THIS FUNCTION BEFORE ASSTPTED BY `{@link assertCommonOptions}`.
+ * @param value The field value to escape.
+ * @param options The options.
+ * @returns The escaped field.
+ */
+export declare function escapeField(value: string, { quotation, delimiter, quote, }?: EscapeFieldOptions): string;

package/dist/types/getOptionsFromResponse.d.ts

@@ -0,0 +1,2 @@
+import { ParseBinaryOptions } from "./common/types.ts";
+export declare function getOptionsFromResponse<Header extends ReadonlyArray<string>>(response: Response, options?: ParseBinaryOptions<Header>): ParseBinaryOptions<Header>;