web-csv-toolbox 0.9.0 → 0.10.1

package/dist/es/common/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../src/common/errors.ts"],"sourcesContent":["import type { Position } from \"./types.js\";\n\n/**\n * Error class for invalid option errors.\n */\nexport class InvalidOptionError extends Error {\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = \"InvalidOptionError\";\n  }\n}\n\n/**\n * Options for creating a parse error.\n */\nexport interface ParseErrorOptions extends ErrorOptions {\n  /**\n   * The position where the error occurred.\n   */\n  position?: Position;\n}\n\n/**\n * Error class for parse errors.\n *\n * @remarks\n * This error is thrown when a parsing error occurs.\n * {@link ParseError} is a subclass of {@link !SyntaxError}.\n *\n * This is in reference to the specification\n * that the error thrown when a parse error occurs in the {@link !JSON.parse} function is {@link !SyntaxError}.\n */\nexport class ParseError extends SyntaxError {\n  /**\n   * The position where the error occurred.\n   */\n  public position?: Position;\n\n  constructor(message?: string, options?: ParseErrorOptions) {\n    super(message, { cause: options?.cause });\n    this.name = \"ParseError\";\n    this.position = options?.position;\n  }\n}\n"],"names":[],"mappings":"AAKO,MAAM,2BAA2B,KAAM,CAAA;AAAA,EAC5C,WAAA,CAAY,SAAkB,OAAwB,EAAA;AACpD,IAAA,KAAA,CAAM,SAAS,OAAO,CAAA,CAAA;AACtB,IAAA,IAAA,CAAK,IAAO,GAAA,oBAAA,CAAA;AAAA,GACd;AACF,CAAA;AAsBO,MAAM,mBAAmB,WAAY,CAAA;AAAA;AAAA;AAAA;AAAA,EAInC,QAAA,CAAA;AAAA,EAEP,WAAA,CAAY,SAAkB,OAA6B,EAAA;AACzD,IAAA,KAAA,CAAM,OAAS,EAAA,EAAE,KAAO,EAAA,OAAA,EAAS,OAAO,CAAA,CAAA;AACxC,IAAA,IAAA,CAAK,IAAO,GAAA,YAAA,CAAA;AACZ,IAAA,IAAA,CAAK,WAAW,OAAS,EAAA,QAAA,CAAA;AAAA,GAC3B;AACF;;;;"}

package/dist/es/commonParseErrorHandling.js

@@ -0,0 +1,13 @@
+import { ParseError, InvalidOptionError } from './common/errors.js';
+
+function commonParseErrorHandling(error) {
+  if (error instanceof ParseError || error instanceof InvalidOptionError) {
+    throw error;
+  }
+  throw new ParseError("An error occurred while parsing the CSV data.", {
+    cause: error
+  });
+}
+
+export { commonParseErrorHandling };
+//# sourceMappingURL=commonParseErrorHandling.js.map

package/dist/es/commonParseErrorHandling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonParseErrorHandling.js","sources":["../../src/commonParseErrorHandling.ts"],"sourcesContent":["import { InvalidOptionError, ParseError } from \"./common/errors\";\n\n/**\n * Common error handling for parsing CSV data.\n *\n * @param error - The error to handle.\n * @throws {ParseError} When an error occurs while parsing the CSV data.\n * @throws {InvalidOptionError} When an invalid option is provided.\n */\n\nexport function commonParseErrorHandling(error: unknown): never {\n  if (error instanceof ParseError || error instanceof InvalidOptionError) {\n    throw error;\n  }\n  throw new ParseError(\"An error occurred while parsing the CSV data.\", {\n    cause: error,\n  });\n}\n"],"names":[],"mappings":";;AAUO,SAAS,yBAAyB,KAAuB,EAAA;AAC9D,EAAI,IAAA,KAAA,YAAiB,UAAc,IAAA,KAAA,YAAiB,kBAAoB,EAAA;AACtE,IAAM,MAAA,KAAA,CAAA;AAAA,GACR;AACA,EAAM,MAAA,IAAI,WAAW,+CAAiD,EAAA;AAAA,IACpE,KAAO,EAAA,KAAA;AAAA,GACR,CAAA,CAAA;AACH;;;;"}

package/dist/es/getOptionsFromResponse.js

