web-csv-toolbox 0.13.0-next-7d51d5285be9cffa5103de58469d8de0c98959d7 → 0.13.0-next-b21b6d89a7a3f18dcbf79ec04ffefde0d7ff4c4c

package/dist/getOptionsFromResponse.js

@@ -1,10 +1,6 @@
+import { SUPPORTED_COMPRESSIONS } from './getOptionsFromResponse.constants.web.js';
 import { parseMime } from './utils/parseMime.js';
 
-const SUPPORTED_COMPRESSIONS = /* @__PURE__ */ new Set([
-  "gzip",
-  "deflate",
-  "deflate-raw"
-]);
 function getOptionsFromResponse(response, options = {}) {
   const { headers } = response;
   const contentType = headers.get("content-type") ?? "text/csv";
@@ -13,7 +9,7 @@ function getOptionsFromResponse(response, options = {}) {
     throw new TypeError(`Invalid mime type: "${contentType}"`);
   }
   const contentEncoding = headers.get("content-encoding");
-  let decomposition;
+  let decompression;
   if (contentEncoding) {
     const normalizedEncoding = contentEncoding.trim().toLowerCase();
     if (normalizedEncoding.includes(",")) {
@@ -22,10 +18,10 @@ function getOptionsFromResponse(response, options = {}) {
       );
     }
     if (SUPPORTED_COMPRESSIONS.has(normalizedEncoding)) {
-      decomposition = normalizedEncoding;
+      decompression = normalizedEncoding;
     } else if (normalizedEncoding) {
       if (options.allowExperimentalCompressions) {
-        decomposition = normalizedEncoding;
+        decompression = normalizedEncoding;
       } else {
         throw new TypeError(
           `Unsupported content-encoding: "${contentEncoding}". Supported formats: ${Array.from(SUPPORTED_COMPRESSIONS).join(", ")}. To use experimental formats, set allowExperimentalCompressions: true`
@@ -35,7 +31,7 @@ function getOptionsFromResponse(response, options = {}) {
   }
   const charset = mime.parameters.charset ?? "utf-8";
   return {
-    decomposition,
+    decompression,
     charset,
     ...options
   };

package/dist/getOptionsFromResponse.js.map

@@ -1 +1 @@
-{"version":3,"file":"getOptionsFromResponse.js","sources":["../src/getOptionsFromResponse.ts"],"sourcesContent":["import type { ParseBinaryOptions } from \"./common/types.ts\";\nimport { parseMime } from \"./utils/parseMime.ts\";\n\n/**\n * Supported compression formats for CSV decompression.\n * These correspond to the Web Standard CompressionFormat values.\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CompressionFormat | CompressionFormat}\n */\nconst SUPPORTED_COMPRESSIONS: ReadonlySet<CompressionFormat> = new Set([\n  \"gzip\",\n  \"deflate\",\n  \"deflate-raw\",\n]);\n\n/**\n * Extracts the options from the response object.\n *\n * @param response - The response object from which to extract the options.\n * @param options - The options to merge with the extracted options.\n * @returns The options extracted from the response.\n * @throws {TypeError} - The content type is not supported or the content-encoding is invalid.\n */\nexport function getOptionsFromResponse<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options: ParseBinaryOptions<Header> = {},\n): ParseBinaryOptions<Header> {\n  const { headers } = response;\n  const contentType = headers.get(\"content-type\") ?? \"text/csv\";\n  const mime = parseMime(contentType);\n  if (mime.type !== \"text/csv\") {\n    throw new TypeError(`Invalid mime type: \"${contentType}\"`);\n  }\n\n  const contentEncoding = headers.get(\"content-encoding\");\n  let decomposition: CompressionFormat | undefined;\n\n  if (contentEncoding) {\n    const normalizedEncoding = contentEncoding.trim().toLowerCase();\n\n    if (normalizedEncoding.includes(\",\")) {\n      throw new TypeError(\n        `Multiple content-encodings are not supported: \"${contentEncoding}\"`,\n      );\n    }\n\n    if (SUPPORTED_COMPRESSIONS.has(normalizedEncoding as CompressionFormat)) {\n      decomposition = normalizedEncoding as CompressionFormat;\n    } else if (normalizedEncoding) {\n      // Unknown compression format\n      if (options.allowExperimentalCompressions) {\n        // Allow runtime to handle experimental/future formats\n        decomposition = normalizedEncoding as CompressionFormat;\n      } else {\n        throw new TypeError(\n          `Unsupported content-encoding: \"${contentEncoding}\". Supported formats: ${Array.from(SUPPORTED_COMPRESSIONS).join(\", \")}. To use experimental formats, set allowExperimentalCompressions: true`,\n        );\n      }\n    }\n  }\n\n  const charset = mime.parameters.charset ?? \"utf-8\";\n  // TODO: Support header=present and header=absent\n  // const header = mime.parameters.header ?? \"present\";\n  return {\n    decomposition,\n    charset,\n    ...options,\n  };\n}\n"],"names":[],"mappings":";;AASA,MAAM,sBAAA,uBAA6D,GAAI,CAAA;AAAA,EACrE,MAAA;AAAA,EACA,SAAA;AAAA,EACA;AACF,CAAC,CAAA;AAUM,SAAS,sBACd,CAAA,QAAA,EACA,OAAsC,GAAA,EACV,EAAA;AAC5B,EAAM,MAAA,EAAE,SAAY,GAAA,QAAA;AACpB,EAAA,MAAM,WAAc,GAAA,OAAA,CAAQ,GAAI,CAAA,cAAc,CAAK,IAAA,UAAA;AACnD,EAAM,MAAA,IAAA,GAAO,UAAU,WAAW,CAAA;AAClC,EAAI,IAAA,IAAA,CAAK,SAAS,UAAY,EAAA;AAC5B,IAAA,MAAM,IAAI,SAAA,CAAU,CAAuB,oBAAA,EAAA,WAAW,CAAG,CAAA,CAAA,CAAA;AAAA;AAG3D,EAAM,MAAA,eAAA,GAAkB,OAAQ,CAAA,GAAA,CAAI,kBAAkB,CAAA;AACtD,EAAI,IAAA,aAAA;AAEJ,EAAA,IAAI,eAAiB,EAAA;AACnB,IAAA,MAAM,kBAAqB,GAAA,eAAA,CAAgB,IAAK,EAAA,CAAE,WAAY,EAAA;AAE9D,IAAI,IAAA,kBAAA,CAAmB,QAAS,CAAA,GAAG,CAAG,EAAA;AACpC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,kDAAkD,eAAe,CAAA,CAAA;AAAA,OACnE;AAAA;AAGF,IAAI,IAAA,sBAAA,CAAuB,GAAI,CAAA,kBAAuC,CAAG,EAAA;AACvE,MAAgB,aAAA,GAAA,kBAAA;AAAA,eACP,kBAAoB,EAAA;AAE7B,MAAA,IAAI,QAAQ,6BAA+B,EAAA;AAEzC,QAAgB,aAAA,GAAA,kBAAA;AAAA,OACX,MAAA;AACL,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,eAAe,CAAyB,sBAAA,EAAA,KAAA,CAAM,KAAK,sBAAsB,CAAA,CAAE,IAAK,CAAA,IAAI,CAAC,CAAA,sEAAA;AAAA,SACzH;AAAA;AACF;AACF;AAGF,EAAM,MAAA,OAAA,GAAU,IAAK,CAAA,UAAA,CAAW,OAAW,IAAA,OAAA;AAG3C,EAAO,OAAA;AAAA,IACL,aAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG;AAAA,GACL;AACF;;;;"}
+{"version":3,"file":"getOptionsFromResponse.js","sources":["../src/getOptionsFromResponse.ts"],"sourcesContent":["import { SUPPORTED_COMPRESSIONS } from \"#getOptionsFromResponse.constants.js\";\nimport type { ParseBinaryOptions } from \"./common/types.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseMime } from \"./utils/parseMime.ts\";\n\n/**\n * Extracts the options from the response object.\n *\n * @param response - The response object from which to extract the options.\n * @param options - The options to merge with the extracted options.\n * @returns The options extracted from the response.\n * @throws {TypeError} - The content type is not supported or the content-encoding is invalid.\n */\nexport function getOptionsFromResponse<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  response: Response,\n  options: ParseBinaryOptions<\n    Header,\n    Delimiter,\n    Quotation\n  > = {} as ParseBinaryOptions<Header, Delimiter, Quotation>,\n): ParseBinaryOptions<Header, Delimiter, Quotation> {\n  const { headers } = response;\n  const contentType = headers.get(\"content-type\") ?? \"text/csv\";\n  const mime = parseMime(contentType);\n  if (mime.type !== \"text/csv\") {\n    throw new TypeError(`Invalid mime type: \"${contentType}\"`);\n  }\n\n  const contentEncoding = headers.get(\"content-encoding\");\n  let decompression: CompressionFormat | undefined;\n\n  if (contentEncoding) {\n    const normalizedEncoding = contentEncoding.trim().toLowerCase();\n\n    if (normalizedEncoding.includes(\",\")) {\n      throw new TypeError(\n        `Multiple content-encodings are not supported: \"${contentEncoding}\"`,\n      );\n    }\n\n    if (SUPPORTED_COMPRESSIONS.has(normalizedEncoding as CompressionFormat)) {\n      decompression = normalizedEncoding as CompressionFormat;\n    } else if (normalizedEncoding) {\n      // Unknown compression format\n      if (options.allowExperimentalCompressions) {\n        // Allow runtime to handle experimental/future formats\n        decompression = normalizedEncoding as CompressionFormat;\n      } else {\n        throw new TypeError(\n          `Unsupported content-encoding: \"${contentEncoding}\". Supported formats: ${Array.from(SUPPORTED_COMPRESSIONS).join(\", \")}. To use experimental formats, set allowExperimentalCompressions: true`,\n        );\n      }\n    }\n  }\n\n  const charset = mime.parameters.charset ?? \"utf-8\";\n  // TODO: Support header=present and header=absent\n  // const header = mime.parameters.header ?? \"present\";\n  return {\n    decompression,\n    charset,\n    ...options,\n  };\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,sBAAA,CAKd,QAAA,EACA,OAAA,GAII,EAAC,EAC6C;AAClD,EAAA,MAAM,EAAE,SAAQ,GAAI,QAAA;AACpB,EAAA,MAAM,WAAA,GAAc,OAAA,CAAQ,GAAA,CAAI,cAAc,CAAA,IAAK,UAAA;AACnD,EAAA,MAAM,IAAA,GAAO,UAAU,WAAW,CAAA;AAClC,EAAA,IAAI,IAAA,CAAK,SAAS,UAAA,EAAY;AAC5B,IAAA,MAAM,IAAI,SAAA,CAAU,CAAA,oBAAA,EAAuB,WAAW,CAAA,CAAA,CAAG,CAAA;AAAA,EAC3D;AAEA,EAAA,MAAM,eAAA,GAAkB,OAAA,CAAQ,GAAA,CAAI,kBAAkB,CAAA;AACtD,EAAA,IAAI,aAAA;AAEJ,EAAA,IAAI,eAAA,EAAiB;AACnB,IAAA,MAAM,kBAAA,GAAqB,eAAA,CAAgB,IAAA,EAAK,CAAE,WAAA,EAAY;AAE9D,IAAA,IAAI,kBAAA,CAAmB,QAAA,CAAS,GAAG,CAAA,EAAG;AACpC,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,kDAAkD,eAAe,CAAA,CAAA;AAAA,OACnE;AAAA,IACF;AAEA,IAAA,IAAI,sBAAA,CAAuB,GAAA,CAAI,kBAAuC,CAAA,EAAG;AACvE,MAAA,aAAA,GAAgB,kBAAA;AAAA,IAClB,WAAW,kBAAA,EAAoB;AAE7B,MAAA,IAAI,QAAQ,6BAAA,EAA+B;AAEzC,QAAA,aAAA,GAAgB,kBAAA;AAAA,MAClB,CAAA,MAAO;AACL,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,eAAe,CAAA,sBAAA,EAAyB,KAAA,CAAM,KAAK,sBAAsB,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA,sEAAA;AAAA,SACzH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,UAAA,CAAW,OAAA,IAAW,OAAA;AAG3C,EAAA,OAAO;AAAA,IACL,aAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG;AAAA,GACL;AACF;;;;"}

package/dist/loadWASM.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadWASM.js","sources":["../src/loadWASM.ts"],"sourcesContent":["import init, { type InitInput } from \"web-csv-toolbox-wasm\";\n\nimport dataURL from \"web-csv-toolbox-wasm/web_csv_toolbox_wasm_bg.wasm\";\n\n/**\n * Load WASM module.\n *\n * This must be called before calling WebAssembly functions.\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 * const parsed = parseStringWASM(csv);\n * ```\n */\nexport async function loadWASM(input?: InitInput | Promise<InitInput>) {\n  await init(input ?? dataURL);\n}\n"],"names":["init"],"mappings":";;;AAoBA,eAAsB,SAAS,KAAwC,EAAA;AACrE,EAAM,MAAAA,UAAA,CAAK,SAAS,OAAO,CAAA;AAC7B;;;;"}
+{"version":3,"file":"loadWASM.js","sources":["../src/loadWASM.ts"],"sourcesContent":["import init, { type InitInput } from \"web-csv-toolbox-wasm\";\n\nimport dataURL from \"web-csv-toolbox-wasm/web_csv_toolbox_wasm_bg.wasm\";\n\n/**\n * Load WASM module.\n *\n * This must be called before calling WebAssembly functions.\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 * const parsed = parseStringWASM(csv);\n * ```\n */\nexport async function loadWASM(input?: InitInput | Promise<InitInput>) {\n  await init(input ?? dataURL);\n}\n"],"names":["init"],"mappings":";;;AAoBA,eAAsB,SAAS,KAAA,EAAwC;AACrE,EAAA,MAAMA,UAAA,CAAK,SAAS,OAAO,CAAA;AAC7B;;;;"}

package/dist/loadWASM.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadWASM.web.js","sources":["../src/loadWASM.web.ts"],"sourcesContent":["import init, { type InitInput } from \"web-csv-toolbox-wasm\";\n\n/**\n * Load WASM module.\n *\n * This must be called before calling WebAssembly functions.\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 * const parsed = parseStringWASM(csv);\n * ```\n */\nexport async function loadWASM(input?: InitInput | Promise<InitInput>) {\n  await init(input);\n}\n"],"names":["init"],"mappings":";;AAkBA,eAAsB,SAAS,KAAwC,EAAA;AACrE,EAAA,MAAMA,WAAK,KAAK,CAAA;AAClB;;;;"}
+{"version":3,"file":"loadWASM.web.js","sources":["../src/loadWASM.web.ts"],"sourcesContent":["import init, { type InitInput } from \"web-csv-toolbox-wasm\";\n\n/**\n * Load WASM module.\n *\n * This must be called before calling WebAssembly functions.\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 * const parsed = parseStringWASM(csv);\n * ```\n */\nexport async function loadWASM(input?: InitInput | Promise<InitInput>) {\n  await init(input);\n}\n"],"names":["init"],"mappings":";;AAkBA,eAAsB,SAAS,KAAA,EAAwC;AACrE,EAAA,MAAMA,WAAK,KAAK,CAAA;AAClB;;;;"}

package/dist/parse.d.ts

@@ -148,7 +148,7 @@ export declare function parse<const CSVSource extends CSVString, const Delimiter
  * for await (const record of parse(response, {
  *   charset: 'shift-jis',
  *   ignoreBOM: true,
- *   decomposition: 'gzip',
+ *   decompression: 'gzip',
  * })) {
  *   // ...
  * }

package/dist/parse.js

@@ -7,24 +7,48 @@ import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyn
 
 async function* parse(csv, options) {
   if (typeof csv === "string") {
-    yield* parseString(csv, options);
+    const iterator = parseString(csv, options);
+    yield* iterator;
   } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {
-    yield* parseBinary(csv, options);
+    const iterator = parseBinary(csv, options);
+    if (iterator instanceof Promise) {
+      yield* await iterator;
+    } else {
+      yield* iterator;
+    }
   } else if (csv instanceof ReadableStream) {
     const [branch1, branch2] = csv.tee();
     const reader1 = branch1.getReader();
     const { value: firstChunk } = await reader1.read();
     reader1.releaseLock();
     if (typeof firstChunk === "string") {
-      yield* parseStringStream(branch2, options);
+      const iterator = parseStringStream(
+        branch2,
+        options
+      );
+      if (iterator instanceof Promise) {
+        yield* await iterator;
+      } else {
+        yield* iterator;
+      }
     } else if (firstChunk instanceof Uint8Array) {
-      yield* parseUint8ArrayStream(
+      const iterator = parseUint8ArrayStream(
         branch2,
         options
       );
+      if (iterator instanceof Promise) {
+        yield* await iterator;
+      } else {
+        yield* iterator;
+      }
     }
   } else if (csv instanceof Response) {
-    yield* parseResponse(csv, options);
+    const iterator = parseResponse(csv, options);
+    if (iterator instanceof Promise) {
+      yield* await iterator;
+    } else {
+      yield* iterator;
+    }
   }
 }
 Object.defineProperties(parse, {

package/dist/parse.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse.js","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 type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.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\";\nimport type { PickCSVHeader } from \"./utils/types.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 * **Performance Characteristics:**\n * - **Memory usage**: O(1) - constant per record (streaming approach)\n * - **Suitable for**: Files of any size, browser and server environments\n * - **Recommended for**: Large files (> 10MB) or memory-constrained environments\n *\n * This function processes CSV data as an async iterable iterator, yielding one record at a time.\n * Memory footprint remains constant regardless of file size, making it ideal for large datasets.\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<const CSVSource extends CSVString>(\n  csv: CSVSource,\n): AsyncIterableIterator<CSVRecord<PickCSVHeader<CSVSource>>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<\n  const CSVSource extends CSVString,\n  const Delimiter extends string = DEFAULT_DELIMITER,\n  const Quotation extends string = DEFAULT_QUOTATION,\n  const Header extends ReadonlyArray<string> = PickCSVHeader<\n    CSVSource,\n    Delimiter,\n    Quotation\n  >,\n>(\n  csv: CSVSource,\n  options: ParseOptions<Header, Delimiter, Quotation>,\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<const Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<const 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   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\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 binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;;AAiMuB,gBAAA,KAAA,CACrB,KACA,OAC0C,EAAA;AAC1C,EAAI,IAAA,OAAO,QAAQ,QAAU,EAAA;AAC3B,IAAO,OAAA,WAAA,CAAY,KAAK,OAAO,CAAA;AAAA,GACtB,MAAA,IAAA,GAAA,YAAe,UAAc,IAAA,GAAA,YAAe,WAAa,EAAA;AAClE,IAAO,OAAA,WAAA,CAAY,KAAK,OAAO,CAAA;AAAA,GACjC,MAAA,IAAW,eAAe,cAAgB,EAAA;AACxC,IAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAI,GAAI,EAAA;AACnC,IAAM,MAAA,OAAA,GAAU,QAAQ,SAAU,EAAA;AAClC,IAAA,MAAM,EAAE,KAAO,EAAA,UAAA,EAAe,GAAA,MAAM,QAAQ,IAAK,EAAA;AACjD,IAAA,OAAA,CAAQ,WAAY,EAAA;AACpB,IAAI,IAAA,OAAO,eAAe,QAAU,EAAA;AAClC,MAAO,OAAA,iBAAA,CAAkB,SAAmC,OAAO,CAAA;AAAA,KACrE,MAAA,IAAW,sBAAsB,UAAY,EAAA;AAC3C,MAAO,OAAA,qBAAA;AAAA,QACL,OAAA;AAAA,QACA;AAAA,OACF;AAAA;AACF,GACF,MAAA,IAAW,eAAe,QAAU,EAAA;AAClC,IAAO,OAAA,aAAA,CAAc,KAAK,OAAO,CAAA;AAAA;AAErC;AAiEA,MAAA,CAAO,iBAAiB,KAAO,EAAA;AAAA,EAC7B,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA;AAAS;AAEpB,CAAC,CAAA;;;;"}
+{"version":3,"file":"parse.js","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 type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.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\";\nimport type { PickCSVHeader } from \"./utils/types.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 * **Performance Characteristics:**\n * - **Memory usage**: O(1) - constant per record (streaming approach)\n * - **Suitable for**: Files of any size, browser and server environments\n * - **Recommended for**: Large files (> 10MB) or memory-constrained environments\n *\n * This function processes CSV data as an async iterable iterator, yielding one record at a time.\n * Memory footprint remains constant regardless of file size, making it ideal for large datasets.\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<const CSVSource extends CSVString>(\n  csv: CSVSource,\n): AsyncIterableIterator<CSVRecord<PickCSVHeader<CSVSource>>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVString,\n  options: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport function parse<\n  const CSVSource extends CSVString,\n  const Delimiter extends string = DEFAULT_DELIMITER,\n  const Quotation extends string = DEFAULT_QUOTATION,\n  const Header extends ReadonlyArray<string> = PickCSVHeader<\n    CSVSource,\n    Delimiter,\n    Quotation\n  >,\n>(\n  csv: CSVSource,\n  options: ParseOptions<Header, Delimiter, Quotation>,\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 *   decompression: 'gzip',\n * })) {\n *   // ...\n * }\n * ```\n */\nexport function parse<const Header extends ReadonlyArray<string>>(\n  csv: CSVBinary,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>>;\nexport async function* parse<const Header extends ReadonlyArray<string>>(\n  csv: CSV,\n  options?: ParseBinaryOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  if (typeof csv === \"string\") {\n    const iterator = parseString(csv, options);\n    yield* iterator;\n  } else if (csv instanceof Uint8Array || csv instanceof ArrayBuffer) {\n    const iterator = parseBinary(csv, options);\n    // Check if it's a Promise\n    if (iterator instanceof Promise) {\n      yield* await iterator;\n    } else {\n      yield* iterator;\n    }\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      const iterator = parseStringStream(\n        branch2 as ReadableStream<string>,\n        options,\n      );\n      // Check if it's a Promise\n      if (iterator instanceof Promise) {\n        yield* await iterator;\n      } else {\n        yield* iterator;\n      }\n    } else if (firstChunk instanceof Uint8Array) {\n      const iterator = parseUint8ArrayStream(\n        branch2 as ReadableStream<Uint8Array>,\n        options,\n      );\n      // Check if it's a Promise\n      if (iterator instanceof Promise) {\n        yield* await iterator;\n      } else {\n        yield* iterator;\n      }\n    }\n  } else if (csv instanceof Response) {\n    const iterator = parseResponse(csv, options);\n    // Check if it's a Promise\n    if (iterator instanceof Promise) {\n      yield* await iterator;\n    } else {\n      yield* iterator;\n    }\n  }\n}\n\nexport declare namespace parse {\n  /**\n   * Parse CSV string to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\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 binary to array of records,\n   * ideal for smaller data sets.\n   *\n   * @remarks\n   * **Performance Characteristics:**\n   * - **Memory usage**: O(n) - proportional to file size (loads entire result into memory)\n   * - **Suitable for**: Small datasets, quick prototyping\n   * - **Recommended max**: ~10MB (browser), ~100MB (Node.js/Deno)\n   *\n   * This function collects all records into an array before returning.\n   * For large files, consider using the streaming {@link parse} function instead.\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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;;AAiMA,gBAAuB,KAAA,CACrB,KACA,OAAA,EAC0C;AAC1C,EAAA,IAAI,OAAO,QAAQ,QAAA,EAAU;AAC3B,IAAA,MAAM,QAAA,GAAW,WAAA,CAAY,GAAA,EAAK,OAAO,CAAA;AACzC,IAAA,OAAO,QAAA;AAAA,EACT,CAAA,MAAA,IAAW,GAAA,YAAe,UAAA,IAAc,GAAA,YAAe,WAAA,EAAa;AAClE,IAAA,MAAM,QAAA,GAAW,WAAA,CAAY,GAAA,EAAK,OAAO,CAAA;AAEzC,IAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,MAAA,OAAO,MAAM,QAAA;AAAA,IACf,CAAA,MAAO;AACL,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,EACF,CAAA,MAAA,IAAW,eAAe,cAAA,EAAgB;AACxC,IAAA,MAAM,CAAC,OAAA,EAAS,OAAO,CAAA,GAAI,IAAI,GAAA,EAAI;AACnC,IAAA,MAAM,OAAA,GAAU,QAAQ,SAAA,EAAU;AAClC,IAAA,MAAM,EAAE,KAAA,EAAO,UAAA,EAAW,GAAI,MAAM,QAAQ,IAAA,EAAK;AACjD,IAAA,OAAA,CAAQ,WAAA,EAAY;AACpB,IAAA,IAAI,OAAO,eAAe,QAAA,EAAU;AAClC,MAAA,MAAM,QAAA,GAAW,iBAAA;AAAA,QACf,OAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,QAAA,OAAO,MAAM,QAAA;AAAA,MACf,CAAA,MAAO;AACL,QAAA,OAAO,QAAA;AAAA,MACT;AAAA,IACF,CAAA,MAAA,IAAW,sBAAsB,UAAA,EAAY;AAC3C,MAAA,MAAM,QAAA,GAAW,qBAAA;AAAA,QACf,OAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,QAAA,OAAO,MAAM,QAAA;AAAA,MACf,CAAA,MAAO;AACL,QAAA,OAAO,QAAA;AAAA,MACT;AAAA,IACF;AAAA,EACF,CAAA,MAAA,IAAW,eAAe,QAAA,EAAU;AAClC,IAAA,MAAM,QAAA,GAAW,aAAA,CAAc,GAAA,EAAK,OAAO,CAAA;AAE3C,IAAA,IAAI,oBAAoB,OAAA,EAAS;AAC/B,MAAA,OAAO,MAAM,QAAA;AAAA,IACf,CAAA,MAAO;AACL,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,EACF;AACF;AAiEA,MAAA,CAAO,iBAAiB,KAAA,EAAO;AAAA,EAC7B,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS;AAEpB,CAAC,CAAA;;;;"}

package/dist/parseBinary.d.ts

@@ -1,4 +1,5 @@
 import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+import { DEFAULT_DELIMITER } from './constants.ts';
 /**
  * Parse a binary from an {@link !Uint8Array}.
  *
@@ -22,7 +23,7 @@ import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
  * }
  * ```
  */
-export declare function parseBinary<Header extends ReadonlyArray<string>>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): AsyncIterableIterator<CSVRecord<Header>>;
+export declare function parseBinary<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = '"'>(bytes: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): AsyncIterableIterator<CSVRecord<Header>>;
 export declare namespace parseBinary {
     /**
      * Parse a binary from an {@link !Uint8Array} to an array of records.

package/dist/parseBinary.js

@@ -1,12 +1,41 @@
+import { InternalEngineConfig } from './execution/InternalEngineConfig.js';
+import { parseBinaryInWASM } from './execution/wasm/parseBinaryInWASM.js';
+import { WorkerSession } from './execution/worker/helpers/WorkerSession.js';
+import { executeWithWorkerStrategy } from './execution/worker/strategies/WorkerStrategySelector.js';
 import { parseBinaryToArraySync } from './parseBinaryToArraySync.js';
 import { parseBinaryToIterableIterator } from './parseBinaryToIterableIterator.js';
 import { parseBinaryToStream } from './parseBinaryToStream.js';
 import { convertIterableIteratorToAsync } from './utils/convertIterableIteratorToAsync.js';
 import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
 
-function parseBinary(bytes, options) {
-  const iterator = parseBinaryToIterableIterator(bytes, options);
-  return convertIterableIteratorToAsync(iterator);
+async function* parseBinary(bytes, options) {
+  const engineConfig = new InternalEngineConfig(options?.engine);
+  if (engineConfig.hasWorker()) {
+    const session = engineConfig.workerPool ? await WorkerSession.create({
+      workerPool: engineConfig.workerPool,
+      workerURL: engineConfig.workerURL
+    }) : null;
+    try {
+      yield* executeWithWorkerStrategy(
+        bytes,
+        options,
+        session,
+        engineConfig
+      );
+    } finally {
+      session?.[Symbol.dispose]();
+    }
+  } else {
+    if (engineConfig.hasWasm()) {
+      yield* parseBinaryInWASM(
+        bytes,
+        options
+      );
+    } else {
+      const iterator = parseBinaryToIterableIterator(bytes, options);
+      yield* convertIterableIteratorToAsync(iterator);
+    }
+  }
 }
 Object.defineProperties(parseBinary, {
   toArray: {

package/dist/parseBinary.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinary.js","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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;AA8BgB,SAAA,WAAA,CACd,OACA,OAC0C,EAAA;AAC1C,EAAM,MAAA,QAAA,GAAW,6BAA8B,CAAA,KAAA,EAAO,OAAO,CAAA;AAC7D,EAAA,OAAO,+BAA+B,QAAQ,CAAA;AAChD;AAyGA,MAAA,CAAO,iBAAiB,WAAa,EAAA;AAAA,EACnC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA;AAAS,GAClB;AAAA,EACA,WAAa,EAAA;AAAA,IACX,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA;AAAA,GACT;AAAA,EACA,kBAAoB,EAAA;AAAA,IAClB,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA;AAAA,GACT;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA;AAAA;AAEX,CAAC,CAAA;;;;"}
+{"version":3,"file":"parseBinary.js","sources":["../src/parseBinary.ts"],"sourcesContent":["import type {\n  CSVRecord,\n  ParseBinaryOptions,\n  ParseOptions,\n} from \"./common/types.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { InternalEngineConfig } from \"./execution/InternalEngineConfig.ts\";\nimport { parseBinaryInWASM } from \"./execution/wasm/parseBinaryInWASM.ts\";\nimport { WorkerSession } from \"./execution/worker/helpers/WorkerSession.ts\";\nimport { executeWithWorkerStrategy } from \"./execution/worker/strategies/WorkerStrategySelector.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 async function* parseBinary<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  bytes: Uint8Array | ArrayBuffer,\n  options?: ParseBinaryOptions<Header, Delimiter, Quotation>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  // Parse engine configuration\n  const engineConfig = new InternalEngineConfig(options?.engine);\n\n  if (engineConfig.hasWorker()) {\n    // Worker execution\n    const session = engineConfig.workerPool\n      ? await WorkerSession.create({\n          workerPool: engineConfig.workerPool,\n          workerURL: engineConfig.workerURL,\n        })\n      : null;\n\n    try {\n      yield* executeWithWorkerStrategy<CSVRecord<Header>>(\n        bytes,\n        options as\n          | ParseOptions<Header>\n          | ParseBinaryOptions<Header>\n          | undefined,\n        session,\n        engineConfig,\n      );\n    } finally {\n      session?.[Symbol.dispose]();\n    }\n  } else {\n    // Main thread execution\n    if (engineConfig.hasWasm()) {\n      yield* parseBinaryInWASM(\n        bytes,\n        options as ParseBinaryOptions<Header> | undefined,\n      );\n    } else {\n      const iterator = parseBinaryToIterableIterator(bytes, options);\n      yield* convertIterableIteratorToAsync(iterator);\n    }\n  }\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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;;;;;AAuCA,gBAAuB,WAAA,CAKrB,OACA,OAAA,EAC0C;AAE1C,EAAA,MAAM,YAAA,GAAe,IAAI,oBAAA,CAAqB,OAAA,EAAS,MAAM,CAAA;AAE7D,EAAA,IAAI,YAAA,CAAa,WAAU,EAAG;AAE5B,IAAA,MAAM,OAAA,GAAU,YAAA,CAAa,UAAA,GACzB,MAAM,cAAc,MAAA,CAAO;AAAA,MACzB,YAAY,YAAA,CAAa,UAAA;AAAA,MACzB,WAAW,YAAA,CAAa;AAAA,KACzB,CAAA,GACD,IAAA;AAEJ,IAAA,IAAI;AACF,MAAA,OAAO,yBAAA;AAAA,QACL,KAAA;AAAA,QACA,OAAA;AAAA,QAIA,OAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF,CAAA,SAAE;AACA,MAAA,OAAA,GAAU,MAAA,CAAO,OAAO,CAAA,EAAE;AAAA,IAC5B;AAAA,EACF,CAAA,MAAO;AAEL,IAAA,IAAI,YAAA,CAAa,SAAQ,EAAG;AAC1B,MAAA,OAAO,iBAAA;AAAA,QACL,KAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF,CAAA,MAAO;AACL,MAAA,MAAM,QAAA,GAAW,6BAAA,CAA8B,KAAA,EAAO,OAAO,CAAA;AAC7D,MAAA,OAAO,+BAA+B,QAAQ,CAAA;AAAA,IAChD;AAAA,EACF;AACF;AAyGA,MAAA,CAAO,iBAAiB,WAAA,EAAa;AAAA,EACnC,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS,GAClB;AAAA,EACA,WAAA,EAAa;AAAA,IACX,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,KAAA,EAAO;AAAA,GACT;AAAA,EACA,kBAAA,EAAoB;AAAA,IAClB,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,KAAA,EAAO;AAAA,GACT;AAAA,EACA,QAAA,EAAU;AAAA,IACR,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,KAAA,EAAO;AAAA;AAEX,CAAC,CAAA;;;;"}

package/dist/parseBinaryInWorker.node.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseBinaryInWorker.node'
+export {}

package/dist/parseBinaryInWorker.web.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseBinaryInWorker.web'
+export {}

package/dist/parseBinaryInWorkerWASM.node.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseBinaryInWorkerWASM.node'
+export {}

package/dist/parseBinaryInWorkerWASM.web.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseBinaryInWorkerWASM.web'
+export {}

package/dist/parseBinaryToArraySync.d.ts

@@ -1,4 +1,5 @@
 import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+import { DEFAULT_DELIMITER } from './constants.ts';
 /**
  * Synchronously parses binary CSV data into an array of records.
  *
@@ -23,4 +24,4 @@ import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
  * // [{ name: "Alice", age: "30" }]
  * ```
  */
-export declare function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): CSVRecord<Header>[];
+export declare function parseBinaryToArraySync<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = '"'>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): CSVRecord<Header>[];

package/dist/parseBinaryToArraySync.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToArraySync.js","sources":["../src/parseBinaryToArraySync.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\n/**\n * Synchronously parses binary CSV data into an array of records.\n *\n * @param binary - The binary CSV data to parse (Uint8Array or ArrayBuffer).\n * @param options - Parsing options including charset, maxBinarySize, etc.\n * @returns An array of CSV records.\n * @throws {RangeError} If the binary size exceeds maxBinarySize limit.\n * @throws {ParseError} If the CSV data is malformed.\n *\n * @remarks\n * **WARNING**: This function loads the entire binary data into memory synchronously.\n * For large files (>100MB), consider using streaming alternatives like `parseStream()` or `parseUint8ArrayStream()`\n * to avoid memory exhaustion and blocking the event loop.\n *\n * The default maxBinarySize is 100MB. You can increase it via options, but this may lead to\n * memory issues with very large files.\n *\n * @example\n * ```ts\n * const binary = new TextEncoder().encode(\"name,age\\nAlice,30\");\n * const records = parseBinaryToArraySync(binary);\n * // [{ name: \"Alice\", age: \"30\" }]\n * ```\n */\nexport function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): CSVRecord<Header>[] {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToArraySync(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AA6BO,SAAS,sBACd,CAAA,MAAA,EACA,OAAsC,GAAA,EACjB,EAAA;AACrB,EAAI,IAAA;AACF,IAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAO,OAAA,sBAAA,CAAuB,KAAK,OAAO,CAAA;AAAA,WACnC,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA;AAElC;;;;"}
+{"version":3,"file":"parseBinaryToArraySync.js","sources":["../src/parseBinaryToArraySync.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\n/**\n * Synchronously parses binary CSV data into an array of records.\n *\n * @param binary - The binary CSV data to parse (Uint8Array or ArrayBuffer).\n * @param options - Parsing options including charset, maxBinarySize, etc.\n * @returns An array of CSV records.\n * @throws {RangeError} If the binary size exceeds maxBinarySize limit.\n * @throws {ParseError} If the CSV data is malformed.\n *\n * @remarks\n * **WARNING**: This function loads the entire binary data into memory synchronously.\n * For large files (>100MB), consider using streaming alternatives like `parseStream()` or `parseUint8ArrayStream()`\n * to avoid memory exhaustion and blocking the event loop.\n *\n * The default maxBinarySize is 100MB. You can increase it via options, but this may lead to\n * memory issues with very large files.\n *\n * @example\n * ```ts\n * const binary = new TextEncoder().encode(\"name,age\\nAlice,30\");\n * const records = parseBinaryToArraySync(binary);\n * // [{ name: \"Alice\", age: \"30\" }]\n * ```\n */\nexport function parseBinaryToArraySync<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<\n    Header,\n    Delimiter,\n    Quotation\n  > = {} as ParseBinaryOptions<Header, Delimiter, Quotation>,\n): CSVRecord<Header>[] {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToArraySync(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AA8BO,SAAS,sBAAA,CAKd,MAAA,EACA,OAAA,GAII,EAAC,EACgB;AACrB,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,qBAAA,CAAsB,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAA,OAAO,sBAAA,CAAuB,KAAK,OAAO,CAAA;AAAA,EAC5C,SAAS,KAAA,EAAO;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,EAChC;AACF;;;;"}

package/dist/parseBinaryToIterableIterator.d.ts

@@ -1,4 +1,5 @@
 import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
+import { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from './constants.ts';
 /**
  * Parses the given binary data into an iterable iterator of CSV records.
  *
@@ -16,4 +17,4 @@ import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
  * The default maxBinarySize is 100MB. While this function returns an iterator, the entire
  * binary is converted to a string in memory before iteration begins.
  */
-export declare function parseBinaryToIterableIterator<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): IterableIterator<CSVRecord<Header>>;
+export declare function parseBinaryToIterableIterator<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = DEFAULT_QUOTATION>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): IterableIterator<CSVRecord<Header>>;

package/dist/parseBinaryToIterableIterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToIterableIterator.js","sources":["../src/parseBinaryToIterableIterator.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\n/**\n * Parses the given binary data into an iterable iterator of CSV records.\n *\n * @param binary - The binary data to parse.\n * @param options - The parse options.\n * @returns An iterable iterator of CSV records.\n * @throws {RangeError} If the binary size exceeds maxBinarySize limit.\n * @throws {ParseError} When an error occurs while parsing the CSV data.\n *\n * @remarks\n * **WARNING**: This function loads the entire binary data into memory before iteration.\n * For large files (>100MB), consider using streaming alternatives like `parseStream()` or `parseUint8ArrayStream()`\n * to avoid memory exhaustion.\n *\n * The default maxBinarySize is 100MB. While this function returns an iterator, the entire\n * binary is converted to a string in memory before iteration begins.\n */\nexport function parseBinaryToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): IterableIterator<CSVRecord<Header>> {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToIterableIterator(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAsBO,SAAS,6BAGd,CAAA,MAAA,EACA,OAAsC,GAAA,EACD,EAAA;AACrC,EAAI,IAAA;AACF,IAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA;AAAA,WAC1C,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA;AAElC;;;;"}
+{"version":3,"file":"parseBinaryToIterableIterator.js","sources":["../src/parseBinaryToIterableIterator.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\n/**\n * Parses the given binary data into an iterable iterator of CSV records.\n *\n * @param binary - The binary data to parse.\n * @param options - The parse options.\n * @returns An iterable iterator of CSV records.\n * @throws {RangeError} If the binary size exceeds maxBinarySize limit.\n * @throws {ParseError} When an error occurs while parsing the CSV data.\n *\n * @remarks\n * **WARNING**: This function loads the entire binary data into memory before iteration.\n * For large files (>100MB), consider using streaming alternatives like `parseStream()` or `parseUint8ArrayStream()`\n * to avoid memory exhaustion.\n *\n * The default maxBinarySize is 100MB. While this function returns an iterator, the entire\n * binary is converted to a string in memory before iteration begins.\n */\nexport function parseBinaryToIterableIterator<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = DEFAULT_QUOTATION,\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<\n    Header,\n    Delimiter,\n    Quotation\n  > = {} as ParseBinaryOptions<Header, Delimiter, Quotation>,\n): IterableIterator<CSVRecord<Header>> {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToIterableIterator(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAuBO,SAAS,6BAAA,CAKd,MAAA,EACA,OAAA,GAII,EAAC,EACgC;AACrC,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,qBAAA,CAAsB,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAA,OAAO,6BAAA,CAA8B,KAAK,OAAO,CAAA;AAAA,EACnD,SAAS,KAAA,EAAO;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,EAChC;AACF;;;;"}

package/dist/parseBinaryToStream.d.ts

@@ -1,2 +1,3 @@
 import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-export declare function parseBinaryToStream<Header extends ReadonlyArray<string>>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
+import { DEFAULT_DELIMITER } from './constants.ts';
+export declare function parseBinaryToStream<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = '"'>(binary: Uint8Array | ArrayBuffer, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): ReadableStream<CSVRecord<Header>>;

package/dist/parseBinaryToStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToStream.js","sources":["../src/parseBinaryToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\nexport function parseBinaryToStream<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): ReadableStream<CSVRecord<Header>> {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToStream(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAKO,SAAS,mBACd,CAAA,MAAA,EACA,OAAsC,GAAA,EACH,EAAA;AACnC,EAAI,IAAA;AACF,IAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAO,OAAA,mBAAA,CAAoB,KAAK,OAAO,CAAA;AAAA,WAChC,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA;AAElC;;;;"}
+{"version":3,"file":"parseBinaryToStream.js","sources":["../src/parseBinaryToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport { convertBinaryToString } from \"./utils/convertBinaryToString.ts\";\n\nexport function parseBinaryToStream<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<\n    Header,\n    Delimiter,\n    Quotation\n  > = {} as ParseBinaryOptions<Header, Delimiter, Quotation>,\n): ReadableStream<CSVRecord<Header>> {\n  try {\n    const csv = convertBinaryToString(binary, options);\n    return parseStringToStream(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAMO,SAAS,mBAAA,CAKd,MAAA,EACA,OAAA,GAII,EAAC,EAC8B;AACnC,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,qBAAA,CAAsB,MAAA,EAAQ,OAAO,CAAA;AACjD,IAAA,OAAO,mBAAA,CAAoB,KAAK,OAAO,CAAA;AAAA,EACzC,SAAS,KAAA,EAAO;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,EAChC;AACF;;;;"}

package/dist/parseResponse.d.ts

@@ -76,5 +76,5 @@ export declare namespace parseResponse {
      * // { name: 'Bob', age: '69' }
      * ```
      */
-    function toStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>[]>;
+    function toStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseOptions<Header>): ReadableStream<CSVRecord<Header>>;
 }

package/dist/parseResponse.js

@@ -5,15 +5,22 @@ import { parseUint8ArrayStream } from './parseUint8ArrayStream.js';
 import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
 
 function parseResponse(response, options) {
-  try {
-    const options_ = getOptionsFromResponse(response, options);
-    if (response.body === null) {
-      throw new TypeError("Response body is null");
-    }
-    return parseUint8ArrayStream(response.body, options_);
-  } catch (error) {
-    commonParseErrorHandling(error);
+  const options_ = getOptionsFromResponse(response, options);
+  if (response.body === null) {
+    throw new TypeError("Response body is null");
   }
+  return (async function* () {
+    try {
+      const result = parseUint8ArrayStream(response.body, options_);
+      if (result instanceof Promise) {
+        yield* await result;
+      } else {
+        yield* result;
+      }
+    } catch (error) {
+      commonParseErrorHandling(error);
+    }
+  })();
 }
 Object.defineProperties(parseResponse, {
   toArray: {

package/dist/parseResponse.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponse.js","sources":["../src/parseResponse.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.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  try {\n    const options_ = getOptionsFromResponse(response, options);\n    if (response.body === null) {\n      throw new TypeError(\"Response body is null\");\n    }\n    return parseUint8ArrayStream(response.body, options_);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;AAuCgB,SAAA,aAAA,CACd,UACA,OAC0C,EAAA;AAC1C,EAAI,IAAA;AACF,IAAM,MAAA,QAAA,GAAW,sBAAuB,CAAA,QAAA,EAAU,OAAO,CAAA;AACzD,IAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,MAAM,MAAA,IAAI,UAAU,uBAAuB,CAAA;AAAA;AAE7C,IAAO,OAAA,qBAAA,CAAsB,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA;AAAA,WAC7C,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA;AAElC;AAuDA,MAAA,CAAO,iBAAiB,aAAe,EAAA;AAAA,EACrC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA;AAAS,GAClB;AAAA,EACA,YAAc,EAAA;AAAA,IACZ,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA;AAAA;AAEX,CAAC,CAAA;;;;"}
+{"version":3,"file":"parseResponse.js","sources":["../src/parseResponse.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.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  // Validate synchronously before creating async generator\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new TypeError(\"Response body is null\");\n  }\n\n  // Return wrapper async generator for error handling\n  return (async function* () {\n    try {\n      const result = parseUint8ArrayStream(response.body!, options_);\n      if (result instanceof Promise) {\n        yield* await result;\n      } else {\n        yield* result;\n      }\n    } catch (error) {\n      commonParseErrorHandling(error);\n    }\n  })();\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":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;AAuCO,SAAS,aAAA,CACd,UACA,OAAA,EAC0C;AAE1C,EAAA,MAAM,QAAA,GAAW,sBAAA,CAAuB,QAAA,EAAU,OAAO,CAAA;AACzD,EAAA,IAAI,QAAA,CAAS,SAAS,IAAA,EAAM;AAC1B,IAAA,MAAM,IAAI,UAAU,uBAAuB,CAAA;AAAA,EAC7C;AAGA,EAAA,OAAA,CAAQ,mBAAmB;AACzB,IAAA,IAAI;AACF,MAAA,MAAM,MAAA,GAAS,qBAAA,CAAsB,QAAA,CAAS,IAAA,EAAO,QAAQ,CAAA;AAC7D,MAAA,IAAI,kBAAkB,OAAA,EAAS;AAC7B,QAAA,OAAO,MAAM,MAAA;AAAA,MACf,CAAA,MAAO;AACL,QAAA,OAAO,MAAA;AAAA,MACT;AAAA,IACF,SAAS,KAAA,EAAO;AACd,MAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,IAChC;AAAA,EACF,CAAA,GAAG;AACL;AAuDA,MAAA,CAAO,iBAAiB,aAAA,EAAe;AAAA,EACrC,OAAA,EAAS;AAAA,IACP,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,OAAOA;AAAS,GAClB;AAAA,EACA,YAAA,EAAc;AAAA,IACZ,UAAA,EAAY,IAAA;AAAA,IACZ,QAAA,EAAU,KAAA;AAAA,IACV,KAAA,EAAO;AAAA;AAEX,CAAC,CAAA;;;;"}

package/dist/parseResponseToStream.d.ts

@@ -1,2 +1,3 @@
 import { CSVRecord, ParseBinaryOptions } from './common/types.ts';
-export declare function parseResponseToStream<Header extends ReadonlyArray<string>>(response: Response, options?: ParseBinaryOptions<Header>): ReadableStream<CSVRecord<Header>>;
+import { DEFAULT_DELIMITER } from './constants.ts';
+export declare function parseResponseToStream<Header extends ReadonlyArray<string>, Delimiter extends string = DEFAULT_DELIMITER, Quotation extends string = '"'>(response: Response, options?: ParseBinaryOptions<Header, Delimiter, Quotation>): ReadableStream<CSVRecord<Header>>;

package/dist/parseResponseToStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponseToStream.js","sources":["../src/parseResponseToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.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  try {\n    const options_ = getOptionsFromResponse(response, options);\n    if (response.body === null) {\n      throw new TypeError(\"Response body is null\");\n    }\n    return parseUint8ArrayStreamToStream(response.body, options_);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAKgB,SAAA,qBAAA,CACd,UACA,OACmC,EAAA;AACnC,EAAI,IAAA;AACF,IAAM,MAAA,QAAA,GAAW,sBAAuB,CAAA,QAAA,EAAU,OAAO,CAAA;AACzD,IAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,MAAM,MAAA,IAAI,UAAU,uBAAuB,CAAA;AAAA;AAE7C,IAAO,OAAA,6BAAA,CAA8B,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA;AAAA,WACrD,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA;AAElC;;;;"}
+{"version":3,"file":"parseResponseToStream.js","sources":["../src/parseResponseToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport type { DEFAULT_DELIMITER, DEFAULT_QUOTATION } from \"./constants.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\n\nexport function parseResponseToStream<\n  Header extends ReadonlyArray<string>,\n  Delimiter extends string = DEFAULT_DELIMITER,\n  Quotation extends string = '\"',\n>(\n  response: Response,\n  options?: ParseBinaryOptions<Header, Delimiter, Quotation>,\n): ReadableStream<CSVRecord<Header>> {\n  try {\n    const options_ = getOptionsFromResponse(response, options);\n    if (response.body === null) {\n      throw new TypeError(\"Response body is null\");\n    }\n    return parseUint8ArrayStreamToStream(response.body, options_);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAMO,SAAS,qBAAA,CAKd,UACA,OAAA,EACmC;AACnC,EAAA,IAAI;AACF,IAAA,MAAM,QAAA,GAAW,sBAAA,CAAuB,QAAA,EAAU,OAAO,CAAA;AACzD,IAAA,IAAI,QAAA,CAAS,SAAS,IAAA,EAAM;AAC1B,MAAA,MAAM,IAAI,UAAU,uBAAuB,CAAA;AAAA,IAC7C;AACA,IAAA,OAAO,6BAAA,CAA8B,QAAA,CAAS,IAAA,EAAM,QAAQ,CAAA;AAAA,EAC9D,SAAS,KAAA,EAAO;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA;AAAA,EAChC;AACF;;;;"}

package/dist/parseStreamInWorker.node.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseStreamInWorker.node'
+export {}

package/dist/parseStreamInWorker.web.d.ts

@@ -0,0 +1,2 @@
+export * from './execution/worker/parseStreamInWorker.web'
+export {}

package/dist/parseString.d.ts

@@ -17,6 +17,25 @@ import { PickCSVHeader } from './utils/types.ts';
  * - **Suitable for**: Files of any size
  * - **Recommended for**: Large CSV strings (> 10MB) or memory-constrained environments
  *
+ * **Execution Strategies:**
+ * Control how parsing is executed using the `engine` option:
+ * - **Main thread** (default): `engine: { worker: false }` - No overhead, good for small files
+ * - **Worker thread**: `engine: { worker: true }` - Offloads parsing, good for large files
+ * - **WebAssembly**: `engine: { wasm: true }` - Fast parsing, limited to UTF-8 and double-quotes
+ * - **Combined**: `engine: { worker: true, wasm: true }` - Worker + WASM for maximum performance
+ *
+ * Use {@link EnginePresets} for convenient configurations:
+ * ```ts
+ * import { parseString, EnginePresets } from 'web-csv-toolbox';
+ *
+ * // Use fastest available execution method
+ * for await (const record of parseString(csv, {
+ *   engine: EnginePresets.fastest()
+ * })) {
+ *   console.log(record);
+ * }
+ * ```
+ *
  * @example Parsing CSV files from strings
  *
  * ```ts
@@ -33,6 +52,18 @@ import { PickCSVHeader } from './utils/types.ts';
  * // { name: 'Alice', age: '42' }
  * // { name: 'Bob', age: '69' }
  * ```
+ *
+ * @example Using worker execution for better performance
+ * ```ts
+ * import { parseString } from 'web-csv-toolbox';
+ *
+ * // Offload parsing to a worker thread
+ * for await (const record of parseString(largeCSV, {
+ *   engine: { worker: true }
+ * })) {
+ *   console.log(record);
+ * }
+ * ```
  */
 export declare function parseString<const CSVSource extends string>(csv: CSVSource): AsyncIterableIterator<CSVRecord<PickCSVHeader<CSVSource>>>;
 export declare function parseString<const Header extends ReadonlyArray<string>>(csv: string): AsyncIterableIterator<CSVRecord<Header>>;

package/dist/parseString.js

@@ -1,12 +1,38 @@
 import { commonParseErrorHandling } from './commonParseErrorHandling.js';
+import { InternalEngineConfig } from './execution/InternalEngineConfig.js';
+import { WorkerSession } from './execution/worker/helpers/WorkerSession.js';
+import { executeWithWorkerStrategy } from './execution/worker/strategies/WorkerStrategySelector.js';
 import { parseStringToArraySync } from './parseStringToArraySync.js';
+import { parseStringToArraySyncWASM } from './parseStringToArraySyncWASM.js';
 import { parseStringToIterableIterator } from './parseStringToIterableIterator.js';
 import { parseStringToStream } from './parseStringToStream.js';
 import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
 
 async function* parseString(csv, options) {
   try {
-    yield* parseStringToIterableIterator(csv, options);
+    const engineConfig = new InternalEngineConfig(options?.engine);
+    if (engineConfig.hasWorker()) {
+      const session = engineConfig.workerPool ? await WorkerSession.create({
+        workerPool: engineConfig.workerPool,
+        workerURL: engineConfig.workerURL
+      }) : null;
+      try {
+        yield* executeWithWorkerStrategy(
+          csv,
+          options,
+          session,
+          engineConfig
+        );
+      } finally {
+        session?.[Symbol.dispose]();
+      }
+    } else {
+      if (engineConfig.hasWasm()) {
+        yield* parseStringToArraySyncWASM(csv, options);
+      } else {
+        yield* parseStringToIterableIterator(csv, options);
+      }
+    }
   } catch (error) {
     commonParseErrorHandling(error);
   }