web-csv-toolbox 0.5.0 → 0.5.2

package/{lib/index.js → dist/web-csv-toolbox.js}

@@ -1,11 +1,13 @@
 const FieldDelimiter = Symbol.for("web-csv-toolbox.FieldDelimiter");
 const RecordDelimiter = Symbol.for("web-csv-toolbox.RecordDelimiter");
 const Field = Symbol.for("web-csv-toolbox.Field");
+
 const CR = "\r";
 const CRLF = "\r\n";
 const LF = "\n";
 const COMMA = ",";
 const DOUBLE_QUOTE = '"';
+
 function assertCommonOptions(options) {
   if (typeof options.quotation === "string" && options.quotation.length === 0) {
     throw new Error("quotation must not be empty");
@@ -19,18 +21,17 @@ function assertCommonOptions(options) {
   if (options.delimiter.includes(LF) || options.delimiter.includes(CR)) {
     throw new Error("delimiter must not include CR or LF");
   }
-  if (
-    options.delimiter.includes(options.quotation) ||
-    options.quotation.includes(options.delimiter)
-  ) {
+  if (options.delimiter.includes(options.quotation) || options.quotation.includes(options.delimiter)) {
     throw new Error(
-      "delimiter and quotation must not include each other as a substring",
+      "delimiter and quotation must not include each other as a substring"
     );
   }
 }
+
 function escapeRegExp(v) {
   return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
 class Lexer {
   #delimiter;
   #delimiterLength;
@@ -39,7 +40,10 @@ class Lexer {
   #matcher;
   #buffer = "";
   #flush = false;
-  constructor({ delimiter = COMMA, quotation = DOUBLE_QUOTE } = {}) {
+  constructor({
+    delimiter = COMMA,
+    quotation = DOUBLE_QUOTE
+  } = {}) {
     assertCommonOptions({ delimiter, quotation });
     this.#delimiter = delimiter;
     this.#delimiterLength = delimiter.length;
@@ -48,7 +52,7 @@ class Lexer {
     const d = escapeRegExp(delimiter);
     const q = escapeRegExp(quotation);
     this.#matcher = new RegExp(
-      `^(?:(?!${q})(?!${d})(?![\\r\\n]))([\\S\\s\\uFEFF\\xA0]+?)(?=${q}|${d}|\\r|\\n|$)`,
+      `^(?:(?!${q})(?!${d})(?![\\r\\n]))([\\S\\s\\uFEFF\\xA0]+?)(?=${q}|${d}|\\r|\\n|$)`
     );
   }
   lex(chunk, buffering = false) {
@@ -73,7 +77,7 @@ class Lexer {
       }
     }
     let currentField = null;
-    for (let token; (token = this.#nextToken()); ) {
+    for (let token; token = this.#nextToken(); ) {
       switch (token) {
         case FieldDelimiter:
           if (currentField) {
@@ -106,10 +110,7 @@ class Lexer {
     if (this.#buffer.length === 0) {
       return null;
     }
-    if (
-      this.#flush === false &&
-      (this.#buffer === CRLF || this.#buffer === LF)
-    ) {
+    if (this.#flush === false && (this.#buffer === CRLF || this.#buffer === LF)) {
       return null;
     }
     if (this.#buffer.startsWith(CRLF)) {
@@ -144,37 +145,25 @@ class Lexer {
     let end = this.#quotationLength;
     let value = "";
     while (end < this.#buffer.length) {
-      if (
-        this.#buffer.slice(end, end + this.#quotationLength) ===
-          this.#quotation &&
-        this.#buffer.slice(
-          end + this.#quotationLength,
-          end + this.#quotationLength * 2,
-        ) === this.#quotation
-      ) {
+      if (this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation && this.#buffer.slice(
+        end + this.#quotationLength,
+        end + this.#quotationLength * 2
+      ) === this.#quotation) {
         value += this.#quotation;
         end += this.#quotationLength * 2;
         continue;
       }
-      if (
-        this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation
-      ) {
-        if (
-          this.#flush === false &&
-          end + this.#quotationLength < this.#buffer.length &&
-          this.#buffer.slice(
-            end + this.#quotationLength,
-            this.#delimiterLength,
-          ) !== this.#delimiter &&
-          this.#buffer.slice(
-            end + this.#quotationLength,
-            end + this.#quotationLength + 2,
-          ) !== CRLF &&
-          this.#buffer.slice(
-            end + this.#quotationLength,
-            end + this.#quotationLength + 1,
-          ) !== LF
-        ) {
+      if (this.#buffer.slice(end, end + this.#quotationLength) === this.#quotation) {
+        if (this.#flush === false && end + this.#quotationLength < this.#buffer.length && this.#buffer.slice(
+          end + this.#quotationLength,
+          this.#delimiterLength
+        ) !== this.#delimiter && this.#buffer.slice(
+          end + this.#quotationLength,
+          end + this.#quotationLength + 2
+        ) !== CRLF && this.#buffer.slice(
+          end + this.#quotationLength,
+          end + this.#quotationLength + 1
+        ) !== LF) {
           return null;
         }
         this.#buffer = this.#buffer.slice(end + this.#quotationLength);
@@ -186,6 +175,7 @@ class Lexer {
     return null;
   }
 }
+
 class LexerTransformer extends TransformStream {
   constructor(options = {}) {
     const lexer = new Lexer(options);
@@ -197,17 +187,18 @@ class LexerTransformer extends TransformStream {
       },
       flush: (controller) => {
         controller.enqueue(lexer.flush());
-      },
+      }
     });
   }
 }
+
 class RecordAssembler {
   #fieldIndex = 0;
   #row = [];
   #header;
   #dirty = false;
   constructor(options = {}) {
-    if (options.header !== undefined && Array.isArray(options.header)) {
+    if (options.header !== void 0 && Array.isArray(options.header)) {
       this.#setHeader(options.header);
     }
   }
@@ -219,19 +210,19 @@ class RecordAssembler {
           this.#dirty = true;
           break;
         case RecordDelimiter:
-          if (this.#header === undefined) {
+          if (this.#header === void 0) {
             this.#setHeader(this.#row);
           } else {
             if (this.#dirty) {
               yield Object.fromEntries(
                 this.#header.map((header, index) => [
                   header,
-                  this.#row.at(index),
-                ]),
+                  this.#row.at(index)
+                ])
               );
             } else {
               yield Object.fromEntries(
-                this.#header.map((header) => [header, ""]),
+                this.#header.map((header) => [header, ""])
               );
             }
           }
@@ -250,12 +241,10 @@ class RecordAssembler {
     }
   }
   *flush() {
-    if (this.#header !== undefined) {
+    if (this.#header !== void 0) {
       if (this.#dirty) {
         yield Object.fromEntries(
-          this.#header
-            .filter((v) => v)
-            .map((header, index) => [header, this.#row.at(index)]),
+          this.#header.filter((v) => v).map((header, index) => [header, this.#row.at(index)])
         );
       }
     }
@@ -270,6 +259,7 @@ class RecordAssembler {
     }
   }
 }
+
 class RecordAssemblerTransformer extends TransformStream {
   constructor(options = {}) {
     const assembler = new RecordAssembler(options);
@@ -283,22 +273,25 @@ class RecordAssemblerTransformer extends TransformStream {
         for (const token of assembler.flush()) {
           controller.enqueue(token);
         }
-      },
+      }
     });
   }
 }
+
 function parseStringToArraySync(csv, options) {
   const lexer = new Lexer(options);
   const assembler = new RecordAssembler(options);
   const tokens = lexer.lex(csv);
   return [...assembler.assemble(tokens)];
 }
+
 function parseStringToIterableIterator(csv, options) {
   const lexer = new Lexer(options);
   const assembler = new RecordAssembler(options);
   const tokens = lexer.lex(csv);
   return assembler.assemble(tokens);
 }
+
 function parseStringToStream(csv, options) {
   const lexer = new Lexer(options);
   const assembler = new RecordAssembler(options);
@@ -309,9 +302,10 @@ function parseStringToStream(csv, options) {
         controller.enqueue(record);
       }
       controller.close();
-    },
+    }
   });
 }
+
 async function toArray(...args) {
   const rows = [];
   for await (const row of this(...args)) {
@@ -319,49 +313,55 @@ async function toArray(...args) {
   }
   return rows;
 }
+
 async function* parseString(csv, options) {
   yield* parseStringToIterableIterator(csv, options);
 }
-((parseString) => {
-  Object.defineProperty(parseString, "toArray", {
+((parseString2) => {
+  Object.defineProperty(parseString2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
-  Object.defineProperty(parseString, "toArraySync", {
+  Object.defineProperty(parseString2, "toArraySync", {
     enumerable: true,
     writable: false,
-    value: parseStringToArraySync,
+    value: parseStringToArraySync
   });
-  Object.defineProperty(parseString, "toIterableIterator", {
+  Object.defineProperty(parseString2, "toIterableIterator", {
     enumerable: true,
     writable: false,
-    value: parseStringToIterableIterator,
+    value: parseStringToIterableIterator
   });
-  Object.defineProperty(parseString, "toStream", {
+  Object.defineProperty(parseString2, "toStream", {
     enumerable: true,
     writable: false,
-    value: parseStringToStream,
+    value: parseStringToStream
   });
 })(parseString || (parseString = {}));
+
 function convertBinaryToString(binary, options) {
   return new TextDecoder(options?.charset, {
     ignoreBOM: options?.ignoreBOM,
-    fatal: options?.fatal,
+    fatal: options?.fatal
   }).decode(binary instanceof ArrayBuffer ? new Uint8Array(binary) : binary);
 }
+
 function parseBinaryToArraySync(binary, options = {}) {
   const csv = convertBinaryToString(binary, options);
   return parseStringToArraySync(csv, options);
 }
+
 function parseBinaryToIterableIterator(binary, options = {}) {
   const csv = convertBinaryToString(binary, options);
   return parseStringToIterableIterator(csv, options);
 }
+
 function parseBinaryToStream(binary, options = {}) {
   const csv = convertBinaryToString(binary, options);
   return parseStringToStream(csv, options);
 }
+
 function iterableIteratorToAsync(iterator) {
   return {
     async next() {
@@ -370,122 +370,126 @@ function iterableIteratorToAsync(iterator) {
     },
     [Symbol.asyncIterator]() {
       return this;
-    },
+    }
   };
 }
+
 function parseBinary(bytes, options) {
   const iterator = parseBinaryToIterableIterator(bytes, options);
   return iterableIteratorToAsync(iterator);
 }
-((parseBinary) => {
-  Object.defineProperty(parseBinary, "toArray", {
+((parseBinary2) => {
+  Object.defineProperty(parseBinary2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
-  Object.defineProperty(parseBinary, "toArraySync", {
+  Object.defineProperty(parseBinary2, "toArraySync", {
     enumerable: true,
     writable: false,
-    value: parseBinaryToArraySync,
+    value: parseBinaryToArraySync
   });
-  Object.defineProperty(parseBinary, "toIterableIterator", {
+  Object.defineProperty(parseBinary2, "toIterableIterator", {
     enumerable: true,
     writable: false,
-    value: parseBinaryToIterableIterator,
+    value: parseBinaryToIterableIterator
   });
-  Object.defineProperty(parseBinary, "toStream", {
+  Object.defineProperty(parseBinary2, "toStream", {
     enumerable: true,
     writable: false,
-    value: parseBinaryToStream,
+    value: parseBinaryToStream
   });
 })(parseBinary || (parseBinary = {}));
+
 function pipeline(stream, ...transformers) {
   return new ReadableStream({
     start: (controller) => {
-      (() =>
-        transformers
-          .reduce(
-            (stream, transformer) => stream.pipeThrough(transformer),
-            stream,
-          )
-          .pipeTo(
-            new WritableStream({
-              write: (v) => controller.enqueue(v),
-              close: () => controller.close(),
-            }),
-          ))();
-    },
+      (() => transformers.reduce(
+        (stream2, transformer) => stream2.pipeThrough(transformer),
+        stream
+      ).pipeTo(
+        new WritableStream({
+          write: (v) => controller.enqueue(v),
+          close: () => controller.close()
+        })
+      ))();
+    }
   });
 }
+
 function parseUint8ArrayStreamToStream(stream, options) {
   const { charset, fatal, ignoreBOM, decomposition } = options ?? {};
-  return decomposition
-    ? pipeline(
-        stream,
-        new DecompressionStream(decomposition),
-        new TextDecoderStream(charset, { fatal, ignoreBOM }),
-        new LexerTransformer(options),
-        new RecordAssemblerTransformer(options),
-      )
-    : pipeline(
-        stream,
-        new TextDecoderStream(charset, { fatal, ignoreBOM }),
-        new LexerTransformer(options),
-        new RecordAssemblerTransformer(options),
-      );
+  return decomposition ? pipeline(
+    stream,
+    new DecompressionStream(decomposition),
+    new TextDecoderStream(charset, { fatal, ignoreBOM }),
+    new LexerTransformer(options),
+    new RecordAssemblerTransformer(options)
+  ) : pipeline(
+    stream,
+    new TextDecoderStream(charset, { fatal, ignoreBOM }),
+    new LexerTransformer(options),
+    new RecordAssemblerTransformer(options)
+  );
 }
+
 async function* streamToAsyncIterableIterator(stream) {
   const reader = stream.getReader();
   while (true) {
     const { done, value } = await reader.read();
-    if (done) break;
+    if (done)
+      break;
     yield value;
   }
 }
+
 function parseUint8ArrayStream(stream, options) {
   const recordStream = parseUint8ArrayStreamToStream(stream, options);
   return streamToAsyncIterableIterator(recordStream);
 }
-((parseUint8ArrayStream) => {
-  Object.defineProperty(parseUint8ArrayStream, "toArray", {
+((parseUint8ArrayStream2) => {
+  Object.defineProperty(parseUint8ArrayStream2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
-  Object.defineProperty(parseUint8ArrayStream, "toStream", {
+  Object.defineProperty(parseUint8ArrayStream2, "toStream", {
     enumerable: true,
     writable: false,
-    value: parseUint8ArrayStreamToStream,
+    value: parseUint8ArrayStreamToStream
   });
 })(parseUint8ArrayStream || (parseUint8ArrayStream = {}));
+
 function parseStringStreamToStream(stream, options) {
   return pipeline(
     stream,
     new LexerTransformer(options),
-    new RecordAssemblerTransformer(options),
+    new RecordAssemblerTransformer(options)
   );
 }
+
 function parseStringStream(stream, options) {
   const recordStream = parseStringStreamToStream(stream, options);
   return streamToAsyncIterableIterator(recordStream);
 }
-((parseStringStream) => {
-  Object.defineProperty(parseStringStream, "toArray", {
+((parseStringStream2) => {
+  Object.defineProperty(parseStringStream2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
-  Object.defineProperty(parseStringStream, "toStream", {
+  Object.defineProperty(parseStringStream2, "toStream", {
     enumerable: true,
     writable: false,
-    value: parseStringStreamToStream,
+    value: parseStringStreamToStream
   });
 })(parseStringStream || (parseStringStream = {}));
+
 function parseMime(contentType) {
   const [type, ...parameters] = contentType.split(";");
   const result = {
     type: type.trim(),
-    parameters: {},
+    parameters: {}
   };
   for (const paramator of parameters) {
     const [key, value] = paramator.split("=");
@@ -493,6 +497,7 @@ function parseMime(contentType) {
   }
   return result;
 }
+
 function getOptionsFromResponse(response, options = {}) {
   const { headers } = response;
   const contentType = headers.get("content-type") ?? "text/csv";
@@ -500,14 +505,15 @@ function getOptionsFromResponse(response, options = {}) {
   if (mime.type !== "text/csv") {
     throw new Error(`Invalid mime type: ${contentType}`);
   }
-  const decomposition = headers.get("content-encoding") ?? undefined;
+  const decomposition = headers.get("content-encoding") ?? void 0;
   const charset = mime.parameters.charset ?? "utf-8";
   return {
     decomposition,
     charset,
-    ...options,
+    ...options
   };
 }
+
 function parseResponseToStream(response, options) {
   const options_ = getOptionsFromResponse(response, options);
   if (response.body === null) {
@@ -515,6 +521,7 @@ function parseResponseToStream(response, options) {
   }
   return parseUint8ArrayStreamToStream(response.body, options_);
 }
+
 function parseResponse(response, options) {
   const options_ = getOptionsFromResponse(response, options);
   if (response.body === null) {
@@ -522,18 +529,19 @@ function parseResponse(response, options) {
   }
   return parseUint8ArrayStream(response.body, options_);
 }
-((parseResponse) => {
-  Object.defineProperty(parseResponse, "toArray", {
+((parseResponse2) => {
+  Object.defineProperty(parseResponse2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
-  Object.defineProperty(parseResponse, "toStream", {
+  Object.defineProperty(parseResponse2, "toStream", {
     enumerable: true,
     writable: false,
-    value: parseResponseToStream,
+    value: parseResponseToStream
   });
 })(parseResponse || (parseResponse = {}));
+
 async function* parse(csv, options) {
   if (typeof csv === "string") {
     yield* parseString(csv, options);
@@ -547,29 +555,22 @@ async function* parse(csv, options) {
     if (typeof firstChunk === "string") {
       yield* parseStringStream(branch2, options);
     } else if (firstChunk instanceof Uint8Array) {
-      yield* parseUint8ArrayStream(branch2, options);
+      yield* parseUint8ArrayStream(
+        branch2,
+        options
+      );
     }
   } else if (csv instanceof Response) {
     yield* parseResponse(csv, options);
   }
 }
-((parse) => {
-  Object.defineProperty(parse, "toArray", {
+((parse2) => {
+  Object.defineProperty(parse2, "toArray", {
     enumerable: true,
     writable: false,
-    value: toArray,
+    value: toArray
   });
 })(parse || (parse = {}));
-export {
-  Field,
-  FieldDelimiter,
-  LexerTransformer,
-  RecordAssemblerTransformer,
-  RecordDelimiter,
-  parse,
-  parseBinary,
-  parseResponse,
-  parseString,
-  parseStringStream,
-  parseUint8ArrayStream,
-};
+
+export { Field, FieldDelimiter, LexerTransformer, RecordAssemblerTransformer, RecordDelimiter, parse, parseBinary, parseResponse, parseString, parseStringStream, parseUint8ArrayStream };
+//# sourceMappingURL=web-csv-toolbox.js.map