@@ -5,7 +5,7 @@ function getOptionsFromResponse(response, options = {}) {
   const contentType = headers.get("content-type") ?? "text/csv";
   const mime = parseMime(contentType);
   if (mime.type !== "text/csv") {
-    throw new Error(`Invalid mime type: ${contentType}`);
+    throw new RangeError(`Invalid mime type: "${contentType}"`);
   }
   const decomposition = headers.get("content-encoding") ?? void 0;
   const charset = mime.parameters.charset ?? "utf-8";

package/dist/es/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\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 Error(`Invalid mime type: ${contentType}`);\n  }\n  const decomposition =\n    (headers.get(\"content-encoding\") as CompressionFormat) ?? undefined;\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":";;AAGO,SAAS,sBACd,CAAA,QAAA,EACA,OAAsC,GAAA,EACV,EAAA;AAC5B,EAAM,MAAA,EAAE,SAAY,GAAA,QAAA,CAAA;AACpB,EAAA,MAAM,WAAc,GAAA,OAAA,CAAQ,GAAI,CAAA,cAAc,CAAK,IAAA,UAAA,CAAA;AACnD,EAAM,MAAA,IAAA,GAAO,UAAU,WAAW,CAAA,CAAA;AAClC,EAAI,IAAA,IAAA,CAAK,SAAS,UAAY,EAAA;AAC5B,IAAA,MAAM,IAAI,KAAA,CAAM,CAAsB,mBAAA,EAAA,WAAW,CAAE,CAAA,CAAA,CAAA;AAAA,GACrD;AACA,EAAA,MAAM,aACH,GAAA,OAAA,CAAQ,GAAI,CAAA,kBAAkB,CAA2B,IAAA,KAAA,CAAA,CAAA;AAC5D,EAAM,MAAA,OAAA,GAAU,IAAK,CAAA,UAAA,CAAW,OAAW,IAAA,OAAA,CAAA;AAG3C,EAAO,OAAA;AAAA,IACL,aAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG,OAAA;AAAA,GACL,CAAA;AACF;;;;"}
+{"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 * 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 {RangeError} - The content type is not supported.\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 RangeError(`Invalid mime type: \"${contentType}\"`);\n  }\n  const decomposition =\n    (headers.get(\"content-encoding\") as CompressionFormat) ?? undefined;\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":";;AAWO,SAAS,sBACd,CAAA,QAAA,EACA,OAAsC,GAAA,EACV,EAAA;AAC5B,EAAM,MAAA,EAAE,SAAY,GAAA,QAAA,CAAA;AACpB,EAAA,MAAM,WAAc,GAAA,OAAA,CAAQ,GAAI,CAAA,cAAc,CAAK,IAAA,UAAA,CAAA;AACnD,EAAM,MAAA,IAAA,GAAO,UAAU,WAAW,CAAA,CAAA;AAClC,EAAI,IAAA,IAAA,CAAK,SAAS,UAAY,EAAA;AAC5B,IAAA,MAAM,IAAI,UAAA,CAAW,CAAuB,oBAAA,EAAA,WAAW,CAAG,CAAA,CAAA,CAAA,CAAA;AAAA,GAC5D;AACA,EAAA,MAAM,aACH,GAAA,OAAA,CAAQ,GAAI,CAAA,kBAAkB,CAA2B,IAAA,KAAA,CAAA,CAAA;AAC5D,EAAM,MAAA,OAAA,GAAU,IAAK,CAAA,UAAA,CAAW,OAAW,IAAA,OAAA,CAAA;AAG3C,EAAO,OAAA;AAAA,IACL,aAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG,OAAA;AAAA,GACL,CAAA;AACF;;;;"}

package/dist/es/parseBinaryToArraySync.js

@@ -1,9 +1,14 @@
-import { convertBinaryToString } from './convertBinaryToString.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { parseStringToArraySync } from './parseStringToArraySync.js';
+import { convertBinaryToString } from './utils/convertBinaryToString.js';
 
 function parseBinaryToArraySync(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToArraySync(csv, options);
+  try {
+    const csv = convertBinaryToString(binary, options);
+    return parseStringToArraySync(csv, options);
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseBinaryToArraySync };

package/dist/es/parseBinaryToArraySync.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToArraySync.js","sources":["../../src/parseBinaryToArraySync.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\n\nexport function parseBinaryToArraySync<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): CSVRecord<Header>[] {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToArraySync(csv, options);\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,sBACd,CAAA,MAAA,EACA,OAAsC,GAAA,EACjB,EAAA;AACrB,EAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AACjD,EAAO,OAAA,sBAAA,CAAuB,KAAK,OAAO,CAAA,CAAA;AAC5C;;;;"}
+{"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\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":";;;;AAKO,SAAS,sBACd,CAAA,MAAA,EACA,OAAsC,GAAA,EACjB,EAAA;AACrB,EAAI,IAAA;AACF,IAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AACjD,IAAO,OAAA,sBAAA,CAAuB,KAAK,OAAO,CAAA,CAAA;AAAA,WACnC,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseBinaryToIterableIterator.js

@@ -1,9 +1,14 @@
-import { convertBinaryToString } from './convertBinaryToString.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { parseStringToIterableIterator } from './parseStringToIterableIterator.js';
+import { convertBinaryToString } from './utils/convertBinaryToString.js';
 
 function parseBinaryToIterableIterator(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToIterableIterator(csv, options);
+  try {
+    const csv = convertBinaryToString(binary, options);
+    return parseStringToIterableIterator(csv, options);
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseBinaryToIterableIterator };

package/dist/es/parseBinaryToIterableIterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToIterableIterator.js","sources":["../../src/parseBinaryToIterableIterator.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\n\nexport function parseBinaryToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): IterableIterator<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToIterableIterator(csv, options);\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,6BAGd,CAAA,MAAA,EACA,OAAsC,GAAA,EACD,EAAA;AACrC,EAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AACjD,EAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA,CAAA;AACnD;;;;"}
+{"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 {ParseError} When an error occurs while parsing the CSV data.\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":";;;;AAaO,SAAS,6BAGd,CAAA,MAAA,EACA,OAAsC,GAAA,EACD,EAAA;AACrC,EAAI,IAAA;AACF,IAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AACjD,IAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA,CAAA;AAAA,WAC1C,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseBinaryToStream.js

@@ -1,9 +1,14 @@
-import { convertBinaryToString } from './convertBinaryToString.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { parseStringToStream } from './parseStringToStream.js';
+import { convertBinaryToString } from './utils/convertBinaryToString.js';
 
 function parseBinaryToStream(binary, options = {}) {
-  const csv = convertBinaryToString(binary, options);
-  return parseStringToStream(csv, options);
+  try {
+    const csv = convertBinaryToString(binary, options);
+    return parseStringToStream(csv, options);
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseBinaryToStream };

package/dist/es/parseBinaryToStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseBinaryToStream.js","sources":["../../src/parseBinaryToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { convertBinaryToString } from \"./convertBinaryToString.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\n\nexport function parseBinaryToStream<Header extends ReadonlyArray<string>>(\n  binary: Uint8Array | ArrayBuffer,\n  options: ParseBinaryOptions<Header> = {},\n): ReadableStream<CSVRecord<Header>> {\n  const csv = convertBinaryToString(binary, options);\n  return parseStringToStream(csv, options);\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,mBACd,CAAA,MAAA,EACA,OAAsC,GAAA,EACH,EAAA;AACnC,EAAM,MAAA,GAAA,GAAM,qBAAsB,CAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AACjD,EAAO,OAAA,mBAAA,CAAoB,KAAK,OAAO,CAAA,CAAA;AACzC;;;;"}
+{"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,CAAA;AACjD,IAAO,OAAA,mBAAA,CAAoB,KAAK,OAAO,CAAA,CAAA;AAAA,WAChC,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseResponse.js

@@ -1,14 +1,19 @@
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { getOptionsFromResponse } from './getOptionsFromResponse.js';
 import { parseResponseToStream } from './parseResponseToStream.js';
 import { parseUint8ArrayStream } from './parseUint8ArrayStream.js';
 import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
 
 function parseResponse(response, options) {
-  const options_ = getOptionsFromResponse(response, options);
-  if (response.body === null) {
-    throw new Error("Response body is null");
+  try {
+    const options_ = getOptionsFromResponse(response, options);
+    if (response.body === null) {
+      throw new RangeError("Response body is null");
+    }
+    return parseUint8ArrayStream(response.body, options_);
+  } catch (error) {
+    commonParseErrorHandling(error);
   }
-  return parseUint8ArrayStream(response.body, options_);
 }
 Object.defineProperties(parseResponse, {
   toArray: {

package/dist/es/parseResponse.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponse.js","sources":["../../src/parseResponse.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseResponseToStream } from \"./parseResponseToStream.ts\";\nimport { parseUint8ArrayStream } from \"./parseUint8ArrayStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse HTTP Response what contains CSV to records,\n * ideal for smaller data sets.\n *\n * @remarks\n * This function automatically treats response headers.\n *\n * - If `Content-Type` header is not set, it assumes `text/csv`.\n * - If `Content-Type` header is not `text/csv`, it throws an error.\n * - If `Content-Type` header has charset parameter, it uses it for decoding.\n * - If `Content-Encoding` header is set, it decompresses the response.\n * - Should there be any conflicting information between the header and the options, the option's value will take precedence.\n *\n * @category Middle-level API\n * @param response\n * @param options\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseResponse.toArray} function.\n *\n * @example Parsing CSV Response\n *\n * ```ts\n * import { parseResponse } from 'web-csv-toolbox';\n *\n * const response = await fetch('https://example.com/data.csv');\n *\n * for await (const record of parseResponse(response)) {\n *   console.log(record);\n * }\n * ```\n */\nexport function parseResponse<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStream(response.body, options_);\n}\n\nexport declare namespace parseResponse {\n  /**\n   * Parse CSV Response to array of records.\n   *\n   * @returns Array of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * const records = await parseResponse.toArray(response);\n   * console.log(records);\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV Response to stream of records.\n   *\n   * @param response Response to parse\n   * @returns Stream of records\n   *\n   * @example Parsing CSV Response\n   *\n   * ```ts\n   * import { parseResponse } from 'web-csv-toolbox';\n   *\n   * const response = await fetch('https://example.com/data.csv');\n   *\n   * await parseResponse.toStream(response)\n   *   .pipeTo(\n   *     new WritableStream({\n   *       write(record) {\n   *         console.log(record);\n   *       },\n   *    }),\n   * );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    response: Response,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>[]>;\n}\n\nObject.defineProperties(parseResponse, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toStreamSync: {\n    enumerable: true,\n    writable: false,\n    value: parseResponseToStream,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;AAsCgB,SAAA,aAAA,CACd,UACA,OAC0C,EAAA;AAC1C,EAAM,MAAA,QAAA,GAAW,sBAAuB,CAAA,QAAA,EAAU,OAAO,CAAA,CAAA;AACzD,EAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,IAAM,MAAA,IAAI,MAAM,uBAAuB,CAAA,CAAA;AAAA,GACzC;AACA,EAAO,OAAA,qBAAA,CAAsB,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AACtD,CAAA;AAuDA,MAAA,CAAO,iBAAiB,aAAe,EAAA;AAAA,EACrC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,YAAc,EAAA;AAAA,IACZ,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,qBAAA;AAAA,GACT;AACF,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  try {\n    const options_ = getOptionsFromResponse(response, options);\n    if (response.body === null) {\n      throw new RangeError(\"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,CAAA;AACzD,IAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,MAAM,MAAA,IAAI,WAAW,uBAAuB,CAAA,CAAA;AAAA,KAC9C;AACA,IAAO,OAAA,qBAAA,CAAsB,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAAA,WAC7C,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF,CAAA;AAuDA,MAAA,CAAO,iBAAiB,aAAe,EAAA;AAAA,EACrC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,YAAc,EAAA;AAAA,IACZ,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,qBAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}

package/dist/es/parseResponseToStream.js

@@ -1,12 +1,17 @@
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { getOptionsFromResponse } from './getOptionsFromResponse.js';
 import { parseUint8ArrayStreamToStream } from './parseUint8ArrayStreamToStream.js';
 
 function parseResponseToStream(response, options) {
-  const options_ = getOptionsFromResponse(response, options);
-  if (response.body === null) {
-    throw new Error("Response body is null");
+  try {
+    const options_ = getOptionsFromResponse(response, options);
+    if (response.body === null) {
+      throw new RangeError("Response body is null");
+    }
+    return parseUint8ArrayStreamToStream(response.body, options_);
+  } catch (error) {
+    commonParseErrorHandling(error);
   }
-  return parseUint8ArrayStreamToStream(response.body, options_);
 }
 
 export { parseResponseToStream };

package/dist/es/parseResponseToStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseResponseToStream.js","sources":["../../src/parseResponseToStream.ts"],"sourcesContent":["import type { CSVRecord, ParseBinaryOptions } from \"./common/types.ts\";\nimport { getOptionsFromResponse } from \"./getOptionsFromResponse.ts\";\nimport { parseUint8ArrayStreamToStream } from \"./parseUint8ArrayStreamToStream.ts\";\n\nexport function parseResponseToStream<Header extends ReadonlyArray<string>>(\n  response: Response,\n  options?: ParseBinaryOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const options_ = getOptionsFromResponse(response, options);\n  if (response.body === null) {\n    throw new Error(\"Response body is null\");\n  }\n  return parseUint8ArrayStreamToStream(response.body, options_);\n}\n"],"names":[],"mappings":";;;AAIgB,SAAA,qBAAA,CACd,UACA,OACmC,EAAA;AACnC,EAAM,MAAA,QAAA,GAAW,sBAAuB,CAAA,QAAA,EAAU,OAAO,CAAA,CAAA;AACzD,EAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,IAAM,MAAA,IAAI,MAAM,uBAAuB,CAAA,CAAA;AAAA,GACzC;AACA,EAAO,OAAA,6BAAA,CAA8B,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAC9D;;;;"}
+{"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 RangeError(\"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,CAAA;AACzD,IAAI,IAAA,QAAA,CAAS,SAAS,IAAM,EAAA;AAC1B,MAAM,MAAA,IAAI,WAAW,uBAAuB,CAAA,CAAA;AAAA,KAC9C;AACA,IAAO,OAAA,6BAAA,CAA8B,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA,CAAA;AAAA,WACrD,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseString.js

@@ -1,10 +1,15 @@
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 import { parseStringToArraySync } from './parseStringToArraySync.js';
 import { parseStringToIterableIterator } from './parseStringToIterableIterator.js';
 import { parseStringToStream } from './parseStringToStream.js';
 import { convertThisAsyncIterableIteratorToArray } from './utils/convertThisAsyncIterableIteratorToArray.js';
 
 async function* parseString(csv, options) {
-  yield* parseStringToIterableIterator(csv, options);
+  try {
+    yield* parseStringToIterableIterator(csv, options);
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 Object.defineProperties(parseString, {
   toArray: {

package/dist/es/parseString.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseString.js","sources":["../../src/parseString.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string to records.\n *\n * @category Middle-level API\n * @param csv CSV string to parse\n * @param options Parsing options. See {@link ParseOptions}.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseString.toArray} function.\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseString } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parseString(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport async function* parseString<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  yield* parseStringToIterableIterator(csv, options);\n}\nexport declare namespace parseString {\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parseString.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = parseString.toArraySync(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): CSVRecord<Header>[];\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Async iterable iterator of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * for (const record of parseString.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Readable stream of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * await parseString.toStream(csv)\n   *   .pipeTo(\n   *      new WritableStream({\n   *        write(record) {\n   *          console.log(record);\n   *        },\n   *      }),\n   *   );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\nObject.defineProperties(parseString, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToStream,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;AAgCuB,gBAAA,WAAA,CACrB,KACA,OAC0C,EAAA;AAC1C,EAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA,CAAA;AACnD,CAAA;AAyGA,MAAA,CAAO,iBAAiB,WAAa,EAAA;AAAA,EACnC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,WAAa,EAAA;AAAA,IACX,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,sBAAA;AAAA,GACT;AAAA,EACA,kBAAoB,EAAA;AAAA,IAClB,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,6BAAA;AAAA,GACT;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,mBAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}
+{"version":3,"file":"parseString.js","sources":["../../src/parseString.ts"],"sourcesContent":["import type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\nimport { parseStringToArraySync } from \"./parseStringToArraySync.ts\";\nimport { parseStringToIterableIterator } from \"./parseStringToIterableIterator.ts\";\nimport { parseStringToStream } from \"./parseStringToStream.ts\";\nimport * as internal from \"./utils/convertThisAsyncIterableIteratorToArray.ts\";\n\n/**\n * Parse CSV string to records.\n *\n * @category Middle-level API\n * @param csv CSV string to parse\n * @param options Parsing options. See {@link ParseOptions}.\n * @returns Async iterable iterator of records.\n *\n * If you want array of records, use {@link parseString.toArray} function.\n * @example Parsing CSV files from strings\n *\n * ```ts\n * import { parseString } from 'web-csv-toolbox';\n *\n * const csv = `name,age\n * Alice,42\n * Bob,69`;\n *\n * for await (const record of parseString(csv)) {\n *   console.log(record);\n * }\n * // Prints:\n * // { name: 'Alice', age: '42' }\n * // { name: 'Bob', age: '69' }\n * ```\n */\nexport async function* parseString<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): AsyncIterableIterator<CSVRecord<Header>> {\n  try {\n    yield* parseStringToIterableIterator(csv, options);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\nexport declare namespace parseString {\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = await parseString.toArray(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArray<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): Promise<CSVRecord<Header>[]>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Array of records\n   *\n   * @example\n   *\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * const records = parseString.toArraySync(csv);\n   * console.log(records);\n   * // Prints:\n   * // [ { name: 'Alice', age: '42' }, { name: 'Bob', age: '69' } ]\n   * ```\n   */\n  export function toArraySync<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): CSVRecord<Header>[];\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Async iterable iterator of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * for (const record of parseString.toIterableIterator(csv)) {\n   *   console.log(record);\n   * }\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toIterableIterator<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): IterableIterator<CSVRecord<Header>>;\n  /**\n   * Parse CSV string to records.\n   *\n   * @returns Readable stream of records\n   *\n   * @example\n   * ```ts\n   * import { parseString } from 'web-csv-toolbox';\n   *\n   * const csv = `name,age\n   * Alice,42\n   * Bob,69`;\n   *\n   * await parseString.toStream(csv)\n   *   .pipeTo(\n   *      new WritableStream({\n   *        write(record) {\n   *          console.log(record);\n   *        },\n   *      }),\n   *   );\n   * // Prints:\n   * // { name: 'Alice', age: '42' }\n   * // { name: 'Bob', age: '69' }\n   * ```\n   */\n  export function toStream<Header extends ReadonlyArray<string>>(\n    csv: string,\n    options?: ParseOptions<Header>,\n  ): ReadableStream<CSVRecord<Header>>;\n}\nObject.defineProperties(parseString, {\n  toArray: {\n    enumerable: true,\n    writable: false,\n    value: internal.convertThisAsyncIterableIteratorToArray,\n  },\n  toArraySync: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToArraySync,\n  },\n  toIterableIterator: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToIterableIterator,\n  },\n  toStream: {\n    enumerable: true,\n    writable: false,\n    value: parseStringToStream,\n  },\n});\n"],"names":["internal.convertThisAsyncIterableIteratorToArray"],"mappings":";;;;;;AAiCuB,gBAAA,WAAA,CACrB,KACA,OAC0C,EAAA;AAC1C,EAAI,IAAA;AACF,IAAO,OAAA,6BAAA,CAA8B,KAAK,OAAO,CAAA,CAAA;AAAA,WAC1C,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF,CAAA;AAyGA,MAAA,CAAO,iBAAiB,WAAa,EAAA;AAAA,EACnC,OAAS,EAAA;AAAA,IACP,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,OAAOA,uCAAS;AAAA,GAClB;AAAA,EACA,WAAa,EAAA;AAAA,IACX,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,sBAAA;AAAA,GACT;AAAA,EACA,kBAAoB,EAAA;AAAA,IAClB,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,6BAAA;AAAA,GACT;AAAA,EACA,QAAU,EAAA;AAAA,IACR,UAAY,EAAA,IAAA;AAAA,IACZ,QAAU,EAAA,KAAA;AAAA,IACV,KAAO,EAAA,mBAAA;AAAA,GACT;AACF,CAAC,CAAA;;;;"}

package/dist/es/parseStringToArraySync.js

@@ -1,11 +1,16 @@
 import { Lexer } from './Lexer.js';
 import { RecordAssembler } from './RecordAssembler.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 
 function parseStringToArraySync(csv, options) {
-  const lexer = new Lexer(options);
-  const assembler = new RecordAssembler(options);
-  const tokens = lexer.lex(csv);
-  return [...assembler.assemble(tokens)];
+  try {
+    const lexer = new Lexer(options);
+    const assembler = new RecordAssembler(options);
+    const tokens = lexer.lex(csv);
+    return [...assembler.assemble(tokens)];
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseStringToArraySync };

package/dist/es/parseStringToArraySync.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToArraySync.js","sources":["../../src/parseStringToArraySync.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToArraySync<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): CSVRecord<Header>[] {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return [...assembler.assemble(tokens)];\n}\n"],"names":[],"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;;;;"}
+{"version":3,"file":"parseStringToArraySync.js","sources":["../../src/parseStringToArraySync.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\n\nexport function parseStringToArraySync<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): CSVRecord<Header>[] {\n  try {\n    const lexer = new Lexer(options);\n    const assembler = new RecordAssembler(options);\n    const tokens = lexer.lex(csv);\n    return [...assembler.assemble(tokens)];\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAKgB,SAAA,sBAAA,CACd,KACA,OACqB,EAAA;AACrB,EAAI,IAAA;AACF,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,IAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,IAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,IAAA,OAAO,CAAC,GAAG,SAAU,CAAA,QAAA,CAAS,MAAM,CAAC,CAAA,CAAA;AAAA,WAC9B,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseStringToArraySyncWASM.js

@@ -1,14 +1,21 @@
 import { parseStringToArraySync } from './_virtual/_web-csv-toolbox-wasm.js';
+import { assertCommonOptions } from './assertCommonOptions.js';
+import { InvalidOptionError } from './common/errors.js';
 import { DOUBLE_QUOTE, COMMA } from './constants.js';
 
 function parseStringToArraySyncWASM(csv, options = {}) {
   const { delimiter = COMMA, quotation = DOUBLE_QUOTE } = options;
   if (typeof delimiter !== "string" || delimiter.length !== 1) {
-    throw new Error("Invalid delimiter, must be a single character on WASM.");
+    throw new InvalidOptionError(
+      "Invalid delimiter, must be a single character on WASM."
+    );
   }
   if (quotation !== DOUBLE_QUOTE) {
-    throw new Error("Invalid quotation, must be double quote on WASM.");
+    throw new InvalidOptionError(
+      "Invalid quotation, must be double quote on WASM."
+    );
   }
+  assertCommonOptions({ delimiter, quotation });
   const demiliterCode = delimiter.charCodeAt(0);
   return JSON.parse(parseStringToArraySync(csv, demiliterCode));
 }

package/dist/es/parseStringToArraySyncWASM.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToArraySyncWASM.js","sources":["../../src/parseStringToArraySyncWASM.ts"],"sourcesContent":["import { parseStringToArraySync } from \"web-csv-toolbox-wasm\";\nimport type { CSVRecord, CommonOptions } from \"./common/types.ts\";\nimport { COMMA, DOUBLE_QUOTE } from \"./constants.ts\";\nimport type { loadWASM } from \"./loadWASM.ts\";\n\n/**\n * Parse CSV string to record of arrays.\n *\n * @param csv CSV string\n * @param options Parse options\n * @returns Record of arrays\n *\n * @remarks\n * This function uses WebAssembly to parse CSV string.\n * Before calling this function, you must call {@link loadWASM} function.\n *\n * This function only supports UTF-8 string.\n * If you pass a string that is not UTF-8, like UTF-16, it throws an error.\n * This function only supports double quote as quotation.\n * So, `options.quotation` must be `\"` (double quote). Otherwise, it throws an error.\n *\n * And this function only supports single character as delimiter.\n * So, `options.delimiter` must be a single character. Otherwise, it throws an error.\n *\n * @example\n *\n * ```ts\n * import { loadWASM, parseStringWASM } from \"web-csv-toolbox\";\n *\n * await loadWASM();\n *\n * const csv = \"a,b,c\\n1,2,3\";\n *\n * const result = parseStringToArraySyncWASM(csv);\n * console.log(result);\n * // Prints:\n * // [{ a: \"1\", b: \"2\", c: \"3\" }]\n * ```\n * @beta\n */\nexport function parseStringToArraySyncWASM<Header extends readonly string[]>(\n  csv: string,\n  options: CommonOptions = {},\n): CSVRecord<Header>[] {\n  const { delimiter = COMMA, quotation = DOUBLE_QUOTE } = options;\n  if (typeof delimiter !== \"string\" || delimiter.length !== 1) {\n    throw new Error(\"Invalid delimiter, must be a single character on WASM.\");\n  }\n  if (quotation !== DOUBLE_QUOTE) {\n    throw new Error(\"Invalid quotation, must be double quote on WASM.\");\n  }\n  const demiliterCode = delimiter.charCodeAt(0);\n  return JSON.parse(parseStringToArraySync(csv, demiliterCode));\n}\n"],"names":[],"mappings":";;;AAwCO,SAAS,0BACd,CAAA,GAAA,EACA,OAAyB,GAAA,EACJ,EAAA;AACrB,EAAA,MAAM,EAAE,SAAA,GAAY,KAAO,EAAA,SAAA,GAAY,cAAiB,GAAA,OAAA,CAAA;AACxD,EAAA,IAAI,OAAO,SAAA,KAAc,QAAY,IAAA,SAAA,CAAU,WAAW,CAAG,EAAA;AAC3D,IAAM,MAAA,IAAI,MAAM,wDAAwD,CAAA,CAAA;AAAA,GAC1E;AACA,EAAA,IAAI,cAAc,YAAc,EAAA;AAC9B,IAAM,MAAA,IAAI,MAAM,kDAAkD,CAAA,CAAA;AAAA,GACpE;AACA,EAAM,MAAA,aAAA,GAAgB,SAAU,CAAA,UAAA,CAAW,CAAC,CAAA,CAAA;AAC5C,EAAA,OAAO,IAAK,CAAA,KAAA,CAAM,sBAAuB,CAAA,GAAA,EAAK,aAAa,CAAC,CAAA,CAAA;AAC9D;;;;"}
+{"version":3,"file":"parseStringToArraySyncWASM.js","sources":["../../src/parseStringToArraySyncWASM.ts"],"sourcesContent":["import { parseStringToArraySync } from \"web-csv-toolbox-wasm\";\nimport { assertCommonOptions } from \"./assertCommonOptions.ts\";\nimport { InvalidOptionError } from \"./common/errors.ts\";\nimport type { CSVRecord, CommonOptions } from \"./common/types.ts\";\nimport { COMMA, DOUBLE_QUOTE } from \"./constants.ts\";\nimport type { loadWASM } from \"./loadWASM.ts\";\n\n/**\n * Parse CSV string to record of arrays.\n *\n * @param csv CSV string\n * @param options Parse options\n * @returns Record of arrays\n *\n * @remarks\n * This function uses WebAssembly to parse CSV string.\n * Before calling this function, you must call {@link loadWASM} function.\n *\n * This function only supports UTF-8 string.\n * If you pass a string that is not UTF-8, like UTF-16, it throws an error.\n * This function only supports double quote as quotation.\n * So, `options.quotation` must be `\"` (double quote). Otherwise, it throws an error.\n *\n * And this function only supports single character as delimiter.\n * So, `options.delimiter` must be a single character. Otherwise, it throws an error.\n *\n * @example\n *\n * ```ts\n * import { loadWASM, parseStringWASM } from \"web-csv-toolbox\";\n *\n * await loadWASM();\n *\n * const csv = \"a,b,c\\n1,2,3\";\n *\n * const result = parseStringToArraySyncWASM(csv);\n * console.log(result);\n * // Prints:\n * // [{ a: \"1\", b: \"2\", c: \"3\" }]\n * ```\n * @beta\n */\nexport function parseStringToArraySyncWASM<Header extends readonly string[]>(\n  csv: string,\n  options: CommonOptions = {},\n): CSVRecord<Header>[] {\n  const { delimiter = COMMA, quotation = DOUBLE_QUOTE } = options;\n  if (typeof delimiter !== \"string\" || delimiter.length !== 1) {\n    throw new InvalidOptionError(\n      \"Invalid delimiter, must be a single character on WASM.\",\n    );\n  }\n  if (quotation !== DOUBLE_QUOTE) {\n    throw new InvalidOptionError(\n      \"Invalid quotation, must be double quote on WASM.\",\n    );\n  }\n  assertCommonOptions({ delimiter, quotation });\n  const demiliterCode = delimiter.charCodeAt(0);\n  return JSON.parse(parseStringToArraySync(csv, demiliterCode));\n}\n"],"names":[],"mappings":";;;;;AA0CO,SAAS,0BACd,CAAA,GAAA,EACA,OAAyB,GAAA,EACJ,EAAA;AACrB,EAAA,MAAM,EAAE,SAAA,GAAY,KAAO,EAAA,SAAA,GAAY,cAAiB,GAAA,OAAA,CAAA;AACxD,EAAA,IAAI,OAAO,SAAA,KAAc,QAAY,IAAA,SAAA,CAAU,WAAW,CAAG,EAAA;AAC3D,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,wDAAA;AAAA,KACF,CAAA;AAAA,GACF;AACA,EAAA,IAAI,cAAc,YAAc,EAAA;AAC9B,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,kDAAA;AAAA,KACF,CAAA;AAAA,GACF;AACA,EAAoB,mBAAA,CAAA,EAAE,SAAW,EAAA,SAAA,EAAW,CAAA,CAAA;AAC5C,EAAM,MAAA,aAAA,GAAgB,SAAU,CAAA,UAAA,CAAW,CAAC,CAAA,CAAA;AAC5C,EAAA,OAAO,IAAK,CAAA,KAAA,CAAM,sBAAuB,CAAA,GAAA,EAAK,aAAa,CAAC,CAAA,CAAA;AAC9D;;;;"}

package/dist/es/parseStringToIterableIterator.js

@@ -1,11 +1,16 @@
 import { Lexer } from './Lexer.js';
 import { RecordAssembler } from './RecordAssembler.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.js';
 
 function parseStringToIterableIterator(csv, options) {
-  const lexer = new Lexer(options);
-  const assembler = new RecordAssembler(options);
-  const tokens = lexer.lex(csv);
-  return assembler.assemble(tokens);
+  try {
+    const lexer = new Lexer(options);
+    const assembler = new RecordAssembler(options);
+    const tokens = lexer.lex(csv);
+    return assembler.assemble(tokens);
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseStringToIterableIterator };

package/dist/es/parseStringToIterableIterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToIterableIterator.js","sources":["../../src/parseStringToIterableIterator.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): IterableIterator<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  const tokens = lexer.lex(csv);\n  return assembler.assemble(tokens);\n}\n"],"names":[],"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;;;;"}
+{"version":3,"file":"parseStringToIterableIterator.js","sources":["../../src/parseStringToIterableIterator.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\n\nexport function parseStringToIterableIterator<\n  Header extends ReadonlyArray<string>,\n>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): IterableIterator<CSVRecord<Header>> {\n  try {\n    const lexer = new Lexer(options);\n    const assembler = new RecordAssembler(options);\n    const tokens = lexer.lex(csv);\n    return assembler.assemble(tokens);\n  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAKgB,SAAA,6BAAA,CAGd,KACA,OACqC,EAAA;AACrC,EAAI,IAAA;AACF,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,IAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,IAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,IAAO,OAAA,SAAA,CAAU,SAAS,MAAM,CAAA,CAAA;AAAA,WACzB,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

package/dist/es/parseStringToStream.js

@@ -1,18 +1,23 @@
 import { Lexer } from './Lexer.js';
 import { RecordAssembler } from './RecordAssembler.js';
+import { commonParseErrorHandling } from './commonParseErrorHandling.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);
+  try {
+    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();
       }
-      controller.close();
-    }
-  });
+    });
+  } catch (error) {
+    commonParseErrorHandling(error);
+  }
 }
 
 export { parseStringToStream };

package/dist/es/parseStringToStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseStringToStream.js","sources":["../../src/parseStringToStream.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\n\nexport function parseStringToStream<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  const lexer = new Lexer(options);\n  const assembler = new RecordAssembler(options);\n  return new ReadableStream({\n    start(controller) {\n      const tokens = lexer.lex(csv);\n      for (const record of assembler.assemble(tokens)) {\n        controller.enqueue(record);\n      }\n      controller.close();\n    },\n  });\n}\n"],"names":[],"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;;;;"}
+{"version":3,"file":"parseStringToStream.js","sources":["../../src/parseStringToStream.ts"],"sourcesContent":["import { Lexer } from \"./Lexer.ts\";\nimport { RecordAssembler } from \"./RecordAssembler.ts\";\nimport type { CSVRecord, ParseOptions } from \"./common/types.ts\";\nimport { commonParseErrorHandling } from \"./commonParseErrorHandling.ts\";\n\nexport function parseStringToStream<Header extends ReadonlyArray<string>>(\n  csv: string,\n  options?: ParseOptions<Header>,\n): ReadableStream<CSVRecord<Header>> {\n  try {\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  } catch (error) {\n    commonParseErrorHandling(error);\n  }\n}\n"],"names":[],"mappings":";;;;AAKgB,SAAA,mBAAA,CACd,KACA,OACmC,EAAA;AACnC,EAAI,IAAA;AACF,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA,CAAA;AAC/B,IAAM,MAAA,SAAA,GAAY,IAAI,eAAA,CAAgB,OAAO,CAAA,CAAA;AAC7C,IAAA,OAAO,IAAI,cAAe,CAAA;AAAA,MACxB,MAAM,UAAY,EAAA;AAChB,QAAM,MAAA,MAAA,GAAS,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC5B,QAAA,KAAA,MAAW,MAAU,IAAA,SAAA,CAAU,QAAS,CAAA,MAAM,CAAG,EAAA;AAC/C,UAAA,UAAA,CAAW,QAAQ,MAAM,CAAA,CAAA;AAAA,SAC3B;AACA,QAAA,UAAA,CAAW,KAAM,EAAA,CAAA;AAAA,OACnB;AAAA,KACD,CAAA,CAAA;AAAA,WACM,KAAO,EAAA;AACd,IAAA,wBAAA,CAAyB,KAAK,CAAA,CAAA;AAAA,GAChC;AACF;;;;"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"convertBinaryToString.js","sources":["../../../src/utils/convertBinaryToString.ts"],"sourcesContent":["import type { BinaryOptions } from \"../common/types.ts\";\n\n/**\n * Converts a binary string to a string.\n *\n * @param binary - The binary string to convert.\n * @param options - The options for parsing the binary string.\n * @returns The converted string.\n * @throws {RangeError} The given charset is not supported.\n * @throws {TypeError} The encoded data was not valid.\n */\nexport function convertBinaryToString(\n  binary: Uint8Array | ArrayBuffer,\n  options: BinaryOptions,\n): string {\n  return new TextDecoder(options?.charset, {\n    ignoreBOM: options?.ignoreBOM,\n    fatal: options?.fatal,\n  }).decode(binary instanceof ArrayBuffer ? new Uint8Array(binary) : binary);\n}\n"],"names":[],"mappings":"AAWgB,SAAA,qBAAA,CACd,QACA,OACQ,EAAA;AACR,EAAO,OAAA,IAAI,WAAY,CAAA,OAAA,EAAS,OAAS,EAAA;AAAA,IACvC,WAAW,OAAS,EAAA,SAAA;AAAA,IACpB,OAAO,OAAS,EAAA,KAAA;AAAA,GACjB,EAAE,MAAO,CAAA,MAAA,YAAkB,cAAc,IAAI,UAAA,CAAW,MAAM,CAAA,GAAI,MAAM,CAAA,CAAA;AAC3E;;;;"}

package/dist/es/utils/pipeline.js

@@ -9,7 +9,7 @@ function pipeline(stream, ...transformers) {
           write: (v) => controller.enqueue(v),
           close: () => controller.close()
         })
-      ))();
+      ).catch((error) => controller.error(error)))();
     }
   });
 }

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

@@ -1 +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;;;;"}
+{"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          .catch((error) => controller.error(error)))();\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,OACH,CACC,MAAM,CAAC,KAAA,KAAU,WAAW,KAAM,CAAA,KAAK,CAAC,CAAG,GAAA,CAAA;AAAA,KAClD;AAAA,GACD,CAAA,CAAA;AACH;;;;"}

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

@@ -1,12 +1,13 @@
 export { Field, FieldDelimiter, RecordDelimiter } from './common/constants.js';
+export { InvalidOptionError, ParseError } from './common/errors.js';
 export { LexerTransformer } from './LexerTransformer.js';
-export { RecordAssemblerTransformer } from './RecordAssemblerTransformer.js';
-export { parseString } from './parseString.js';
+export { loadWASM } from './loadWASM.js';
+export { parse } from './parse.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';
-export { loadWASM } from './loadWASM.js';
+export { parseString } from './parseString.js';
+export { parseStringStream } from './parseStringStream.js';
 export { parseStringToArraySyncWASM } from './parseStringToArraySyncWASM.js';
+export { parseUint8ArrayStream } from './parseUint8ArrayStream.js';
+export { RecordAssemblerTransformer } from './RecordAssemblerTransformer.js';
 //# sourceMappingURL=web-csv-toolbox.js.map

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

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

package/dist/types/Lexer.d.ts

@@ -1,4 +1,5 @@
-import type { CommonOptions, Token } from "./common/types.ts";
+import { CommonOptions, Token } from './common/types.ts';
+
 /**
  * CSV Lexer.
  *

package/dist/types/LexerTransformer.d.ts

@@ -1,4 +1,6 @@
-import type { CommonOptions, Token } from "./common/types.ts";
+import { Lexer } from './Lexer.ts';
+import { CommonOptions, Token } from './common/types.ts';
+
 /**
  * A transform stream that converts a stream of tokens into a stream of rows.
  *
@@ -19,16 +21,17 @@ import type { CommonOptions, Token } from "./common/types.ts";
  *       console.log(token);
  *     }
  *   }}));
- * // { type: Field, value: "name" }
- * // FieldDelimiter
- * // { type: Field, value: "age" }
- * // RecordDelimiter
- * // { type: Field, value: "Alice" }
- * // FieldDelimiter
+ * // { type: Field, value: "name", location: {...} }
+ * // { type: FieldDelimiter, value: ",", location: {...} }
+ * // { type: Field, value: "age", location: {...} }
+ * // { type: RecordDelimiter, value: "\r\n", location: {...} }
+ * // { type: Field, value: "Alice", location: {...} }
+ * // { type: FieldDelimiter, value: ",", location: {...} }
  * // { type: Field, value: "20" }
- * // RecordDelimiter
+ * // { type: RecordDelimiter, value: "\r\n", location: {...} }
  * ```
  */
 export declare class LexerTransformer extends TransformStream<string, Token[]> {
+    readonly lexer: Lexer;
     constructor(options?: CommonOptions);
 }

package/dist/types/LexerTransformer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/RecordAssembler.d.ts

@@ -1,4 +1,5 @@
-import type { CSVRecord, RecordAssemblerOptions, Token } from "./common/types.ts";
+import { CSVRecord, RecordAssemblerOptions, Token } from './common/types.ts';
+
 export declare class RecordAssembler<Header extends ReadonlyArray<string>> {
     #private;
     constructor(options?: RecordAssemblerOptions<Header>);

package/dist/types/RecordAssemblerTransformer.d.ts

@@ -1,4 +1,6 @@
-import type { CSVRecord, RecordAssemblerOptions, Token } from "./common/types.ts";
+import { RecordAssembler } from './RecordAssembler.ts';
+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.
@@ -43,5 +45,6 @@ import type { CSVRecord, RecordAssemblerOptions, Token } from "./common/types.ts
  * ```
  */
 export declare class RecordAssemblerTransformer<Header extends ReadonlyArray<string>> extends TransformStream<Token[], CSVRecord<Header>> {
+    readonly assembler: RecordAssembler<Header>;
     constructor(options?: RecordAssemblerOptions<Header>);
 }

package/dist/types/assertCommonOptions.d.ts

@@ -1,4 +1,5 @@
-import type { CommonOptions } from "./common/types.ts";
+import { CommonOptions } from './common/types.ts';
+
 /**
  * Asserts that the provided options object contains all the required properties.
  * Throws an error if any required property is missing
@@ -15,6 +16,7 @@ import type { CommonOptions } from "./common/types.ts";
  * ```
  *
  * @param options - The options object to be validated.
- * @throws {Error} If any required property is missing or if the delimiter is the same as the quotation.
+ * @throws {InvalidOptionError} If any required property is missing or if the delimiter is the same as the quotation.
+ * @throws {TypeError} If any required property is not a string.
  */
 export declare function assertCommonOptions(options: Required<CommonOptions>): asserts options is Required<CommonOptions>;

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

@@ -0,0 +1,34 @@
+import { Position } from './types.js';
+
+/**
+ * Error class for invalid option errors.
+ */
+export declare class InvalidOptionError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Options for creating a parse error.
+ */
+export interface ParseErrorOptions extends ErrorOptions {
+    /**
+     * The position where the error occurred.
+     */
+    position?: Position;
+}
+/**
+ * Error class for parse errors.
+ *
+ * @remarks
+ * This error is thrown when a parsing error occurs.
+ * {@link ParseError} is a subclass of {@link !SyntaxError}.
+ *
+ * This is in reference to the specification
+ * that the error thrown when a parse error occurs in the {@link !JSON.parse} function is {@link !SyntaxError}.
+ */
+export declare class ParseError extends SyntaxError {
+    /**
+     * The position where the error occurred.
+     */
+    position?: Position;
+    constructor(message?: string, options?: ParseErrorOptions);
+}

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

@@ -1,4 +1,5 @@
-import type { Field, FieldDelimiter, RecordDelimiter } from "./constants.ts";
+import { Field, FieldDelimiter, RecordDelimiter } from './constants.ts';
+
 /**
  * Position object.
  */