@teselagen/bio-parsers 0.4.23 → 0.4.25

package/index.js

@@ -4,7 +4,6 @@ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __pow = Math.pow;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -7927,7 +7926,7 @@ const calcTmMethods = {
    * monovalentCationConc - THe monovalent salt concentration. Defaults to 50e-3M.
    * return - Temperature for the given sequence, in Celsius.
    */
-  calculateTemperature: function(_sequence, { type, A, R, primerConc, monovalentCationConc } = {}) {
+  calculateTemperature: function(_sequence, { type, A, R: R2, primerConc, monovalentCationConc } = {}) {
     const sequence = (_sequence || "").toLowerCase();
     if (typeof type === "undefined") {
       type = this.TABLE_BRESLAUER;
@@ -7937,8 +7936,8 @@ const calcTmMethods = {
     if (!A) {
       A = this.A;
     }
-    if (!R) {
-      R = this.R;
+    if (!R2) {
+      R2 = this.R;
     }
     if (!primerConc) {
       primerConc = this.primerConc;
@@ -7975,7 +7974,7 @@ const calcTmMethods = {
       sumDeltaH = sumDeltaH + neighbors[i] * deltaHTable[i];
       sumDeltaS = sumDeltaS + neighbors[i] * deltaSTable[i];
     }
-    const temperature = -1e3 * sumDeltaH / (A + -sumDeltaS + R * Math.log(primerConc / 4)) - 273.15 + 16.6 * Math.LOG10E * Math.log(monovalentCationConc);
+    const temperature = -1e3 * sumDeltaH / (A + -sumDeltaS + R2 * Math.log(primerConc / 4)) - 273.15 + 16.6 * Math.LOG10E * Math.log(monovalentCationConc);
     return temperature;
   },
   /**
@@ -18800,7 +18799,7 @@ var bufferpack = new BufferPack();
 const bufferpack$1 = /* @__PURE__ */ getDefaultExportFromCjs(bufferpack);
 var string_decoder = {};
 var safeBuffer = { exports: {} };
-var buffer$2 = {};
+var buffer$1 = {};
 var base64Js = {};
 base64Js.byteLength = byteLength;
 base64Js.toByteArray = toByteArray;
@@ -20499,10 +20498,11 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
     }
     return table;
   }();
-})(buffer$2);
+})(buffer$1);
+const buffer = /* @__PURE__ */ getDefaultExportFromCjs(buffer$1);
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 (function(module2, exports2) {
-  var buffer2 = buffer$2;
+  var buffer2 = buffer$1;
   var Buffer2 = buffer2.Buffer;
   function copyProps(src, dst) {
     for (var key in src) {
@@ -20826,1949 +20826,197 @@ function simpleEnd(buf) {
   return buf && buf.length ? this.write(buf) : "";
 }
 __name(simpleEnd, "simpleEnd");
-var buffer$1 = {};
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-(function(exports2) {
-  const base64 = base64Js;
-  const ieee754$1 = ieee754;
-  const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-  exports2.Buffer = Buffer2;
-  exports2.SlowBuffer = SlowBuffer;
-  exports2.INSPECT_MAX_BYTES = 50;
-  const K_MAX_LENGTH = 2147483647;
-  exports2.kMaxLength = K_MAX_LENGTH;
-  Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
-  if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(
-      "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+function getArrayBufferFromFile(file) {
+  if (!isBrowser) {
+    return toArrayBuffer(buffer$1.Buffer.isBuffer(file) ? file : file.buffer || file);
+  }
+  const reader = new window.FileReader();
+  return new Promise((resolve, reject) => {
+    reader.onload = (e) => {
+      resolve(e.target.result);
+    };
+    reader.onerror = (err2) => {
+      console.error("err:", err2);
+      reject(err2);
+    };
+    reader.readAsArrayBuffer(
+      buffer$1.Buffer.isBuffer(file) ? file : file.buffer || file
     );
+  });
+}
+__name(getArrayBufferFromFile, "getArrayBufferFromFile");
+function toArrayBuffer(buffer2) {
+  const ab = new ArrayBuffer(buffer2.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buffer2.length; ++i) {
+    view[i] = buffer2[i];
   }
-  function typedArraySupport() {
+  return ab;
+}
+__name(toArrayBuffer, "toArrayBuffer");
+const Buffer$1 = buffer.Buffer;
+function snapgeneToJson(_0) {
+  return __async(this, arguments, function* (fileObj, options = {}) {
     try {
-      const arr = new Uint8Array(1);
-      const proto = { foo: function() {
-        return 42;
-      } };
-      Object.setPrototypeOf(proto, Uint8Array.prototype);
-      Object.setPrototypeOf(arr, proto);
-      return arr.foo() === 42;
+      let read = function(size, fmt) {
+        const buffer2 = Buffer$1.from(arrayBuffer.slice(offset, size + offset));
+        offset += size;
+        if (fmt) {
+          const decoder = new StringDecoder_1(fmt);
+          const toRet = decoder.write(buffer2);
+          return toRet;
+        } else {
+          return buffer2;
+        }
+      };
+      __name(read, "read");
+      const returnVal = createInitialSequence(options);
+      const arrayBuffer = yield getArrayBufferFromFile(fileObj);
+      const ext = extractFileExtension(options.fileName);
+      let isProtein = options.isProtein;
+      if (ext && /^(prot)$/.test(ext)) {
+        isProtein = true;
+        options.isProtein = true;
+      }
+      let offset = 0;
+      function unpack(size, mode) {
+        return __async(this, null, function* () {
+          const buffer2 = yield read(size);
+          const unpacked = yield bufferpack$1.unpack(">" + mode, buffer2);
+          if (unpacked === void 0)
+            return void 0;
+          return yield unpacked[0];
+        });
+      }
+      __name(unpack, "unpack");
+      yield read(1);
+      const length = yield unpack(4, "I");
+      const title = yield read(8, "ascii");
+      if (length !== 14 || title !== "SnapGene") {
+        throw new Error("Wrong format for a SnapGene file !");
+      }
+      const data = yield __spreadProps(__spreadValues({}, returnVal.parsedSequence), {
+        isProtein,
+        isDNA: !!(yield unpack(2, "H")) && !isProtein,
+        exportVersion: yield unpack(2, "H"),
+        importVersion: yield unpack(2, "H"),
+        features: []
+      });
+      while (offset <= arrayBuffer.byteLength) {
+        const next_byte = yield read(1);
+        const block_size = yield unpack(4, "I");
+        if (ord(next_byte) === 21 || ord(next_byte) === 0) {
+          const props = yield unpack(1, "b");
+          const binaryRep = dec2bin(props);
+          data.circular = isFirstBitA1(binaryRep);
+          const size = block_size - 1;
+          if (size < 0)
+            return;
+          data.size = isProtein ? size * 3 : size;
+          data.sequence = yield read(size, "utf8");
+        } else if (ord(next_byte) === 10) {
+          const strand_dict = {
+            // [strand, arrowheadType]
+            0: [1, "NONE"],
+            // non-directional feature (in that case, the attribute is generally absent altogether)
+            1: [1, "TOP"],
+            // forward strand
+            2: [-1, "BOTTOM"],
+            // reverse strand
+            3: [1, "BOTH"]
+            // bi-directional feature
+          };
+          const xml = yield read(block_size, "utf8");
+          const b = new fxp.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "",
+            isArray: (name) => name === "Feature" || name === "Segment"
+          }).parse(xml);
+          const { Features: { Feature = [] } = {} } = b;
+          data.features = [];
+          Feature.forEach((feat) => {
+            const { directionality, Segment = [], name, type } = feat;
+            let maxStart = 0;
+            let maxEnd = 0;
+            const locations = Segment && Segment.map((seg) => {
+              if (!seg)
+                throw new Error("invalid feature definition");
+              const { range } = seg;
+              let { start, end } = getStartAndEndFromRangeString(range);
+              start = isProtein ? start * 3 : start;
+              end = isProtein ? end * 3 + 2 : end;
+              maxStart = Math.max(maxStart, start);
+              maxEnd = Math.max(maxEnd, end);
+              return {
+                start,
+                end
+              };
+            });
+            data.features.push(__spreadProps(__spreadValues({
+              name,
+              type
+            }, (locations == null ? void 0 : locations.length) > 1 && { locations }), {
+              strand: directionality ? strand_dict[directionality][0] : 1,
+              arrowheadType: directionality ? strand_dict[directionality][1] : "NONE",
+              start: maxStart,
+              end: maxEnd
+              // color,
+            }));
+          });
+        } else if (ord(next_byte) === 6) {
+          const xml = yield read(block_size, "utf8");
+          const b = new fxp.XMLParser({}).parse(xml);
+          const name = get$1(b, "Notes.CustomMapLabel");
+          if (name) {
+            data.name = name;
+          }
+          const description = get$1(b, "Notes.Description");
+          if (description && typeof description === "string") {
+            data.description = description.replace("<html><body>", "").replace("</body></html>", "");
+          }
+        } else {
+          yield read(block_size);
+        }
+      }
+      returnVal.parsedSequence = data;
+      return validateSequenceArray(
+        flattenSequenceArray([returnVal], options),
+        options
+      );
     } catch (e) {
-      return false;
-    }
-  }
-  __name(typedArraySupport, "typedArraySupport");
-  Object.defineProperty(Buffer2.prototype, "parent", {
-    enumerable: true,
-    get: function() {
-      if (!Buffer2.isBuffer(this))
-        return void 0;
-      return this.buffer;
-    }
-  });
-  Object.defineProperty(Buffer2.prototype, "offset", {
-    enumerable: true,
-    get: function() {
-      if (!Buffer2.isBuffer(this))
-        return void 0;
-      return this.byteOffset;
+      console.error("Error trying to parse file as snapgene:", e);
+      return [
+        {
+          success: false,
+          messages: ["Import Error: Invalid File"]
+        }
+      ];
     }
   });
-  function createBuffer(length) {
-    if (length > K_MAX_LENGTH) {
-      throw new RangeError('The value "' + length + '" is invalid for option "size"');
+}
+__name(snapgeneToJson, "snapgeneToJson");
+function getStartAndEndFromRangeString(rangestring) {
+  const [start, end] = rangestring.split("-");
+  return {
+    start: start - 1,
+    end: end - 1
+  };
+}
+__name(getStartAndEndFromRangeString, "getStartAndEndFromRangeString");
+function ord(string) {
+  const str = string + "";
+  const code2 = str.charCodeAt(0);
+  if (code2 >= 55296 && code2 <= 56319) {
+    const hi = code2;
+    if (str.length === 1) {
+      return code2;
     }
-    const buf = new Uint8Array(length);
-    Object.setPrototypeOf(buf, Buffer2.prototype);
-    return buf;
+    const low = str.charCodeAt(1);
+    return (hi - 55296) * 1024 + (low - 56320) + 65536;
   }
-  __name(createBuffer, "createBuffer");
-  function Buffer2(arg, encodingOrOffset, length) {
-    if (typeof arg === "number") {
-      if (typeof encodingOrOffset === "string") {
-        throw new TypeError(
-          'The "string" argument must be of type string. Received type number'
-        );
-      }
-      return allocUnsafe2(arg);
-    }
-    return from(arg, encodingOrOffset, length);
-  }
-  __name(Buffer2, "Buffer");
-  Buffer2.poolSize = 8192;
-  function from(value, encodingOrOffset, length) {
-    if (typeof value === "string") {
-      return fromString(value, encodingOrOffset);
-    }
-    if (ArrayBuffer.isView(value)) {
-      return fromArrayView(value);
-    }
-    if (value == null) {
-      throw new TypeError(
-        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
-      );
-    }
-    if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
-      return fromArrayBuffer(value, encodingOrOffset, length);
-    }
-    if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
-      return fromArrayBuffer(value, encodingOrOffset, length);
-    }
-    if (typeof value === "number") {
-      throw new TypeError(
-        'The "value" argument must not be of type number. Received type number'
-      );
-    }
-    const valueOf = value.valueOf && value.valueOf();
-    if (valueOf != null && valueOf !== value) {
-      return Buffer2.from(valueOf, encodingOrOffset, length);
-    }
-    const b = fromObject(value);
-    if (b)
-      return b;
-    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
-      return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
-    }
-    throw new TypeError(
-      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
-    );
-  }
-  __name(from, "from");
-  Buffer2.from = function(value, encodingOrOffset, length) {
-    return from(value, encodingOrOffset, length);
-  };
-  Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
-  Object.setPrototypeOf(Buffer2, Uint8Array);
-  function assertSize(size) {
-    if (typeof size !== "number") {
-      throw new TypeError('"size" argument must be of type number');
-    } else if (size < 0) {
-      throw new RangeError('The value "' + size + '" is invalid for option "size"');
-    }
-  }
-  __name(assertSize, "assertSize");
-  function alloc(size, fill, encoding) {
-    assertSize(size);
-    if (size <= 0) {
-      return createBuffer(size);
-    }
-    if (fill !== void 0) {
-      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
-    }
-    return createBuffer(size);
-  }
-  __name(alloc, "alloc");
-  Buffer2.alloc = function(size, fill, encoding) {
-    return alloc(size, fill, encoding);
-  };
-  function allocUnsafe2(size) {
-    assertSize(size);
-    return createBuffer(size < 0 ? 0 : checked(size) | 0);
-  }
-  __name(allocUnsafe2, "allocUnsafe");
-  Buffer2.allocUnsafe = function(size) {
-    return allocUnsafe2(size);
-  };
-  Buffer2.allocUnsafeSlow = function(size) {
-    return allocUnsafe2(size);
-  };
-  function fromString(string, encoding) {
-    if (typeof encoding !== "string" || encoding === "") {
-      encoding = "utf8";
-    }
-    if (!Buffer2.isEncoding(encoding)) {
-      throw new TypeError("Unknown encoding: " + encoding);
-    }
-    const length = byteLength2(string, encoding) | 0;
-    let buf = createBuffer(length);
-    const actual = buf.write(string, encoding);
-    if (actual !== length) {
-      buf = buf.slice(0, actual);
-    }
-    return buf;
-  }
-  __name(fromString, "fromString");
-  function fromArrayLike(array) {
-    const length = array.length < 0 ? 0 : checked(array.length) | 0;
-    const buf = createBuffer(length);
-    for (let i = 0; i < length; i += 1) {
-      buf[i] = array[i] & 255;
-    }
-    return buf;
-  }
-  __name(fromArrayLike, "fromArrayLike");
-  function fromArrayView(arrayView) {
-    if (isInstance(arrayView, Uint8Array)) {
-      const copy = new Uint8Array(arrayView);
-      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
-    }
-    return fromArrayLike(arrayView);
-  }
-  __name(fromArrayView, "fromArrayView");
-  function fromArrayBuffer(array, byteOffset, length) {
-    if (byteOffset < 0 || array.byteLength < byteOffset) {
-      throw new RangeError('"offset" is outside of buffer bounds');
-    }
-    if (array.byteLength < byteOffset + (length || 0)) {
-      throw new RangeError('"length" is outside of buffer bounds');
-    }
-    let buf;
-    if (byteOffset === void 0 && length === void 0) {
-      buf = new Uint8Array(array);
-    } else if (length === void 0) {
-      buf = new Uint8Array(array, byteOffset);
-    } else {
-      buf = new Uint8Array(array, byteOffset, length);
-    }
-    Object.setPrototypeOf(buf, Buffer2.prototype);
-    return buf;
-  }
-  __name(fromArrayBuffer, "fromArrayBuffer");
-  function fromObject(obj) {
-    if (Buffer2.isBuffer(obj)) {
-      const len = checked(obj.length) | 0;
-      const buf = createBuffer(len);
-      if (buf.length === 0) {
-        return buf;
-      }
-      obj.copy(buf, 0, 0, len);
-      return buf;
-    }
-    if (obj.length !== void 0) {
-      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
-        return createBuffer(0);
-      }
-      return fromArrayLike(obj);
-    }
-    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
-      return fromArrayLike(obj.data);
-    }
-  }
-  __name(fromObject, "fromObject");
-  function checked(length) {
-    if (length >= K_MAX_LENGTH) {
-      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
-    }
-    return length | 0;
-  }
-  __name(checked, "checked");
-  function SlowBuffer(length) {
-    if (+length != length) {
-      length = 0;
-    }
-    return Buffer2.alloc(+length);
-  }
-  __name(SlowBuffer, "SlowBuffer");
-  Buffer2.isBuffer = /* @__PURE__ */ __name(function isBuffer2(b) {
-    return b != null && b._isBuffer === true && b !== Buffer2.prototype;
-  }, "isBuffer");
-  Buffer2.compare = /* @__PURE__ */ __name(function compare(a, b) {
-    if (isInstance(a, Uint8Array))
-      a = Buffer2.from(a, a.offset, a.byteLength);
-    if (isInstance(b, Uint8Array))
-      b = Buffer2.from(b, b.offset, b.byteLength);
-    if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
-      throw new TypeError(
-        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
-      );
-    }
-    if (a === b)
-      return 0;
-    let x = a.length;
-    let y = b.length;
-    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
-      if (a[i] !== b[i]) {
-        x = a[i];
-        y = b[i];
-        break;
-      }
-    }
-    if (x < y)
-      return -1;
-    if (y < x)
-      return 1;
-    return 0;
-  }, "compare");
-  Buffer2.isEncoding = /* @__PURE__ */ __name(function isEncoding2(encoding) {
-    switch (String(encoding).toLowerCase()) {
-      case "hex":
-      case "utf8":
-      case "utf-8":
-      case "ascii":
-      case "latin1":
-      case "binary":
-      case "base64":
-      case "ucs2":
-      case "ucs-2":
-      case "utf16le":
-      case "utf-16le":
-        return true;
-      default:
-        return false;
-    }
-  }, "isEncoding");
-  Buffer2.concat = /* @__PURE__ */ __name(function concat2(list, length) {
-    if (!Array.isArray(list)) {
-      throw new TypeError('"list" argument must be an Array of Buffers');
-    }
-    if (list.length === 0) {
-      return Buffer2.alloc(0);
-    }
-    let i;
-    if (length === void 0) {
-      length = 0;
-      for (i = 0; i < list.length; ++i) {
-        length += list[i].length;
-      }
-    }
-    const buffer2 = Buffer2.allocUnsafe(length);
-    let pos = 0;
-    for (i = 0; i < list.length; ++i) {
-      let buf = list[i];
-      if (isInstance(buf, Uint8Array)) {
-        if (pos + buf.length > buffer2.length) {
-          if (!Buffer2.isBuffer(buf))
-            buf = Buffer2.from(buf);
-          buf.copy(buffer2, pos);
-        } else {
-          Uint8Array.prototype.set.call(
-            buffer2,
-            buf,
-            pos
-          );
-        }
-      } else if (!Buffer2.isBuffer(buf)) {
-        throw new TypeError('"list" argument must be an Array of Buffers');
-      } else {
-        buf.copy(buffer2, pos);
-      }
-      pos += buf.length;
-    }
-    return buffer2;
-  }, "concat");
-  function byteLength2(string, encoding) {
-    if (Buffer2.isBuffer(string)) {
-      return string.length;
-    }
-    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
-      return string.byteLength;
-    }
-    if (typeof string !== "string") {
-      throw new TypeError(
-        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
-      );
-    }
-    const len = string.length;
-    const mustMatch = arguments.length > 2 && arguments[2] === true;
-    if (!mustMatch && len === 0)
-      return 0;
-    let loweredCase = false;
-    for (; ; ) {
-      switch (encoding) {
-        case "ascii":
-        case "latin1":
-        case "binary":
-          return len;
-        case "utf8":
-        case "utf-8":
-          return utf8ToBytes(string).length;
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return len * 2;
-        case "hex":
-          return len >>> 1;
-        case "base64":
-          return base64ToBytes(string).length;
-        default:
-          if (loweredCase) {
-            return mustMatch ? -1 : utf8ToBytes(string).length;
-          }
-          encoding = ("" + encoding).toLowerCase();
-          loweredCase = true;
-      }
-    }
-  }
-  __name(byteLength2, "byteLength");
-  Buffer2.byteLength = byteLength2;
-  function slowToString(encoding, start, end) {
-    let loweredCase = false;
-    if (start === void 0 || start < 0) {
-      start = 0;
-    }
-    if (start > this.length) {
-      return "";
-    }
-    if (end === void 0 || end > this.length) {
-      end = this.length;
-    }
-    if (end <= 0) {
-      return "";
-    }
-    end >>>= 0;
-    start >>>= 0;
-    if (end <= start) {
-      return "";
-    }
-    if (!encoding)
-      encoding = "utf8";
-    while (true) {
-      switch (encoding) {
-        case "hex":
-          return hexSlice(this, start, end);
-        case "utf8":
-        case "utf-8":
-          return utf8Slice(this, start, end);
-        case "ascii":
-          return asciiSlice(this, start, end);
-        case "latin1":
-        case "binary":
-          return latin1Slice(this, start, end);
-        case "base64":
-          return base64Slice(this, start, end);
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return utf16leSlice(this, start, end);
-        default:
-          if (loweredCase)
-            throw new TypeError("Unknown encoding: " + encoding);
-          encoding = (encoding + "").toLowerCase();
-          loweredCase = true;
-      }
-    }
-  }
-  __name(slowToString, "slowToString");
-  Buffer2.prototype._isBuffer = true;
-  function swap(b, n, m) {
-    const i = b[n];
-    b[n] = b[m];
-    b[m] = i;
-  }
-  __name(swap, "swap");
-  Buffer2.prototype.swap16 = /* @__PURE__ */ __name(function swap16() {
-    const len = this.length;
-    if (len % 2 !== 0) {
-      throw new RangeError("Buffer size must be a multiple of 16-bits");
-    }
-    for (let i = 0; i < len; i += 2) {
-      swap(this, i, i + 1);
-    }
-    return this;
-  }, "swap16");
-  Buffer2.prototype.swap32 = /* @__PURE__ */ __name(function swap32() {
-    const len = this.length;
-    if (len % 4 !== 0) {
-      throw new RangeError("Buffer size must be a multiple of 32-bits");
-    }
-    for (let i = 0; i < len; i += 4) {
-      swap(this, i, i + 3);
-      swap(this, i + 1, i + 2);
-    }
-    return this;
-  }, "swap32");
-  Buffer2.prototype.swap64 = /* @__PURE__ */ __name(function swap64() {
-    const len = this.length;
-    if (len % 8 !== 0) {
-      throw new RangeError("Buffer size must be a multiple of 64-bits");
-    }
-    for (let i = 0; i < len; i += 8) {
-      swap(this, i, i + 7);
-      swap(this, i + 1, i + 6);
-      swap(this, i + 2, i + 5);
-      swap(this, i + 3, i + 4);
-    }
-    return this;
-  }, "swap64");
-  Buffer2.prototype.toString = /* @__PURE__ */ __name(function toString2() {
-    const length = this.length;
-    if (length === 0)
-      return "";
-    if (arguments.length === 0)
-      return utf8Slice(this, 0, length);
-    return slowToString.apply(this, arguments);
-  }, "toString");
-  Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
-  Buffer2.prototype.equals = /* @__PURE__ */ __name(function equals(b) {
-    if (!Buffer2.isBuffer(b))
-      throw new TypeError("Argument must be a Buffer");
-    if (this === b)
-      return true;
-    return Buffer2.compare(this, b) === 0;
-  }, "equals");
-  Buffer2.prototype.inspect = /* @__PURE__ */ __name(function inspect() {
-    let str = "";
-    const max2 = exports2.INSPECT_MAX_BYTES;
-    str = this.toString("hex", 0, max2).replace(/(.{2})/g, "$1 ").trim();
-    if (this.length > max2)
-      str += " ... ";
-    return "<Buffer " + str + ">";
-  }, "inspect");
-  if (customInspectSymbol) {
-    Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
-  }
-  Buffer2.prototype.compare = /* @__PURE__ */ __name(function compare(target, start, end, thisStart, thisEnd) {
-    if (isInstance(target, Uint8Array)) {
-      target = Buffer2.from(target, target.offset, target.byteLength);
-    }
-    if (!Buffer2.isBuffer(target)) {
-      throw new TypeError(
-        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
-      );
-    }
-    if (start === void 0) {
-      start = 0;
-    }
-    if (end === void 0) {
-      end = target ? target.length : 0;
-    }
-    if (thisStart === void 0) {
-      thisStart = 0;
-    }
-    if (thisEnd === void 0) {
-      thisEnd = this.length;
-    }
-    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
-      throw new RangeError("out of range index");
-    }
-    if (thisStart >= thisEnd && start >= end) {
-      return 0;
-    }
-    if (thisStart >= thisEnd) {
-      return -1;
-    }
-    if (start >= end) {
-      return 1;
-    }
-    start >>>= 0;
-    end >>>= 0;
-    thisStart >>>= 0;
-    thisEnd >>>= 0;
-    if (this === target)
-      return 0;
-    let x = thisEnd - thisStart;
-    let y = end - start;
-    const len = Math.min(x, y);
-    const thisCopy = this.slice(thisStart, thisEnd);
-    const targetCopy = target.slice(start, end);
-    for (let i = 0; i < len; ++i) {
-      if (thisCopy[i] !== targetCopy[i]) {
-        x = thisCopy[i];
-        y = targetCopy[i];
-        break;
-      }
-    }
-    if (x < y)
-      return -1;
-    if (y < x)
-      return 1;
-    return 0;
-  }, "compare");
-  function bidirectionalIndexOf(buffer2, val2, byteOffset, encoding, dir) {
-    if (buffer2.length === 0)
-      return -1;
-    if (typeof byteOffset === "string") {
-      encoding = byteOffset;
-      byteOffset = 0;
-    } else if (byteOffset > 2147483647) {
-      byteOffset = 2147483647;
-    } else if (byteOffset < -2147483648) {
-      byteOffset = -2147483648;
-    }
-    byteOffset = +byteOffset;
-    if (numberIsNaN(byteOffset)) {
-      byteOffset = dir ? 0 : buffer2.length - 1;
-    }
-    if (byteOffset < 0)
-      byteOffset = buffer2.length + byteOffset;
-    if (byteOffset >= buffer2.length) {
-      if (dir)
-        return -1;
-      else
-        byteOffset = buffer2.length - 1;
-    } else if (byteOffset < 0) {
-      if (dir)
-        byteOffset = 0;
-      else
-        return -1;
-    }
-    if (typeof val2 === "string") {
-      val2 = Buffer2.from(val2, encoding);
-    }
-    if (Buffer2.isBuffer(val2)) {
-      if (val2.length === 0) {
-        return -1;
-      }
-      return arrayIndexOf(buffer2, val2, byteOffset, encoding, dir);
-    } else if (typeof val2 === "number") {
-      val2 = val2 & 255;
-      if (typeof Uint8Array.prototype.indexOf === "function") {
-        if (dir) {
-          return Uint8Array.prototype.indexOf.call(buffer2, val2, byteOffset);
-        } else {
-          return Uint8Array.prototype.lastIndexOf.call(buffer2, val2, byteOffset);
-        }
-      }
-      return arrayIndexOf(buffer2, [val2], byteOffset, encoding, dir);
-    }
-    throw new TypeError("val must be string, number or Buffer");
-  }
-  __name(bidirectionalIndexOf, "bidirectionalIndexOf");
-  function arrayIndexOf(arr, val2, byteOffset, encoding, dir) {
-    let indexSize = 1;
-    let arrLength = arr.length;
-    let valLength = val2.length;
-    if (encoding !== void 0) {
-      encoding = String(encoding).toLowerCase();
-      if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
-        if (arr.length < 2 || val2.length < 2) {
-          return -1;
-        }
-        indexSize = 2;
-        arrLength /= 2;
-        valLength /= 2;
-        byteOffset /= 2;
-      }
-    }
-    function read(buf, i2) {
-      if (indexSize === 1) {
-        return buf[i2];
-      } else {
-        return buf.readUInt16BE(i2 * indexSize);
-      }
-    }
-    __name(read, "read");
-    let i;
-    if (dir) {
-      let foundIndex = -1;
-      for (i = byteOffset; i < arrLength; i++) {
-        if (read(arr, i) === read(val2, foundIndex === -1 ? 0 : i - foundIndex)) {
-          if (foundIndex === -1)
-            foundIndex = i;
-          if (i - foundIndex + 1 === valLength)
-            return foundIndex * indexSize;
-        } else {
-          if (foundIndex !== -1)
-            i -= i - foundIndex;
-          foundIndex = -1;
-        }
-      }
-    } else {
-      if (byteOffset + valLength > arrLength)
-        byteOffset = arrLength - valLength;
-      for (i = byteOffset; i >= 0; i--) {
-        let found = true;
-        for (let j = 0; j < valLength; j++) {
-          if (read(arr, i + j) !== read(val2, j)) {
-            found = false;
-            break;
-          }
-        }
-        if (found)
-          return i;
-      }
-    }
-    return -1;
-  }
-  __name(arrayIndexOf, "arrayIndexOf");
-  Buffer2.prototype.includes = /* @__PURE__ */ __name(function includes(val2, byteOffset, encoding) {
-    return this.indexOf(val2, byteOffset, encoding) !== -1;
-  }, "includes");
-  Buffer2.prototype.indexOf = /* @__PURE__ */ __name(function indexOf(val2, byteOffset, encoding) {
-    return bidirectionalIndexOf(this, val2, byteOffset, encoding, true);
-  }, "indexOf");
-  Buffer2.prototype.lastIndexOf = /* @__PURE__ */ __name(function lastIndexOf(val2, byteOffset, encoding) {
-    return bidirectionalIndexOf(this, val2, byteOffset, encoding, false);
-  }, "lastIndexOf");
-  function hexWrite(buf, string, offset, length) {
-    offset = Number(offset) || 0;
-    const remaining = buf.length - offset;
-    if (!length) {
-      length = remaining;
-    } else {
-      length = Number(length);
-      if (length > remaining) {
-        length = remaining;
-      }
-    }
-    const strLen = string.length;
-    if (length > strLen / 2) {
-      length = strLen / 2;
-    }
-    let i;
-    for (i = 0; i < length; ++i) {
-      const parsed = parseInt(string.substr(i * 2, 2), 16);
-      if (numberIsNaN(parsed))
-        return i;
-      buf[offset + i] = parsed;
-    }
-    return i;
-  }
-  __name(hexWrite, "hexWrite");
-  function utf8Write(buf, string, offset, length) {
-    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
-  }
-  __name(utf8Write, "utf8Write");
-  function asciiWrite(buf, string, offset, length) {
-    return blitBuffer(asciiToBytes(string), buf, offset, length);
-  }
-  __name(asciiWrite, "asciiWrite");
-  function base64Write(buf, string, offset, length) {
-    return blitBuffer(base64ToBytes(string), buf, offset, length);
-  }
-  __name(base64Write, "base64Write");
-  function ucs2Write(buf, string, offset, length) {
-    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
-  }
-  __name(ucs2Write, "ucs2Write");
-  Buffer2.prototype.write = /* @__PURE__ */ __name(function write(string, offset, length, encoding) {
-    if (offset === void 0) {
-      encoding = "utf8";
-      length = this.length;
-      offset = 0;
-    } else if (length === void 0 && typeof offset === "string") {
-      encoding = offset;
-      length = this.length;
-      offset = 0;
-    } else if (isFinite(offset)) {
-      offset = offset >>> 0;
-      if (isFinite(length)) {
-        length = length >>> 0;
-        if (encoding === void 0)
-          encoding = "utf8";
-      } else {
-        encoding = length;
-        length = void 0;
-      }
-    } else {
-      throw new Error(
-        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
-      );
-    }
-    const remaining = this.length - offset;
-    if (length === void 0 || length > remaining)
-      length = remaining;
-    if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
-      throw new RangeError("Attempt to write outside buffer bounds");
-    }
-    if (!encoding)
-      encoding = "utf8";
-    let loweredCase = false;
-    for (; ; ) {
-      switch (encoding) {
-        case "hex":
-          return hexWrite(this, string, offset, length);
-        case "utf8":
-        case "utf-8":
-          return utf8Write(this, string, offset, length);
-        case "ascii":
-        case "latin1":
-        case "binary":
-          return asciiWrite(this, string, offset, length);
-        case "base64":
-          return base64Write(this, string, offset, length);
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return ucs2Write(this, string, offset, length);
-        default:
-          if (loweredCase)
-            throw new TypeError("Unknown encoding: " + encoding);
-          encoding = ("" + encoding).toLowerCase();
-          loweredCase = true;
-      }
-    }
-  }, "write");
-  Buffer2.prototype.toJSON = /* @__PURE__ */ __name(function toJSON() {
-    return {
-      type: "Buffer",
-      data: Array.prototype.slice.call(this._arr || this, 0)
-    };
-  }, "toJSON");
-  function base64Slice(buf, start, end) {
-    if (start === 0 && end === buf.length) {
-      return base64.fromByteArray(buf);
-    } else {
-      return base64.fromByteArray(buf.slice(start, end));
-    }
-  }
-  __name(base64Slice, "base64Slice");
-  function utf8Slice(buf, start, end) {
-    end = Math.min(buf.length, end);
-    const res = [];
-    let i = start;
-    while (i < end) {
-      const firstByte = buf[i];
-      let codePoint = null;
-      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-      if (i + bytesPerSequence <= end) {
-        let secondByte, thirdByte, fourthByte, tempCodePoint;
-        switch (bytesPerSequence) {
-          case 1:
-            if (firstByte < 128) {
-              codePoint = firstByte;
-            }
-            break;
-          case 2:
-            secondByte = buf[i + 1];
-            if ((secondByte & 192) === 128) {
-              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-              if (tempCodePoint > 127) {
-                codePoint = tempCodePoint;
-              }
-            }
-            break;
-          case 3:
-            secondByte = buf[i + 1];
-            thirdByte = buf[i + 2];
-            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-                codePoint = tempCodePoint;
-              }
-            }
-            break;
-          case 4:
-            secondByte = buf[i + 1];
-            thirdByte = buf[i + 2];
-            fourthByte = buf[i + 3];
-            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-                codePoint = tempCodePoint;
-              }
-            }
-        }
-      }
-      if (codePoint === null) {
-        codePoint = 65533;
-        bytesPerSequence = 1;
-      } else if (codePoint > 65535) {
-        codePoint -= 65536;
-        res.push(codePoint >>> 10 & 1023 | 55296);
-        codePoint = 56320 | codePoint & 1023;
-      }
-      res.push(codePoint);
-      i += bytesPerSequence;
-    }
-    return decodeCodePointsArray(res);
-  }
-  __name(utf8Slice, "utf8Slice");
-  const MAX_ARGUMENTS_LENGTH = 4096;
-  function decodeCodePointsArray(codePoints) {
-    const len = codePoints.length;
-    if (len <= MAX_ARGUMENTS_LENGTH) {
-      return String.fromCharCode.apply(String, codePoints);
-    }
-    let res = "";
-    let i = 0;
-    while (i < len) {
-      res += String.fromCharCode.apply(
-        String,
-        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
-      );
-    }
-    return res;
-  }
-  __name(decodeCodePointsArray, "decodeCodePointsArray");
-  function asciiSlice(buf, start, end) {
-    let ret = "";
-    end = Math.min(buf.length, end);
-    for (let i = start; i < end; ++i) {
-      ret += String.fromCharCode(buf[i] & 127);
-    }
-    return ret;
-  }
-  __name(asciiSlice, "asciiSlice");
-  function latin1Slice(buf, start, end) {
-    let ret = "";
-    end = Math.min(buf.length, end);
-    for (let i = start; i < end; ++i) {
-      ret += String.fromCharCode(buf[i]);
-    }
-    return ret;
-  }
-  __name(latin1Slice, "latin1Slice");
-  function hexSlice(buf, start, end) {
-    const len = buf.length;
-    if (!start || start < 0)
-      start = 0;
-    if (!end || end < 0 || end > len)
-      end = len;
-    let out = "";
-    for (let i = start; i < end; ++i) {
-      out += hexSliceLookupTable[buf[i]];
-    }
-    return out;
-  }
-  __name(hexSlice, "hexSlice");
-  function utf16leSlice(buf, start, end) {
-    const bytes = buf.slice(start, end);
-    let res = "";
-    for (let i = 0; i < bytes.length - 1; i += 2) {
-      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
-    }
-    return res;
-  }
-  __name(utf16leSlice, "utf16leSlice");
-  Buffer2.prototype.slice = /* @__PURE__ */ __name(function slice2(start, end) {
-    const len = this.length;
-    start = ~~start;
-    end = end === void 0 ? len : ~~end;
-    if (start < 0) {
-      start += len;
-      if (start < 0)
-        start = 0;
-    } else if (start > len) {
-      start = len;
-    }
-    if (end < 0) {
-      end += len;
-      if (end < 0)
-        end = 0;
-    } else if (end > len) {
-      end = len;
-    }
-    if (end < start)
-      end = start;
-    const newBuf = this.subarray(start, end);
-    Object.setPrototypeOf(newBuf, Buffer2.prototype);
-    return newBuf;
-  }, "slice");
-  function checkOffset(offset, ext, length) {
-    if (offset % 1 !== 0 || offset < 0)
-      throw new RangeError("offset is not uint");
-    if (offset + ext > length)
-      throw new RangeError("Trying to access beyond buffer length");
-  }
-  __name(checkOffset, "checkOffset");
-  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = /* @__PURE__ */ __name(function readUIntLE(offset, byteLength3, noAssert) {
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert)
-      checkOffset(offset, byteLength3, this.length);
-    let val2 = this[offset];
-    let mul = 1;
-    let i = 0;
-    while (++i < byteLength3 && (mul *= 256)) {
-      val2 += this[offset + i] * mul;
-    }
-    return val2;
-  }, "readUIntLE");
-  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = /* @__PURE__ */ __name(function readUIntBE(offset, byteLength3, noAssert) {
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert) {
-      checkOffset(offset, byteLength3, this.length);
-    }
-    let val2 = this[offset + --byteLength3];
-    let mul = 1;
-    while (byteLength3 > 0 && (mul *= 256)) {
-      val2 += this[offset + --byteLength3] * mul;
-    }
-    return val2;
-  }, "readUIntBE");
-  Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = /* @__PURE__ */ __name(function readUInt8(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 1, this.length);
-    return this[offset];
-  }, "readUInt8");
-  Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = /* @__PURE__ */ __name(function readUInt16LE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 2, this.length);
-    return this[offset] | this[offset + 1] << 8;
-  }, "readUInt16LE");
-  Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = /* @__PURE__ */ __name(function readUInt16BE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 2, this.length);
-    return this[offset] << 8 | this[offset + 1];
-  }, "readUInt16BE");
-  Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = /* @__PURE__ */ __name(function readUInt32LE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
-  }, "readUInt32LE");
-  Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = /* @__PURE__ */ __name(function readUInt32BE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
-  }, "readUInt32BE");
-  Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(/* @__PURE__ */ __name(function readBigUInt64LE(offset) {
-    offset = offset >>> 0;
-    validateNumber(offset, "offset");
-    const first = this[offset];
-    const last2 = this[offset + 7];
-    if (first === void 0 || last2 === void 0) {
-      boundsError(offset, this.length - 8);
-    }
-    const lo = first + this[++offset] * __pow(2, 8) + this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 24);
-    const hi = this[++offset] + this[++offset] * __pow(2, 8) + this[++offset] * __pow(2, 16) + last2 * __pow(2, 24);
-    return BigInt(lo) + (BigInt(hi) << BigInt(32));
-  }, "readBigUInt64LE"));
-  Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(/* @__PURE__ */ __name(function readBigUInt64BE(offset) {
-    offset = offset >>> 0;
-    validateNumber(offset, "offset");
-    const first = this[offset];
-    const last2 = this[offset + 7];
-    if (first === void 0 || last2 === void 0) {
-      boundsError(offset, this.length - 8);
-    }
-    const hi = first * __pow(2, 24) + this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 8) + this[++offset];
-    const lo = this[++offset] * __pow(2, 24) + this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 8) + last2;
-    return (BigInt(hi) << BigInt(32)) + BigInt(lo);
-  }, "readBigUInt64BE"));
-  Buffer2.prototype.readIntLE = /* @__PURE__ */ __name(function readIntLE(offset, byteLength3, noAssert) {
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert)
-      checkOffset(offset, byteLength3, this.length);
-    let val2 = this[offset];
-    let mul = 1;
-    let i = 0;
-    while (++i < byteLength3 && (mul *= 256)) {
-      val2 += this[offset + i] * mul;
-    }
-    mul *= 128;
-    if (val2 >= mul)
-      val2 -= Math.pow(2, 8 * byteLength3);
-    return val2;
-  }, "readIntLE");
-  Buffer2.prototype.readIntBE = /* @__PURE__ */ __name(function readIntBE(offset, byteLength3, noAssert) {
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert)
-      checkOffset(offset, byteLength3, this.length);
-    let i = byteLength3;
-    let mul = 1;
-    let val2 = this[offset + --i];
-    while (i > 0 && (mul *= 256)) {
-      val2 += this[offset + --i] * mul;
-    }
-    mul *= 128;
-    if (val2 >= mul)
-      val2 -= Math.pow(2, 8 * byteLength3);
-    return val2;
-  }, "readIntBE");
-  Buffer2.prototype.readInt8 = /* @__PURE__ */ __name(function readInt8(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 1, this.length);
-    if (!(this[offset] & 128))
-      return this[offset];
-    return (255 - this[offset] + 1) * -1;
-  }, "readInt8");
-  Buffer2.prototype.readInt16LE = /* @__PURE__ */ __name(function readInt16LE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 2, this.length);
-    const val2 = this[offset] | this[offset + 1] << 8;
-    return val2 & 32768 ? val2 | 4294901760 : val2;
-  }, "readInt16LE");
-  Buffer2.prototype.readInt16BE = /* @__PURE__ */ __name(function readInt16BE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 2, this.length);
-    const val2 = this[offset + 1] | this[offset] << 8;
-    return val2 & 32768 ? val2 | 4294901760 : val2;
-  }, "readInt16BE");
-  Buffer2.prototype.readInt32LE = /* @__PURE__ */ __name(function readInt32LE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
-  }, "readInt32LE");
-  Buffer2.prototype.readInt32BE = /* @__PURE__ */ __name(function readInt32BE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
-  }, "readInt32BE");
-  Buffer2.prototype.readBigInt64LE = defineBigIntMethod(/* @__PURE__ */ __name(function readBigInt64LE(offset) {
-    offset = offset >>> 0;
-    validateNumber(offset, "offset");
-    const first = this[offset];
-    const last2 = this[offset + 7];
-    if (first === void 0 || last2 === void 0) {
-      boundsError(offset, this.length - 8);
-    }
-    const val2 = this[offset + 4] + this[offset + 5] * __pow(2, 8) + this[offset + 6] * __pow(2, 16) + (last2 << 24);
-    return (BigInt(val2) << BigInt(32)) + BigInt(first + this[++offset] * __pow(2, 8) + this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 24));
-  }, "readBigInt64LE"));
-  Buffer2.prototype.readBigInt64BE = defineBigIntMethod(/* @__PURE__ */ __name(function readBigInt64BE(offset) {
-    offset = offset >>> 0;
-    validateNumber(offset, "offset");
-    const first = this[offset];
-    const last2 = this[offset + 7];
-    if (first === void 0 || last2 === void 0) {
-      boundsError(offset, this.length - 8);
-    }
-    const val2 = (first << 24) + // Overflow
-    this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 8) + this[++offset];
-    return (BigInt(val2) << BigInt(32)) + BigInt(this[++offset] * __pow(2, 24) + this[++offset] * __pow(2, 16) + this[++offset] * __pow(2, 8) + last2);
-  }, "readBigInt64BE"));
-  Buffer2.prototype.readFloatLE = /* @__PURE__ */ __name(function readFloatLE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return ieee754$1.read(this, offset, true, 23, 4);
-  }, "readFloatLE");
-  Buffer2.prototype.readFloatBE = /* @__PURE__ */ __name(function readFloatBE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 4, this.length);
-    return ieee754$1.read(this, offset, false, 23, 4);
-  }, "readFloatBE");
-  Buffer2.prototype.readDoubleLE = /* @__PURE__ */ __name(function readDoubleLE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 8, this.length);
-    return ieee754$1.read(this, offset, true, 52, 8);
-  }, "readDoubleLE");
-  Buffer2.prototype.readDoubleBE = /* @__PURE__ */ __name(function readDoubleBE(offset, noAssert) {
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkOffset(offset, 8, this.length);
-    return ieee754$1.read(this, offset, false, 52, 8);
-  }, "readDoubleBE");
-  function checkInt(buf, value, offset, ext, max2, min) {
-    if (!Buffer2.isBuffer(buf))
-      throw new TypeError('"buffer" argument must be a Buffer instance');
-    if (value > max2 || value < min)
-      throw new RangeError('"value" argument is out of bounds');
-    if (offset + ext > buf.length)
-      throw new RangeError("Index out of range");
-  }
-  __name(checkInt, "checkInt");
-  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = /* @__PURE__ */ __name(function writeUIntLE(value, offset, byteLength3, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert) {
-      const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
-      checkInt(this, value, offset, byteLength3, maxBytes, 0);
-    }
-    let mul = 1;
-    let i = 0;
-    this[offset] = value & 255;
-    while (++i < byteLength3 && (mul *= 256)) {
-      this[offset + i] = value / mul & 255;
-    }
-    return offset + byteLength3;
-  }, "writeUIntLE");
-  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = /* @__PURE__ */ __name(function writeUIntBE(value, offset, byteLength3, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    byteLength3 = byteLength3 >>> 0;
-    if (!noAssert) {
-      const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
-      checkInt(this, value, offset, byteLength3, maxBytes, 0);
-    }
-    let i = byteLength3 - 1;
-    let mul = 1;
-    this[offset + i] = value & 255;
-    while (--i >= 0 && (mul *= 256)) {
-      this[offset + i] = value / mul & 255;
-    }
-    return offset + byteLength3;
-  }, "writeUIntBE");
-  Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = /* @__PURE__ */ __name(function writeUInt8(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 1, 255, 0);
-    this[offset] = value & 255;
-    return offset + 1;
-  }, "writeUInt8");
-  Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = /* @__PURE__ */ __name(function writeUInt16LE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 2, 65535, 0);
-    this[offset] = value & 255;
-    this[offset + 1] = value >>> 8;
-    return offset + 2;
-  }, "writeUInt16LE");
-  Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = /* @__PURE__ */ __name(function writeUInt16BE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 2, 65535, 0);
-    this[offset] = value >>> 8;
-    this[offset + 1] = value & 255;
-    return offset + 2;
-  }, "writeUInt16BE");
-  Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = /* @__PURE__ */ __name(function writeUInt32LE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 4, 4294967295, 0);
-    this[offset + 3] = value >>> 24;
-    this[offset + 2] = value >>> 16;
-    this[offset + 1] = value >>> 8;
-    this[offset] = value & 255;
-    return offset + 4;
-  }, "writeUInt32LE");
-  Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = /* @__PURE__ */ __name(function writeUInt32BE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 4, 4294967295, 0);
-    this[offset] = value >>> 24;
-    this[offset + 1] = value >>> 16;
-    this[offset + 2] = value >>> 8;
-    this[offset + 3] = value & 255;
-    return offset + 4;
-  }, "writeUInt32BE");
-  function wrtBigUInt64LE(buf, value, offset, min, max2) {
-    checkIntBI(value, min, max2, buf, offset, 7);
-    let lo = Number(value & BigInt(4294967295));
-    buf[offset++] = lo;
-    lo = lo >> 8;
-    buf[offset++] = lo;
-    lo = lo >> 8;
-    buf[offset++] = lo;
-    lo = lo >> 8;
-    buf[offset++] = lo;
-    let hi = Number(value >> BigInt(32) & BigInt(4294967295));
-    buf[offset++] = hi;
-    hi = hi >> 8;
-    buf[offset++] = hi;
-    hi = hi >> 8;
-    buf[offset++] = hi;
-    hi = hi >> 8;
-    buf[offset++] = hi;
-    return offset;
-  }
-  __name(wrtBigUInt64LE, "wrtBigUInt64LE");
-  function wrtBigUInt64BE(buf, value, offset, min, max2) {
-    checkIntBI(value, min, max2, buf, offset, 7);
-    let lo = Number(value & BigInt(4294967295));
-    buf[offset + 7] = lo;
-    lo = lo >> 8;
-    buf[offset + 6] = lo;
-    lo = lo >> 8;
-    buf[offset + 5] = lo;
-    lo = lo >> 8;
-    buf[offset + 4] = lo;
-    let hi = Number(value >> BigInt(32) & BigInt(4294967295));
-    buf[offset + 3] = hi;
-    hi = hi >> 8;
-    buf[offset + 2] = hi;
-    hi = hi >> 8;
-    buf[offset + 1] = hi;
-    hi = hi >> 8;
-    buf[offset] = hi;
-    return offset + 8;
-  }
-  __name(wrtBigUInt64BE, "wrtBigUInt64BE");
-  Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(/* @__PURE__ */ __name(function writeBigUInt64LE(value, offset = 0) {
-    return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-  }, "writeBigUInt64LE"));
-  Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(/* @__PURE__ */ __name(function writeBigUInt64BE(value, offset = 0) {
-    return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-  }, "writeBigUInt64BE"));
-  Buffer2.prototype.writeIntLE = /* @__PURE__ */ __name(function writeIntLE(value, offset, byteLength3, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert) {
-      const limit = Math.pow(2, 8 * byteLength3 - 1);
-      checkInt(this, value, offset, byteLength3, limit - 1, -limit);
-    }
-    let i = 0;
-    let mul = 1;
-    let sub = 0;
-    this[offset] = value & 255;
-    while (++i < byteLength3 && (mul *= 256)) {
-      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
-        sub = 1;
-      }
-      this[offset + i] = (value / mul >> 0) - sub & 255;
-    }
-    return offset + byteLength3;
-  }, "writeIntLE");
-  Buffer2.prototype.writeIntBE = /* @__PURE__ */ __name(function writeIntBE(value, offset, byteLength3, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert) {
-      const limit = Math.pow(2, 8 * byteLength3 - 1);
-      checkInt(this, value, offset, byteLength3, limit - 1, -limit);
-    }
-    let i = byteLength3 - 1;
-    let mul = 1;
-    let sub = 0;
-    this[offset + i] = value & 255;
-    while (--i >= 0 && (mul *= 256)) {
-      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
-        sub = 1;
-      }
-      this[offset + i] = (value / mul >> 0) - sub & 255;
-    }
-    return offset + byteLength3;
-  }, "writeIntBE");
-  Buffer2.prototype.writeInt8 = /* @__PURE__ */ __name(function writeInt8(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 1, 127, -128);
-    if (value < 0)
-      value = 255 + value + 1;
-    this[offset] = value & 255;
-    return offset + 1;
-  }, "writeInt8");
-  Buffer2.prototype.writeInt16LE = /* @__PURE__ */ __name(function writeInt16LE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 2, 32767, -32768);
-    this[offset] = value & 255;
-    this[offset + 1] = value >>> 8;
-    return offset + 2;
-  }, "writeInt16LE");
-  Buffer2.prototype.writeInt16BE = /* @__PURE__ */ __name(function writeInt16BE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 2, 32767, -32768);
-    this[offset] = value >>> 8;
-    this[offset + 1] = value & 255;
-    return offset + 2;
-  }, "writeInt16BE");
-  Buffer2.prototype.writeInt32LE = /* @__PURE__ */ __name(function writeInt32LE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 4, 2147483647, -2147483648);
-    this[offset] = value & 255;
-    this[offset + 1] = value >>> 8;
-    this[offset + 2] = value >>> 16;
-    this[offset + 3] = value >>> 24;
-    return offset + 4;
-  }, "writeInt32LE");
-  Buffer2.prototype.writeInt32BE = /* @__PURE__ */ __name(function writeInt32BE(value, offset, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert)
-      checkInt(this, value, offset, 4, 2147483647, -2147483648);
-    if (value < 0)
-      value = 4294967295 + value + 1;
-    this[offset] = value >>> 24;
-    this[offset + 1] = value >>> 16;
-    this[offset + 2] = value >>> 8;
-    this[offset + 3] = value & 255;
-    return offset + 4;
-  }, "writeInt32BE");
-  Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(/* @__PURE__ */ __name(function writeBigInt64LE(value, offset = 0) {
-    return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-  }, "writeBigInt64LE"));
-  Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(/* @__PURE__ */ __name(function writeBigInt64BE(value, offset = 0) {
-    return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-  }, "writeBigInt64BE"));
-  function checkIEEE754(buf, value, offset, ext, max2, min) {
-    if (offset + ext > buf.length)
-      throw new RangeError("Index out of range");
-    if (offset < 0)
-      throw new RangeError("Index out of range");
-  }
-  __name(checkIEEE754, "checkIEEE754");
-  function writeFloat(buf, value, offset, littleEndian, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert) {
-      checkIEEE754(buf, value, offset, 4);
-    }
-    ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
-    return offset + 4;
-  }
-  __name(writeFloat, "writeFloat");
-  Buffer2.prototype.writeFloatLE = /* @__PURE__ */ __name(function writeFloatLE(value, offset, noAssert) {
-    return writeFloat(this, value, offset, true, noAssert);
-  }, "writeFloatLE");
-  Buffer2.prototype.writeFloatBE = /* @__PURE__ */ __name(function writeFloatBE(value, offset, noAssert) {
-    return writeFloat(this, value, offset, false, noAssert);
-  }, "writeFloatBE");
-  function writeDouble(buf, value, offset, littleEndian, noAssert) {
-    value = +value;
-    offset = offset >>> 0;
-    if (!noAssert) {
-      checkIEEE754(buf, value, offset, 8);
-    }
-    ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
-    return offset + 8;
-  }
-  __name(writeDouble, "writeDouble");
-  Buffer2.prototype.writeDoubleLE = /* @__PURE__ */ __name(function writeDoubleLE(value, offset, noAssert) {
-    return writeDouble(this, value, offset, true, noAssert);
-  }, "writeDoubleLE");
-  Buffer2.prototype.writeDoubleBE = /* @__PURE__ */ __name(function writeDoubleBE(value, offset, noAssert) {
-    return writeDouble(this, value, offset, false, noAssert);
-  }, "writeDoubleBE");
-  Buffer2.prototype.copy = /* @__PURE__ */ __name(function copy(target, targetStart, start, end) {
-    if (!Buffer2.isBuffer(target))
-      throw new TypeError("argument should be a Buffer");
-    if (!start)
-      start = 0;
-    if (!end && end !== 0)
-      end = this.length;
-    if (targetStart >= target.length)
-      targetStart = target.length;
-    if (!targetStart)
-      targetStart = 0;
-    if (end > 0 && end < start)
-      end = start;
-    if (end === start)
-      return 0;
-    if (target.length === 0 || this.length === 0)
-      return 0;
-    if (targetStart < 0) {
-      throw new RangeError("targetStart out of bounds");
-    }
-    if (start < 0 || start >= this.length)
-      throw new RangeError("Index out of range");
-    if (end < 0)
-      throw new RangeError("sourceEnd out of bounds");
-    if (end > this.length)
-      end = this.length;
-    if (target.length - targetStart < end - start) {
-      end = target.length - targetStart + start;
-    }
-    const len = end - start;
-    if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
-      this.copyWithin(targetStart, start, end);
-    } else {
-      Uint8Array.prototype.set.call(
-        target,
-        this.subarray(start, end),
-        targetStart
-      );
-    }
-    return len;
-  }, "copy");
-  Buffer2.prototype.fill = /* @__PURE__ */ __name(function fill(val2, start, end, encoding) {
-    if (typeof val2 === "string") {
-      if (typeof start === "string") {
-        encoding = start;
-        start = 0;
-        end = this.length;
-      } else if (typeof end === "string") {
-        encoding = end;
-        end = this.length;
-      }
-      if (encoding !== void 0 && typeof encoding !== "string") {
-        throw new TypeError("encoding must be a string");
-      }
-      if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
-        throw new TypeError("Unknown encoding: " + encoding);
-      }
-      if (val2.length === 1) {
-        const code2 = val2.charCodeAt(0);
-        if (encoding === "utf8" && code2 < 128 || encoding === "latin1") {
-          val2 = code2;
-        }
-      }
-    } else if (typeof val2 === "number") {
-      val2 = val2 & 255;
-    } else if (typeof val2 === "boolean") {
-      val2 = Number(val2);
-    }
-    if (start < 0 || this.length < start || this.length < end) {
-      throw new RangeError("Out of range index");
-    }
-    if (end <= start) {
-      return this;
-    }
-    start = start >>> 0;
-    end = end === void 0 ? this.length : end >>> 0;
-    if (!val2)
-      val2 = 0;
-    let i;
-    if (typeof val2 === "number") {
-      for (i = start; i < end; ++i) {
-        this[i] = val2;
-      }
-    } else {
-      const bytes = Buffer2.isBuffer(val2) ? val2 : Buffer2.from(val2, encoding);
-      const len = bytes.length;
-      if (len === 0) {
-        throw new TypeError('The value "' + val2 + '" is invalid for argument "value"');
-      }
-      for (i = 0; i < end - start; ++i) {
-        this[i + start] = bytes[i % len];
-      }
-    }
-    return this;
-  }, "fill");
-  const errors = {};
-  function E(sym, getMessage, Base) {
-    var _a3;
-    errors[sym] = (_a3 = class extends Base {
-      constructor() {
-        super();
-        Object.defineProperty(this, "message", {
-          value: getMessage.apply(this, arguments),
-          writable: true,
-          configurable: true
-        });
-        this.name = `${this.name} [${sym}]`;
-        this.stack;
-        delete this.name;
-      }
-      get code() {
-        return sym;
-      }
-      set code(value) {
-        Object.defineProperty(this, "code", {
-          configurable: true,
-          enumerable: true,
-          value,
-          writable: true
-        });
-      }
-      toString() {
-        return `${this.name} [${sym}]: ${this.message}`;
-      }
-    }, __name(_a3, "NodeError"), _a3);
-  }
-  __name(E, "E");
-  E(
-    "ERR_BUFFER_OUT_OF_BOUNDS",
-    function(name) {
-      if (name) {
-        return `${name} is outside of buffer bounds`;
-      }
-      return "Attempt to access memory outside buffer bounds";
-    },
-    RangeError
-  );
-  E(
-    "ERR_INVALID_ARG_TYPE",
-    function(name, actual) {
-      return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
-    },
-    TypeError
-  );
-  E(
-    "ERR_OUT_OF_RANGE",
-    function(str, range, input) {
-      let msg = `The value of "${str}" is out of range.`;
-      let received = input;
-      if (Number.isInteger(input) && Math.abs(input) > __pow(2, 32)) {
-        received = addNumericalSeparator(String(input));
-      } else if (typeof input === "bigint") {
-        received = String(input);
-        if (input > __pow(BigInt(2), BigInt(32)) || input < -__pow(BigInt(2), BigInt(32))) {
-          received = addNumericalSeparator(received);
-        }
-        received += "n";
-      }
-      msg += ` It must be ${range}. Received ${received}`;
-      return msg;
-    },
-    RangeError
-  );
-  function addNumericalSeparator(val2) {
-    let res = "";
-    let i = val2.length;
-    const start = val2[0] === "-" ? 1 : 0;
-    for (; i >= start + 4; i -= 3) {
-      res = `_${val2.slice(i - 3, i)}${res}`;
-    }
-    return `${val2.slice(0, i)}${res}`;
-  }
-  __name(addNumericalSeparator, "addNumericalSeparator");
-  function checkBounds(buf, offset, byteLength3) {
-    validateNumber(offset, "offset");
-    if (buf[offset] === void 0 || buf[offset + byteLength3] === void 0) {
-      boundsError(offset, buf.length - (byteLength3 + 1));
-    }
-  }
-  __name(checkBounds, "checkBounds");
-  function checkIntBI(value, min, max2, buf, offset, byteLength3) {
-    if (value > max2 || value < min) {
-      const n = typeof min === "bigint" ? "n" : "";
-      let range;
-      {
-        if (min === 0 || min === BigInt(0)) {
-          range = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
-        } else {
-          range = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
-        }
-      }
-      throw new errors.ERR_OUT_OF_RANGE("value", range, value);
-    }
-    checkBounds(buf, offset, byteLength3);
-  }
-  __name(checkIntBI, "checkIntBI");
-  function validateNumber(value, name) {
-    if (typeof value !== "number") {
-      throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
-    }
-  }
-  __name(validateNumber, "validateNumber");
-  function boundsError(value, length, type) {
-    if (Math.floor(value) !== value) {
-      validateNumber(value, type);
-      throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value);
-    }
-    if (length < 0) {
-      throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
-    }
-    throw new errors.ERR_OUT_OF_RANGE(
-      "offset",
-      `>= ${0} and <= ${length}`,
-      value
-    );
-  }
-  __name(boundsError, "boundsError");
-  const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
-  function base64clean(str) {
-    str = str.split("=")[0];
-    str = str.trim().replace(INVALID_BASE64_RE, "");
-    if (str.length < 2)
-      return "";
-    while (str.length % 4 !== 0) {
-      str = str + "=";
-    }
-    return str;
-  }
-  __name(base64clean, "base64clean");
-  function utf8ToBytes(string, units) {
-    units = units || Infinity;
-    let codePoint;
-    const length = string.length;
-    let leadSurrogate = null;
-    const bytes = [];
-    for (let i = 0; i < length; ++i) {
-      codePoint = string.charCodeAt(i);
-      if (codePoint > 55295 && codePoint < 57344) {
-        if (!leadSurrogate) {
-          if (codePoint > 56319) {
-            if ((units -= 3) > -1)
-              bytes.push(239, 191, 189);
-            continue;
-          } else if (i + 1 === length) {
-            if ((units -= 3) > -1)
-              bytes.push(239, 191, 189);
-            continue;
-          }
-          leadSurrogate = codePoint;
-          continue;
-        }
-        if (codePoint < 56320) {
-          if ((units -= 3) > -1)
-            bytes.push(239, 191, 189);
-          leadSurrogate = codePoint;
-          continue;
-        }
-        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
-      } else if (leadSurrogate) {
-        if ((units -= 3) > -1)
-          bytes.push(239, 191, 189);
-      }
-      leadSurrogate = null;
-      if (codePoint < 128) {
-        if ((units -= 1) < 0)
-          break;
-        bytes.push(codePoint);
-      } else if (codePoint < 2048) {
-        if ((units -= 2) < 0)
-          break;
-        bytes.push(
-          codePoint >> 6 | 192,
-          codePoint & 63 | 128
-        );
-      } else if (codePoint < 65536) {
-        if ((units -= 3) < 0)
-          break;
-        bytes.push(
-          codePoint >> 12 | 224,
-          codePoint >> 6 & 63 | 128,
-          codePoint & 63 | 128
-        );
-      } else if (codePoint < 1114112) {
-        if ((units -= 4) < 0)
-          break;
-        bytes.push(
-          codePoint >> 18 | 240,
-          codePoint >> 12 & 63 | 128,
-          codePoint >> 6 & 63 | 128,
-          codePoint & 63 | 128
-        );
-      } else {
-        throw new Error("Invalid code point");
-      }
-    }
-    return bytes;
-  }
-  __name(utf8ToBytes, "utf8ToBytes");
-  function asciiToBytes(str) {
-    const byteArray = [];
-    for (let i = 0; i < str.length; ++i) {
-      byteArray.push(str.charCodeAt(i) & 255);
-    }
-    return byteArray;
-  }
-  __name(asciiToBytes, "asciiToBytes");
-  function utf16leToBytes(str, units) {
-    let c, hi, lo;
-    const byteArray = [];
-    for (let i = 0; i < str.length; ++i) {
-      if ((units -= 2) < 0)
-        break;
-      c = str.charCodeAt(i);
-      hi = c >> 8;
-      lo = c % 256;
-      byteArray.push(lo);
-      byteArray.push(hi);
-    }
-    return byteArray;
-  }
-  __name(utf16leToBytes, "utf16leToBytes");
-  function base64ToBytes(str) {
-    return base64.toByteArray(base64clean(str));
-  }
-  __name(base64ToBytes, "base64ToBytes");
-  function blitBuffer(src, dst, offset, length) {
-    let i;
-    for (i = 0; i < length; ++i) {
-      if (i + offset >= dst.length || i >= src.length)
-        break;
-      dst[i + offset] = src[i];
-    }
-    return i;
-  }
-  __name(blitBuffer, "blitBuffer");
-  function isInstance(obj, type) {
-    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
-  }
-  __name(isInstance, "isInstance");
-  function numberIsNaN(obj) {
-    return obj !== obj;
-  }
-  __name(numberIsNaN, "numberIsNaN");
-  const hexSliceLookupTable = function() {
-    const alphabet2 = "0123456789abcdef";
-    const table = new Array(256);
-    for (let i = 0; i < 16; ++i) {
-      const i16 = i * 16;
-      for (let j = 0; j < 16; ++j) {
-        table[i16 + j] = alphabet2[i] + alphabet2[j];
-      }
-    }
-    return table;
-  }();
-  function defineBigIntMethod(fn) {
-    return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
-  }
-  __name(defineBigIntMethod, "defineBigIntMethod");
-  function BufferBigIntNotDefined() {
-    throw new Error("BigInt not supported");
-  }
-  __name(BufferBigIntNotDefined, "BufferBigIntNotDefined");
-})(buffer$1);
-const buffer = /* @__PURE__ */ getDefaultExportFromCjs(buffer$1);
-const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-function getArrayBufferFromFile(file) {
-  if (!isBrowser) {
-    return toArrayBuffer(buffer$1.Buffer.isBuffer(file) ? file : file.buffer || file);
-  }
-  const reader = new window.FileReader();
-  return new Promise((resolve, reject) => {
-    reader.onload = (e) => {
-      resolve(e.target.result);
-    };
-    reader.onerror = (err2) => {
-      console.error("err:", err2);
-      reject(err2);
-    };
-    reader.readAsArrayBuffer(
-      buffer$1.Buffer.isBuffer(file) ? file : file.buffer || file
-    );
-  });
-}
-__name(getArrayBufferFromFile, "getArrayBufferFromFile");
-function toArrayBuffer(buffer2) {
-  const ab = new ArrayBuffer(buffer2.length);
-  const view = new Uint8Array(ab);
-  for (let i = 0; i < buffer2.length; ++i) {
-    view[i] = buffer2[i];
-  }
-  return ab;
-}
-__name(toArrayBuffer, "toArrayBuffer");
-const Buffer$1 = buffer.Buffer;
-function snapgeneToJson(_0) {
-  return __async(this, arguments, function* (fileObj, options = {}) {
-    try {
-      let read = function(size, fmt) {
-        const buffer2 = Buffer$1.from(arrayBuffer.slice(offset, size + offset));
-        offset += size;
-        if (fmt) {
-          const decoder = new StringDecoder_1(fmt);
-          const toRet = decoder.write(buffer2);
-          return toRet;
-        } else {
-          return buffer2;
-        }
-      };
-      __name(read, "read");
-      const returnVal = createInitialSequence(options);
-      const arrayBuffer = yield getArrayBufferFromFile(fileObj);
-      const ext = extractFileExtension(options.fileName);
-      let isProtein = options.isProtein;
-      if (ext && /^(prot)$/.test(ext)) {
-        isProtein = true;
-        options.isProtein = true;
-      }
-      let offset = 0;
-      function unpack(size, mode) {
-        return __async(this, null, function* () {
-          const buffer2 = yield read(size);
-          const unpacked = yield bufferpack$1.unpack(">" + mode, buffer2);
-          if (unpacked === void 0)
-            return void 0;
-          return yield unpacked[0];
-        });
-      }
-      __name(unpack, "unpack");
-      yield read(1);
-      const length = yield unpack(4, "I");
-      const title = yield read(8, "ascii");
-      if (length !== 14 || title !== "SnapGene") {
-        throw new Error("Wrong format for a SnapGene file !");
-      }
-      const data = yield __spreadProps(__spreadValues({}, returnVal.parsedSequence), {
-        isProtein,
-        isDNA: !!(yield unpack(2, "H")) && !isProtein,
-        exportVersion: yield unpack(2, "H"),
-        importVersion: yield unpack(2, "H"),
-        features: []
-      });
-      while (offset <= arrayBuffer.byteLength) {
-        const next_byte = yield read(1);
-        const block_size = yield unpack(4, "I");
-        if (ord(next_byte) === 21 || ord(next_byte) === 0) {
-          const props = yield unpack(1, "b");
-          const binaryRep = dec2bin(props);
-          data.circular = isFirstBitA1(binaryRep);
-          const size = block_size - 1;
-          if (size < 0)
-            return;
-          data.size = isProtein ? size * 3 : size;
-          data.sequence = yield read(size, "utf8");
-        } else if (ord(next_byte) === 10) {
-          const strand_dict = {
-            // [strand, arrowheadType]
-            0: [1, "NONE"],
-            // non-directional feature (in that case, the attribute is generally absent altogether)
-            1: [1, "TOP"],
-            // forward strand
-            2: [-1, "BOTTOM"],
-            // reverse strand
-            3: [1, "BOTH"]
-            // bi-directional feature
-          };
-          const xml = yield read(block_size, "utf8");
-          const b = new fxp.XMLParser({
-            ignoreAttributes: false,
-            attributeNamePrefix: "",
-            isArray: (name) => name === "Feature" || name === "Segment"
-          }).parse(xml);
-          const { Features: { Feature = [] } = {} } = b;
-          data.features = [];
-          Feature.forEach((feat) => {
-            const { directionality, Segment = [], name, type } = feat;
-            let maxStart = 0;
-            let maxEnd = 0;
-            const locations = Segment && Segment.map((seg) => {
-              if (!seg)
-                throw new Error("invalid feature definition");
-              const { range } = seg;
-              let { start, end } = getStartAndEndFromRangeString(range);
-              start = isProtein ? start * 3 : start;
-              end = isProtein ? end * 3 + 2 : end;
-              maxStart = Math.max(maxStart, start);
-              maxEnd = Math.max(maxEnd, end);
-              return {
-                start,
-                end
-              };
-            });
-            data.features.push(__spreadProps(__spreadValues({
-              name,
-              type
-            }, (locations == null ? void 0 : locations.length) > 1 && { locations }), {
-              strand: directionality ? strand_dict[directionality][0] : 1,
-              arrowheadType: directionality ? strand_dict[directionality][1] : "NONE",
-              start: maxStart,
-              end: maxEnd
-              // color,
-            }));
-          });
-        } else if (ord(next_byte) === 6) {
-          const xml = yield read(block_size, "utf8");
-          const b = new fxp.XMLParser({}).parse(xml);
-          const name = get$1(b, "Notes.CustomMapLabel");
-          if (name) {
-            data.name = name;
-          }
-          const description = get$1(b, "Notes.Description");
-          if (description && typeof description === "string") {
-            data.description = description.replace("<html><body>", "").replace("</body></html>", "");
-          }
-        } else {
-          yield read(block_size);
-        }
-      }
-      returnVal.parsedSequence = data;
-      return validateSequenceArray(
-        flattenSequenceArray([returnVal], options),
-        options
-      );
-    } catch (e) {
-      console.error("Error trying to parse file as snapgene:", e);
-      return [
-        {
-          success: false,
-          messages: ["Import Error: Invalid File"]
-        }
-      ];
-    }
-  });
-}
-__name(snapgeneToJson, "snapgeneToJson");
-function getStartAndEndFromRangeString(rangestring) {
-  const [start, end] = rangestring.split("-");
-  return {
-    start: start - 1,
-    end: end - 1
-  };
-}
-__name(getStartAndEndFromRangeString, "getStartAndEndFromRangeString");
-function ord(string) {
-  const str = string + "";
-  const code2 = str.charCodeAt(0);
-  if (code2 >= 55296 && code2 <= 56319) {
-    const hi = code2;
-    if (str.length === 1) {
-      return code2;
-    }
-    const low = str.charCodeAt(1);
-    return (hi - 55296) * 1024 + (low - 56320) + 65536;
-  }
-  if (code2 >= 56320 && code2 <= 57343) {
-    return code2;
+  if (code2 >= 56320 && code2 <= 57343) {
+    return code2;
   }
   return code2;
 }
@@ -22852,6 +21100,9 @@ function abConverter(inputArrayBuffer) {
     traceData.gTrace = this.getDataTag(tagDict.colorDataG);
     traceData.cTrace = this.getDataTag(tagDict.colorDataC);
     traceData.basePos = this.getDataTag(tagDict.peakLocations);
+    if (traceData.basePos === void 0) {
+      traceData.basePos = this.getDataTag(tagDict.peakLocationsUser);
+    }
     traceData.baseCalls = this.getDataTag(tagDict.baseCalls2);
     traceData.qualNums = this.getDataTag(tagDict.qualNums);
     if (traceData.qualNums) {
@@ -22879,6 +21130,7 @@ const tagDict = {
   baseCalls2: { tagName: "PBAS", tagNum: 2, typeToReturn: "getChar" },
   qualNums: { tagName: "PCON", tagNum: 2, typeToReturn: "getNumber" },
   peakLocations: { tagName: "PLOC", tagNum: 2, typeToReturn: "getShort" },
+  peakLocationsUser: { tagName: "PLOC", tagNum: 1, typeToReturn: "getShort" },
   peakDev: { tagName: "P1RL", tagNum: 1, typeToReturn: "getShort" },
   peakOneAmp: { tagName: "P1AM", tagNum: 1, typeToReturn: "getShort" },
   colorDataA: { tagName: "DATA", tagNum: 10, typeToReturn: "getShort" },
@@ -22886,61 +21138,438 @@ const tagDict = {
   colorDataG: { tagName: "DATA", tagNum: 9, typeToReturn: "getShort" },
   colorDataC: { tagName: "DATA", tagNum: 12, typeToReturn: "getShort" }
 };
-const correctionAmount = 3;
-function convertBasePosTraceToPerBpTrace(chromData) {
-  const { basePos, aTrace } = chromData;
-  const traceLength = aTrace.length;
-  let startPos = 0;
-  let nextBasePos = basePos[1];
-  let endPos;
-  function setEndPos() {
-    if (nextBasePos) {
-      endPos = startPos + Math.ceil((nextBasePos - startPos) / 2);
-    } else {
-      endPos = traceLength;
+const correctionAmount = 3;
+function convertBasePosTraceToPerBpTrace(chromData) {
+  const { basePos, aTrace } = chromData;
+  const traceLength = aTrace.length;
+  let startPos = 0;
+  let nextBasePos = basePos[1];
+  let endPos;
+  function setEndPos() {
+    if (nextBasePos) {
+      endPos = startPos + Math.ceil((nextBasePos - startPos) / 2);
+    } else {
+      endPos = traceLength;
+    }
+  }
+  __name(setEndPos, "setEndPos");
+  setEndPos();
+  const baseTraces = [];
+  for (let i = 0; i < basePos.length; i++) {
+    const tracesForType = {
+      aTrace: [],
+      tTrace: [],
+      gTrace: [],
+      cTrace: []
+    };
+    baseTraces[i] = tracesForType;
+    [
+      "aTrace",
+      "tTrace",
+      "gTrace",
+      "cTrace"
+      // eslint-disable-next-line no-loop-func
+    ].forEach((type) => {
+      const traceForType = tracesForType[type];
+      const traceData = chromData[type];
+      for (let j = startPos; j < endPos + correctionAmount; j++) {
+        traceForType.push(traceData[j] || 0);
+      }
+    });
+    if (i !== basePos.length - 1) {
+      startPos = endPos + correctionAmount;
+      nextBasePos = basePos[i + 2];
+      setEndPos();
+    }
+  }
+  return __spreadValues({
+    baseTraces
+  }, chromData);
+}
+__name(convertBasePosTraceToPerBpTrace, "convertBasePosTraceToPerBpTrace");
+var events = { exports: {} };
+var R = typeof Reflect === "object" ? Reflect : null;
+var ReflectApply = R && typeof R.apply === "function" ? R.apply : /* @__PURE__ */ __name(function ReflectApply2(target, receiver, args) {
+  return Function.prototype.apply.call(target, receiver, args);
+}, "ReflectApply");
+var ReflectOwnKeys;
+if (R && typeof R.ownKeys === "function") {
+  ReflectOwnKeys = R.ownKeys;
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+  }, "ReflectOwnKeys");
+} else {
+  ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+    return Object.getOwnPropertyNames(target);
+  }, "ReflectOwnKeys");
+}
+function ProcessEmitWarning(warning) {
+  if (console && console.warn)
+    console.warn(warning);
+}
+__name(ProcessEmitWarning, "ProcessEmitWarning");
+var NumberIsNaN = Number.isNaN || /* @__PURE__ */ __name(function NumberIsNaN2(value) {
+  return value !== value;
+}, "NumberIsNaN");
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+__name(EventEmitter, "EventEmitter");
+events.exports = EventEmitter;
+events.exports.once = once2;
+EventEmitter.EventEmitter = EventEmitter;
+EventEmitter.prototype._events = void 0;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = void 0;
+var defaultMaxListeners = 10;
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+__name(checkListener, "checkListener");
+Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+    }
+    defaultMaxListeners = arg;
+  }
+});
+EventEmitter.init = function() {
+  if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+  }
+  this._maxListeners = this._maxListeners || void 0;
+};
+EventEmitter.prototype.setMaxListeners = /* @__PURE__ */ __name(function setMaxListeners(n) {
+  if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+  }
+  this._maxListeners = n;
+  return this;
+}, "setMaxListeners");
+function _getMaxListeners(that) {
+  if (that._maxListeners === void 0)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+__name(_getMaxListeners, "_getMaxListeners");
+EventEmitter.prototype.getMaxListeners = /* @__PURE__ */ __name(function getMaxListeners() {
+  return _getMaxListeners(this);
+}, "getMaxListeners");
+EventEmitter.prototype.emit = /* @__PURE__ */ __name(function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++)
+    args.push(arguments[i]);
+  var doError = type === "error";
+  var events2 = this._events;
+  if (events2 !== void 0)
+    doError = doError && events2.error === void 0;
+  else if (!doError)
+    return false;
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      throw er;
+    }
+    var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+    err2.context = er;
+    throw err2;
+  }
+  var handler = events2[type];
+  if (handler === void 0)
+    return false;
+  if (typeof handler === "function") {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners2 = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners2[i], this, args);
+  }
+  return true;
+}, "emit");
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events2;
+  var existing;
+  checkListener(listener);
+  events2 = target._events;
+  if (events2 === void 0) {
+    events2 = target._events = /* @__PURE__ */ Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    if (events2.newListener !== void 0) {
+      target.emit(
+        "newListener",
+        type,
+        listener.listener ? listener.listener : listener
+      );
+      events2 = target._events;
+    }
+    existing = events2[type];
+  }
+  if (existing === void 0) {
+    existing = events2[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === "function") {
+      existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      w.name = "MaxListenersExceededWarning";
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+  return target;
+}
+__name(_addListener, "_addListener");
+EventEmitter.prototype.addListener = /* @__PURE__ */ __name(function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+}, "addListener");
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter.prototype.prependListener = /* @__PURE__ */ __name(function prependListener(type, listener) {
+  return _addListener(this, type, listener, true);
+}, "prependListener");
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
+  }
+}
+__name(onceWrapper, "onceWrapper");
+function _onceWrap(target, type, listener) {
+  var state2 = { fired: false, wrapFn: void 0, target, type, listener };
+  var wrapped = onceWrapper.bind(state2);
+  wrapped.listener = listener;
+  state2.wrapFn = wrapped;
+  return wrapped;
+}
+__name(_onceWrap, "_onceWrap");
+EventEmitter.prototype.once = /* @__PURE__ */ __name(function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+}, "once");
+EventEmitter.prototype.prependOnceListener = /* @__PURE__ */ __name(function prependOnceListener(type, listener) {
+  checkListener(listener);
+  this.prependListener(type, _onceWrap(this, type, listener));
+  return this;
+}, "prependOnceListener");
+EventEmitter.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(type, listener) {
+  var list, events2, position, i, originalListener;
+  checkListener(listener);
+  events2 = this._events;
+  if (events2 === void 0)
+    return this;
+  list = events2[type];
+  if (list === void 0)
+    return this;
+  if (list === listener || list.listener === listener) {
+    if (--this._eventsCount === 0)
+      this._events = /* @__PURE__ */ Object.create(null);
+    else {
+      delete events2[type];
+      if (events2.removeListener)
+        this.emit("removeListener", type, list.listener || listener);
+    }
+  } else if (typeof list !== "function") {
+    position = -1;
+    for (i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        originalListener = list[i].listener;
+        position = i;
+        break;
+      }
+    }
+    if (position < 0)
+      return this;
+    if (position === 0)
+      list.shift();
+    else {
+      spliceOne(list, position);
+    }
+    if (list.length === 1)
+      events2[type] = list[0];
+    if (events2.removeListener !== void 0)
+      this.emit("removeListener", type, originalListener || listener);
+  }
+  return this;
+}, "removeListener");
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(type) {
+  var listeners2, events2, i;
+  events2 = this._events;
+  if (events2 === void 0)
+    return this;
+  if (events2.removeListener === void 0) {
+    if (arguments.length === 0) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    } else if (events2[type] !== void 0) {
+      if (--this._eventsCount === 0)
+        this._events = /* @__PURE__ */ Object.create(null);
+      else
+        delete events2[type];
+    }
+    return this;
+  }
+  if (arguments.length === 0) {
+    var keys2 = Object.keys(events2);
+    var key;
+    for (i = 0; i < keys2.length; ++i) {
+      key = keys2[i];
+      if (key === "removeListener")
+        continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners("removeListener");
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+    return this;
+  }
+  listeners2 = events2[type];
+  if (typeof listeners2 === "function") {
+    this.removeListener(type, listeners2);
+  } else if (listeners2 !== void 0) {
+    for (i = listeners2.length - 1; i >= 0; i--) {
+      this.removeListener(type, listeners2[i]);
+    }
+  }
+  return this;
+}, "removeAllListeners");
+function _listeners(target, type, unwrap) {
+  var events2 = target._events;
+  if (events2 === void 0)
+    return [];
+  var evlistener = events2[type];
+  if (evlistener === void 0)
+    return [];
+  if (typeof evlistener === "function")
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+__name(_listeners, "_listeners");
+EventEmitter.prototype.listeners = /* @__PURE__ */ __name(function listeners(type) {
+  return _listeners(this, type, true);
+}, "listeners");
+EventEmitter.prototype.rawListeners = /* @__PURE__ */ __name(function rawListeners(type) {
+  return _listeners(this, type, false);
+}, "rawListeners");
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === "function") {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events2 = this._events;
+  if (events2 !== void 0) {
+    var evlistener = events2[type];
+    if (typeof evlistener === "function") {
+      return 1;
+    } else if (evlistener !== void 0) {
+      return evlistener.length;
     }
   }
-  __name(setEndPos, "setEndPos");
-  setEndPos();
-  const baseTraces = [];
-  for (let i = 0; i < basePos.length; i++) {
-    const tracesForType = {
-      aTrace: [],
-      tTrace: [],
-      gTrace: [],
-      cTrace: []
-    };
-    baseTraces[i] = tracesForType;
-    [
-      "aTrace",
-      "tTrace",
-      "gTrace",
-      "cTrace"
-      // eslint-disable-next-line no-loop-func
-    ].forEach((type) => {
-      const traceForType = tracesForType[type];
-      const traceData = chromData[type];
-      for (let j = startPos; j < endPos + correctionAmount; j++) {
-        traceForType.push(traceData[j] || 0);
+  return 0;
+}
+__name(listenerCount, "listenerCount");
+EventEmitter.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+}, "eventNames");
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+__name(arrayClone, "arrayClone");
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
+__name(spliceOne, "spliceOne");
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+__name(unwrapListeners, "unwrapListeners");
+function once2(emitter, name) {
+  return new Promise(function(resolve, reject) {
+    function errorListener(err2) {
+      emitter.removeListener(name, resolver);
+      reject(err2);
+    }
+    __name(errorListener, "errorListener");
+    function resolver() {
+      if (typeof emitter.removeListener === "function") {
+        emitter.removeListener("error", errorListener);
       }
-    });
-    if (i !== basePos.length - 1) {
-      startPos = endPos + correctionAmount;
-      nextBasePos = basePos[i + 2];
-      setEndPos();
+      resolve([].slice.call(arguments));
     }
+    __name(resolver, "resolver");
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== "error") {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+__name(once2, "once");
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === "function") {
+    eventTargetAgnosticAddListener(emitter, "error", handler, flags);
   }
-  return __spreadValues({
-    baseTraces
-  }, chromData);
 }
-__name(convertBasePosTraceToPerBpTrace, "convertBasePosTraceToPerBpTrace");
-const __viteBrowserExternal = {};
-const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: __viteBrowserExternal
-}, Symbol.toStringTag, { value: "Module" }));
-const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+__name(addErrorHandlerIfEventEmitter, "addErrorHandlerIfEventEmitter");
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === "function") {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
+    emitter.addEventListener(name, /* @__PURE__ */ __name(function wrapListener(arg) {
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    }, "wrapListener"));
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+__name(eventTargetAgnosticAddListener, "eventTargetAgnosticAddListener");
+var eventsExports = events.exports;
 var inherits_browser = { exports: {} };
 if (typeof Object.create === "function") {
   inherits_browser.exports = /* @__PURE__ */ __name(function inherits2(ctor, superCtor) {
@@ -22975,10 +21604,16 @@ function requireStreamBrowser() {
   if (hasRequiredStreamBrowser)
     return streamBrowser;
   hasRequiredStreamBrowser = 1;
-  streamBrowser = require$$0.EventEmitter;
+  streamBrowser = eventsExports.EventEmitter;
   return streamBrowser;
 }
 __name(requireStreamBrowser, "requireStreamBrowser");
+const __viteBrowserExternal = {};
+const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$3 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
 var buffer_list;
 var hasRequiredBuffer_list;
 function requireBuffer_list() {
@@ -23060,8 +21695,8 @@ function requireBuffer_list() {
     return (hint === "string" ? String : Number)(input);
   }
   __name(_toPrimitive, "_toPrimitive");
-  var _require = buffer$2, Buffer2 = _require.Buffer;
-  var _require2 = require$$0, inspect = _require2.inspect;
+  var _require = buffer$1, Buffer2 = _require.Buffer;
+  var _require2 = require$$3, inspect = _require2.inspect;
   var custom = inspect && inspect.custom || "inspect";
   function copyBuffer(src, target, offset) {
     Buffer2.prototype.copy.call(src, target, offset);
@@ -23565,7 +22200,7 @@ function require_stream_writable() {
     deprecate: requireBrowser()
   };
   var Stream2 = requireStreamBrowser();
-  var Buffer2 = buffer$2.Buffer;
+  var Buffer2 = buffer$1.Buffer;
   var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
   };
   function _uint8ArrayToBuffer(chunk) {
@@ -24167,7 +22802,7 @@ function requireEndOfStream() {
     return endOfStream;
   hasRequiredEndOfStream = 1;
   var ERR_STREAM_PREMATURE_CLOSE = requireErrorsBrowser().codes.ERR_STREAM_PREMATURE_CLOSE;
-  function once(callback) {
+  function once3(callback) {
     var called = false;
     return function() {
       if (called)
@@ -24179,7 +22814,7 @@ function requireEndOfStream() {
       callback.apply(this, args);
     };
   }
-  __name(once, "once");
+  __name(once3, "once");
   function noop2() {
   }
   __name(noop2, "noop");
@@ -24192,7 +22827,7 @@ function requireEndOfStream() {
       return eos(stream, null, opts);
     if (!opts)
       opts = {};
-    callback = once(callback || noop2);
+    callback = once3(callback || noop2);
     var readable = opts.readable || opts.readable !== false && stream.readable;
     var writable = opts.writable || opts.writable !== false && stream.writable;
     var onlegacyfinish = /* @__PURE__ */ __name(function onlegacyfinish2() {
@@ -24482,12 +23117,12 @@ function require_stream_readable() {
   _stream_readable = Readable;
   var Duplex;
   Readable.ReadableState = ReadableState;
-  require$$0.EventEmitter;
+  eventsExports.EventEmitter;
   var EElistenerCount = /* @__PURE__ */ __name(function EElistenerCount2(emitter, type) {
     return emitter.listeners(type).length;
   }, "EElistenerCount");
   var Stream2 = requireStreamBrowser();
-  var Buffer2 = buffer$2.Buffer;
+  var Buffer2 = buffer$1.Buffer;
   var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
   };
   function _uint8ArrayToBuffer(chunk) {
@@ -24498,7 +23133,7 @@ function require_stream_readable() {
     return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
   }
   __name(_isUint8Array, "_isUint8Array");
-  var debugUtil = require$$0;
+  var debugUtil = require$$3;
   var debug;
   if (debugUtil && debugUtil.debuglog) {
     debug = debugUtil.debuglog("stream");
@@ -24516,7 +23151,7 @@ function require_stream_readable() {
   inherits_browserExports(Readable, Stream2);
   var errorOrDestroy = destroyImpl.errorOrDestroy;
   var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
-  function prependListener(emitter, event, fn) {
+  function prependListener2(emitter, event, fn) {
     if (typeof emitter.prependListener === "function")
       return emitter.prependListener(event, fn);
     if (!emitter._events || !emitter._events[event])
@@ -24526,7 +23161,7 @@ function require_stream_readable() {
     else
       emitter._events[event] = [fn, emitter._events[event]];
   }
-  __name(prependListener, "prependListener");
+  __name(prependListener2, "prependListener");
   function ReadableState(options, stream, isDuplex) {
     Duplex = Duplex || require_stream_duplex();
     options = options || {};
@@ -24960,7 +23595,7 @@ function require_stream_readable() {
         errorOrDestroy(dest, er);
     }
     __name(onerror, "onerror");
-    prependListener(dest, "error", onerror);
+    prependListener2(dest, "error", onerror);
     function onclose() {
       dest.removeListener("finish", onfinish);
       unpipe();
@@ -25437,7 +24072,7 @@ function requirePipeline() {
     return pipeline_1;
   hasRequiredPipeline = 1;
   var eos;
-  function once(callback) {
+  function once3(callback) {
     var called = false;
     return function() {
       if (called)
@@ -25446,7 +24081,7 @@ function requirePipeline() {
       callback.apply(void 0, arguments);
     };
   }
-  __name(once, "once");
+  __name(once3, "once");
   var _require$codes = requireErrorsBrowser().codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
   function noop2(err2) {
     if (err2)
@@ -25458,7 +24093,7 @@ function requirePipeline() {
   }
   __name(isRequest, "isRequest");
   function destroyer(stream, reading, writing, callback) {
-    callback = once(callback);
+    callback = once3(callback);
     var closed = false;
     stream.on("close", function() {
       closed = true;
@@ -25538,7 +24173,7 @@ function requirePipeline() {
 }
 __name(requirePipeline, "requirePipeline");
 var streamBrowserify = Stream;
-var EE = require$$0.EventEmitter;
+var EE = eventsExports.EventEmitter;
 var inherits = inherits_browserExports;
 inherits(Stream, EE);
 Stream.Readable = require_stream_readable();
@@ -27098,7 +25733,7 @@ function getUint8ArrayFromFile(file, { emulateBrowser } = {}) {
 }
 __name(getUint8ArrayFromFile, "getUint8ArrayFromFile");
 var colorString$1 = { exports: {} };
-var colorName = {
+var colorName$1 = {
   "aliceblue": [240, 248, 255],
   "antiquewhite": [250, 235, 215],
   "aqua": [0, 255, 255],
@@ -27276,7 +25911,7 @@ swizzle$1.wrap = function(fn) {
   };
 };
 var simpleSwizzleExports = simpleSwizzle.exports;
-var colorNames = colorName;
+var colorNames = colorName$1;
 var swizzle2 = simpleSwizzleExports;
 var hasOwnProperty = Object.hasOwnProperty;
 var reverseNames = /* @__PURE__ */ Object.create(null);
@@ -27457,12 +26092,165 @@ function hexDouble(num) {
 }
 __name(hexDouble, "hexDouble");
 var colorStringExports = colorString$1.exports;
-const cssKeywords = colorName;
-const reverseKeywords = {};
-for (const key of Object.keys(cssKeywords)) {
-  reverseKeywords[cssKeywords[key]] = key;
+var conversions$2 = { exports: {} };
+var colorName = {
+  "aliceblue": [240, 248, 255],
+  "antiquewhite": [250, 235, 215],
+  "aqua": [0, 255, 255],
+  "aquamarine": [127, 255, 212],
+  "azure": [240, 255, 255],
+  "beige": [245, 245, 220],
+  "bisque": [255, 228, 196],
+  "black": [0, 0, 0],
+  "blanchedalmond": [255, 235, 205],
+  "blue": [0, 0, 255],
+  "blueviolet": [138, 43, 226],
+  "brown": [165, 42, 42],
+  "burlywood": [222, 184, 135],
+  "cadetblue": [95, 158, 160],
+  "chartreuse": [127, 255, 0],
+  "chocolate": [210, 105, 30],
+  "coral": [255, 127, 80],
+  "cornflowerblue": [100, 149, 237],
+  "cornsilk": [255, 248, 220],
+  "crimson": [220, 20, 60],
+  "cyan": [0, 255, 255],
+  "darkblue": [0, 0, 139],
+  "darkcyan": [0, 139, 139],
+  "darkgoldenrod": [184, 134, 11],
+  "darkgray": [169, 169, 169],
+  "darkgreen": [0, 100, 0],
+  "darkgrey": [169, 169, 169],
+  "darkkhaki": [189, 183, 107],
+  "darkmagenta": [139, 0, 139],
+  "darkolivegreen": [85, 107, 47],
+  "darkorange": [255, 140, 0],
+  "darkorchid": [153, 50, 204],
+  "darkred": [139, 0, 0],
+  "darksalmon": [233, 150, 122],
+  "darkseagreen": [143, 188, 143],
+  "darkslateblue": [72, 61, 139],
+  "darkslategray": [47, 79, 79],
+  "darkslategrey": [47, 79, 79],
+  "darkturquoise": [0, 206, 209],
+  "darkviolet": [148, 0, 211],
+  "deeppink": [255, 20, 147],
+  "deepskyblue": [0, 191, 255],
+  "dimgray": [105, 105, 105],
+  "dimgrey": [105, 105, 105],
+  "dodgerblue": [30, 144, 255],
+  "firebrick": [178, 34, 34],
+  "floralwhite": [255, 250, 240],
+  "forestgreen": [34, 139, 34],
+  "fuchsia": [255, 0, 255],
+  "gainsboro": [220, 220, 220],
+  "ghostwhite": [248, 248, 255],
+  "gold": [255, 215, 0],
+  "goldenrod": [218, 165, 32],
+  "gray": [128, 128, 128],
+  "green": [0, 128, 0],
+  "greenyellow": [173, 255, 47],
+  "grey": [128, 128, 128],
+  "honeydew": [240, 255, 240],
+  "hotpink": [255, 105, 180],
+  "indianred": [205, 92, 92],
+  "indigo": [75, 0, 130],
+  "ivory": [255, 255, 240],
+  "khaki": [240, 230, 140],
+  "lavender": [230, 230, 250],
+  "lavenderblush": [255, 240, 245],
+  "lawngreen": [124, 252, 0],
+  "lemonchiffon": [255, 250, 205],
+  "lightblue": [173, 216, 230],
+  "lightcoral": [240, 128, 128],
+  "lightcyan": [224, 255, 255],
+  "lightgoldenrodyellow": [250, 250, 210],
+  "lightgray": [211, 211, 211],
+  "lightgreen": [144, 238, 144],
+  "lightgrey": [211, 211, 211],
+  "lightpink": [255, 182, 193],
+  "lightsalmon": [255, 160, 122],
+  "lightseagreen": [32, 178, 170],
+  "lightskyblue": [135, 206, 250],
+  "lightslategray": [119, 136, 153],
+  "lightslategrey": [119, 136, 153],
+  "lightsteelblue": [176, 196, 222],
+  "lightyellow": [255, 255, 224],
+  "lime": [0, 255, 0],
+  "limegreen": [50, 205, 50],
+  "linen": [250, 240, 230],
+  "magenta": [255, 0, 255],
+  "maroon": [128, 0, 0],
+  "mediumaquamarine": [102, 205, 170],
+  "mediumblue": [0, 0, 205],
+  "mediumorchid": [186, 85, 211],
+  "mediumpurple": [147, 112, 219],
+  "mediumseagreen": [60, 179, 113],
+  "mediumslateblue": [123, 104, 238],
+  "mediumspringgreen": [0, 250, 154],
+  "mediumturquoise": [72, 209, 204],
+  "mediumvioletred": [199, 21, 133],
+  "midnightblue": [25, 25, 112],
+  "mintcream": [245, 255, 250],
+  "mistyrose": [255, 228, 225],
+  "moccasin": [255, 228, 181],
+  "navajowhite": [255, 222, 173],
+  "navy": [0, 0, 128],
+  "oldlace": [253, 245, 230],
+  "olive": [128, 128, 0],
+  "olivedrab": [107, 142, 35],
+  "orange": [255, 165, 0],
+  "orangered": [255, 69, 0],
+  "orchid": [218, 112, 214],
+  "palegoldenrod": [238, 232, 170],
+  "palegreen": [152, 251, 152],
+  "paleturquoise": [175, 238, 238],
+  "palevioletred": [219, 112, 147],
+  "papayawhip": [255, 239, 213],
+  "peachpuff": [255, 218, 185],
+  "peru": [205, 133, 63],
+  "pink": [255, 192, 203],
+  "plum": [221, 160, 221],
+  "powderblue": [176, 224, 230],
+  "purple": [128, 0, 128],
+  "rebeccapurple": [102, 51, 153],
+  "red": [255, 0, 0],
+  "rosybrown": [188, 143, 143],
+  "royalblue": [65, 105, 225],
+  "saddlebrown": [139, 69, 19],
+  "salmon": [250, 128, 114],
+  "sandybrown": [244, 164, 96],
+  "seagreen": [46, 139, 87],
+  "seashell": [255, 245, 238],
+  "sienna": [160, 82, 45],
+  "silver": [192, 192, 192],
+  "skyblue": [135, 206, 235],
+  "slateblue": [106, 90, 205],
+  "slategray": [112, 128, 144],
+  "slategrey": [112, 128, 144],
+  "snow": [255, 250, 250],
+  "springgreen": [0, 255, 127],
+  "steelblue": [70, 130, 180],
+  "tan": [210, 180, 140],
+  "teal": [0, 128, 128],
+  "thistle": [216, 191, 216],
+  "tomato": [255, 99, 71],
+  "turquoise": [64, 224, 208],
+  "violet": [238, 130, 238],
+  "wheat": [245, 222, 179],
+  "white": [255, 255, 255],
+  "whitesmoke": [245, 245, 245],
+  "yellow": [255, 255, 0],
+  "yellowgreen": [154, 205, 50]
+};
+var cssKeywords = colorName;
+var reverseKeywords = {};
+for (var key in cssKeywords) {
+  if (cssKeywords.hasOwnProperty(key)) {
+    reverseKeywords[cssKeywords[key]] = key;
+  }
 }
-const convert$2 = {
+var convert$2 = conversions$2.exports = {
   rgb: { channels: 3, labels: "rgb" },
   hsl: { channels: 3, labels: "hsl" },
   hsv: { channels: 3, labels: "hsv" },
@@ -27479,32 +26267,35 @@ const convert$2 = {
   apple: { channels: 3, labels: ["r16", "g16", "b16"] },
   gray: { channels: 1, labels: ["gray"] }
 };
-var conversions$2 = convert$2;
-for (const model of Object.keys(convert$2)) {
-  if (!("channels" in convert$2[model])) {
-    throw new Error("missing channels property: " + model);
-  }
-  if (!("labels" in convert$2[model])) {
-    throw new Error("missing channel labels property: " + model);
-  }
-  if (convert$2[model].labels.length !== convert$2[model].channels) {
-    throw new Error("channel and label counts mismatch: " + model);
+for (var model in convert$2) {
+  if (convert$2.hasOwnProperty(model)) {
+    if (!("channels" in convert$2[model])) {
+      throw new Error("missing channels property: " + model);
+    }
+    if (!("labels" in convert$2[model])) {
+      throw new Error("missing channel labels property: " + model);
+    }
+    if (convert$2[model].labels.length !== convert$2[model].channels) {
+      throw new Error("channel and label counts mismatch: " + model);
+    }
+    var channels = convert$2[model].channels;
+    var labels = convert$2[model].labels;
+    delete convert$2[model].channels;
+    delete convert$2[model].labels;
+    Object.defineProperty(convert$2[model], "channels", { value: channels });
+    Object.defineProperty(convert$2[model], "labels", { value: labels });
   }
-  const { channels, labels } = convert$2[model];
-  delete convert$2[model].channels;
-  delete convert$2[model].labels;
-  Object.defineProperty(convert$2[model], "channels", { value: channels });
-  Object.defineProperty(convert$2[model], "labels", { value: labels });
 }
 convert$2.rgb.hsl = function(rgb) {
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const min = Math.min(r, g, b);
-  const max2 = Math.max(r, g, b);
-  const delta = max2 - min;
-  let h;
-  let s;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var min = Math.min(r, g, b);
+  var max2 = Math.max(r, g, b);
+  var delta = max2 - min;
+  var h;
+  var s;
+  var l;
   if (max2 === min) {
     h = 0;
   } else if (r === max2) {
@@ -27518,7 +26309,7 @@ convert$2.rgb.hsl = function(rgb) {
   if (h < 0) {
     h += 360;
   }
-  const l = (min + max2) / 2;
+  l = (min + max2) / 2;
   if (max2 === min) {
     s = 0;
   } else if (l <= 0.5) {
@@ -27529,22 +26320,21 @@ convert$2.rgb.hsl = function(rgb) {
   return [h, s * 100, l * 100];
 };
 convert$2.rgb.hsv = function(rgb) {
-  let rdif;
-  let gdif;
-  let bdif;
-  let h;
-  let s;
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const v = Math.max(r, g, b);
-  const diff = v - Math.min(r, g, b);
-  const diffc = /* @__PURE__ */ __name(function(c) {
+  var rdif;
+  var gdif;
+  var bdif;
+  var h;
+  var s;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var v = Math.max(r, g, b);
+  var diff = v - Math.min(r, g, b);
+  var diffc = /* @__PURE__ */ __name(function(c) {
     return (v - c) / 6 / diff + 1 / 2;
   }, "diffc");
   if (diff === 0) {
-    h = 0;
-    s = 0;
+    h = s = 0;
   } else {
     s = diff / v;
     rdif = diffc(r);
@@ -27570,41 +26360,47 @@ convert$2.rgb.hsv = function(rgb) {
   ];
 };
 convert$2.rgb.hwb = function(rgb) {
-  const r = rgb[0];
-  const g = rgb[1];
-  let b = rgb[2];
-  const h = convert$2.rgb.hsl(rgb)[0];
-  const w = 1 / 255 * Math.min(r, Math.min(g, b));
+  var r = rgb[0];
+  var g = rgb[1];
+  var b = rgb[2];
+  var h = convert$2.rgb.hsl(rgb)[0];
+  var w = 1 / 255 * Math.min(r, Math.min(g, b));
   b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
   return [h, w * 100, b * 100];
 };
 convert$2.rgb.cmyk = function(rgb) {
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const k = Math.min(1 - r, 1 - g, 1 - b);
-  const c = (1 - r - k) / (1 - k) || 0;
-  const m = (1 - g - k) / (1 - k) || 0;
-  const y = (1 - b - k) / (1 - k) || 0;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var c;
+  var m;
+  var y;
+  var k;
+  k = Math.min(1 - r, 1 - g, 1 - b);
+  c = (1 - r - k) / (1 - k) || 0;
+  m = (1 - g - k) / (1 - k) || 0;
+  y = (1 - b - k) / (1 - k) || 0;
   return [c * 100, m * 100, y * 100, k * 100];
 };
 function comparativeDistance(x, y) {
-  return __pow(x[0] - y[0], 2) + __pow(x[1] - y[1], 2) + __pow(x[2] - y[2], 2);
+  return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
 }
 __name(comparativeDistance, "comparativeDistance");
 convert$2.rgb.keyword = function(rgb) {
-  const reversed = reverseKeywords[rgb];
+  var reversed = reverseKeywords[rgb];
   if (reversed) {
     return reversed;
   }
-  let currentClosestDistance = Infinity;
-  let currentClosestKeyword;
-  for (const keyword of Object.keys(cssKeywords)) {
-    const value = cssKeywords[keyword];
-    const distance = comparativeDistance(rgb, value);
-    if (distance < currentClosestDistance) {
-      currentClosestDistance = distance;
-      currentClosestKeyword = keyword;
+  var currentClosestDistance = Infinity;
+  var currentClosestKeyword;
+  for (var keyword in cssKeywords) {
+    if (cssKeywords.hasOwnProperty(keyword)) {
+      var value = cssKeywords[keyword];
+      var distance = comparativeDistance(rgb, value);
+      if (distance < currentClosestDistance) {
+        currentClosestDistance = distance;
+        currentClosestKeyword = keyword;
+      }
     }
   }
   return currentClosestKeyword;
@@ -27613,40 +26409,45 @@ convert$2.keyword.rgb = function(keyword) {
   return cssKeywords[keyword];
 };
 convert$2.rgb.xyz = function(rgb) {
-  let r = rgb[0] / 255;
-  let g = rgb[1] / 255;
-  let b = rgb[2] / 255;
-  r = r > 0.04045 ? __pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
-  g = g > 0.04045 ? __pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
-  b = b > 0.04045 ? __pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
-  const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
-  const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
-  const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+  g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+  b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+  var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+  var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+  var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
   return [x * 100, y * 100, z * 100];
 };
 convert$2.rgb.lab = function(rgb) {
-  const xyz = convert$2.rgb.xyz(rgb);
-  let x = xyz[0];
-  let y = xyz[1];
-  let z = xyz[2];
+  var xyz = convert$2.rgb.xyz(rgb);
+  var x = xyz[0];
+  var y = xyz[1];
+  var z = xyz[2];
+  var l;
+  var a;
+  var b;
   x /= 95.047;
   y /= 100;
   z /= 108.883;
-  x = x > 8856e-6 ? __pow(x, 1 / 3) : 7.787 * x + 16 / 116;
-  y = y > 8856e-6 ? __pow(y, 1 / 3) : 7.787 * y + 16 / 116;
-  z = z > 8856e-6 ? __pow(z, 1 / 3) : 7.787 * z + 16 / 116;
-  const l = 116 * y - 16;
-  const a = 500 * (x - y);
-  const b = 200 * (y - z);
+  x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+  y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+  z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+  l = 116 * y - 16;
+  a = 500 * (x - y);
+  b = 200 * (y - z);
   return [l, a, b];
 };
 convert$2.hsl.rgb = function(hsl) {
-  const h = hsl[0] / 360;
-  const s = hsl[1] / 100;
-  const l = hsl[2] / 100;
-  let t2;
-  let t3;
-  let val2;
+  var h = hsl[0] / 360;
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var t1;
+  var t2;
+  var t3;
+  var rgb;
+  var val2;
   if (s === 0) {
     val2 = l * 255;
     return [val2, val2, val2];
@@ -27656,9 +26457,9 @@ convert$2.hsl.rgb = function(hsl) {
   } else {
     t2 = l + s - l * s;
   }
-  const t1 = 2 * l - t2;
-  const rgb = [0, 0, 0];
-  for (let i = 0; i < 3; i++) {
+  t1 = 2 * l - t2;
+  rgb = [0, 0, 0];
+  for (var i = 0; i < 3; i++) {
     t3 = h + 1 / 3 * -(i - 1);
     if (t3 < 0) {
       t3++;
@@ -27680,27 +26481,29 @@ convert$2.hsl.rgb = function(hsl) {
   return rgb;
 };
 convert$2.hsl.hsv = function(hsl) {
-  const h = hsl[0];
-  let s = hsl[1] / 100;
-  let l = hsl[2] / 100;
-  let smin = s;
-  const lmin = Math.max(l, 0.01);
+  var h = hsl[0];
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var smin = s;
+  var lmin = Math.max(l, 0.01);
+  var sv;
+  var v;
   l *= 2;
   s *= l <= 1 ? l : 2 - l;
   smin *= lmin <= 1 ? lmin : 2 - lmin;
-  const v = (l + s) / 2;
-  const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+  v = (l + s) / 2;
+  sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
   return [h, sv * 100, v * 100];
 };
 convert$2.hsv.rgb = function(hsv) {
-  const h = hsv[0] / 60;
-  const s = hsv[1] / 100;
-  let v = hsv[2] / 100;
-  const hi = Math.floor(h) % 6;
-  const f = h - Math.floor(h);
-  const p = 255 * v * (1 - s);
-  const q = 255 * v * (1 - s * f);
-  const t = 255 * v * (1 - s * (1 - f));
+  var h = hsv[0] / 60;
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var hi = Math.floor(h) % 6;
+  var f = h - Math.floor(h);
+  var p = 255 * v * (1 - s);
+  var q = 255 * v * (1 - s * f);
+  var t = 255 * v * (1 - s * (1 - f));
   v *= 255;
   switch (hi) {
     case 0:
@@ -27718,14 +26521,15 @@ convert$2.hsv.rgb = function(hsv) {
   }
 };
 convert$2.hsv.hsl = function(hsv) {
-  const h = hsv[0];
-  const s = hsv[1] / 100;
-  const v = hsv[2] / 100;
-  const vmin = Math.max(v, 0.01);
-  let sl;
-  let l;
+  var h = hsv[0];
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var vmin = Math.max(v, 0.01);
+  var lmin;
+  var sl;
+  var l;
   l = (2 - s) * v;
-  const lmin = (2 - s) * vmin;
+  lmin = (2 - s) * vmin;
   sl = s * vmin;
   sl /= lmin <= 1 ? lmin : 2 - lmin;
   sl = sl || 0;
@@ -27733,25 +26537,28 @@ convert$2.hsv.hsl = function(hsv) {
   return [h, sl * 100, l * 100];
 };
 convert$2.hwb.rgb = function(hwb) {
-  const h = hwb[0] / 360;
-  let wh = hwb[1] / 100;
-  let bl = hwb[2] / 100;
-  const ratio = wh + bl;
-  let f;
+  var h = hwb[0] / 360;
+  var wh = hwb[1] / 100;
+  var bl = hwb[2] / 100;
+  var ratio = wh + bl;
+  var i;
+  var v;
+  var f;
+  var n;
   if (ratio > 1) {
     wh /= ratio;
     bl /= ratio;
   }
-  const i = Math.floor(6 * h);
-  const v = 1 - bl;
+  i = Math.floor(6 * h);
+  v = 1 - bl;
   f = 6 * h - i;
   if ((i & 1) !== 0) {
     f = 1 - f;
   }
-  const n = wh + f * (v - wh);
-  let r;
-  let g;
-  let b;
+  n = wh + f * (v - wh);
+  var r;
+  var g;
+  var b;
   switch (i) {
     default:
     case 6:
@@ -27789,61 +26596,67 @@ convert$2.hwb.rgb = function(hwb) {
   return [r * 255, g * 255, b * 255];
 };
 convert$2.cmyk.rgb = function(cmyk) {
-  const c = cmyk[0] / 100;
-  const m = cmyk[1] / 100;
-  const y = cmyk[2] / 100;
-  const k = cmyk[3] / 100;
-  const r = 1 - Math.min(1, c * (1 - k) + k);
-  const g = 1 - Math.min(1, m * (1 - k) + k);
-  const b = 1 - Math.min(1, y * (1 - k) + k);
+  var c = cmyk[0] / 100;
+  var m = cmyk[1] / 100;
+  var y = cmyk[2] / 100;
+  var k = cmyk[3] / 100;
+  var r;
+  var g;
+  var b;
+  r = 1 - Math.min(1, c * (1 - k) + k);
+  g = 1 - Math.min(1, m * (1 - k) + k);
+  b = 1 - Math.min(1, y * (1 - k) + k);
   return [r * 255, g * 255, b * 255];
 };
 convert$2.xyz.rgb = function(xyz) {
-  const x = xyz[0] / 100;
-  const y = xyz[1] / 100;
-  const z = xyz[2] / 100;
-  let r;
-  let g;
-  let b;
+  var x = xyz[0] / 100;
+  var y = xyz[1] / 100;
+  var z = xyz[2] / 100;
+  var r;
+  var g;
+  var b;
   r = x * 3.2406 + y * -1.5372 + z * -0.4986;
   g = x * -0.9689 + y * 1.8758 + z * 0.0415;
   b = x * 0.0557 + y * -0.204 + z * 1.057;
-  r = r > 31308e-7 ? 1.055 * __pow(r, 1 / 2.4) - 0.055 : r * 12.92;
-  g = g > 31308e-7 ? 1.055 * __pow(g, 1 / 2.4) - 0.055 : g * 12.92;
-  b = b > 31308e-7 ? 1.055 * __pow(b, 1 / 2.4) - 0.055 : b * 12.92;
+  r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92;
+  g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92;
+  b = b > 31308e-7 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : b * 12.92;
   r = Math.min(Math.max(0, r), 1);
   g = Math.min(Math.max(0, g), 1);
   b = Math.min(Math.max(0, b), 1);
   return [r * 255, g * 255, b * 255];
 };
 convert$2.xyz.lab = function(xyz) {
-  let x = xyz[0];
-  let y = xyz[1];
-  let z = xyz[2];
+  var x = xyz[0];
+  var y = xyz[1];
+  var z = xyz[2];
+  var l;
+  var a;
+  var b;
   x /= 95.047;
   y /= 100;
   z /= 108.883;
-  x = x > 8856e-6 ? __pow(x, 1 / 3) : 7.787 * x + 16 / 116;
-  y = y > 8856e-6 ? __pow(y, 1 / 3) : 7.787 * y + 16 / 116;
-  z = z > 8856e-6 ? __pow(z, 1 / 3) : 7.787 * z + 16 / 116;
-  const l = 116 * y - 16;
-  const a = 500 * (x - y);
-  const b = 200 * (y - z);
+  x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+  y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+  z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+  l = 116 * y - 16;
+  a = 500 * (x - y);
+  b = 200 * (y - z);
   return [l, a, b];
 };
 convert$2.lab.xyz = function(lab) {
-  const l = lab[0];
-  const a = lab[1];
-  const b = lab[2];
-  let x;
-  let y;
-  let z;
+  var l = lab[0];
+  var a = lab[1];
+  var b = lab[2];
+  var x;
+  var y;
+  var z;
   y = (l + 16) / 116;
   x = a / 500 + y;
   z = y - b / 200;
-  const y2 = __pow(y, 3);
-  const x2 = __pow(x, 3);
-  const z2 = __pow(z, 3);
+  var y2 = Math.pow(y, 3);
+  var x2 = Math.pow(x, 3);
+  var z2 = Math.pow(z, 3);
   y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
   x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
   z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
@@ -27853,35 +26666,42 @@ convert$2.lab.xyz = function(lab) {
   return [x, y, z];
 };
 convert$2.lab.lch = function(lab) {
-  const l = lab[0];
-  const a = lab[1];
-  const b = lab[2];
-  let h;
-  const hr = Math.atan2(b, a);
+  var l = lab[0];
+  var a = lab[1];
+  var b = lab[2];
+  var hr;
+  var h;
+  var c;
+  hr = Math.atan2(b, a);
   h = hr * 360 / 2 / Math.PI;
   if (h < 0) {
     h += 360;
   }
-  const c = Math.sqrt(a * a + b * b);
+  c = Math.sqrt(a * a + b * b);
   return [l, c, h];
 };
 convert$2.lch.lab = function(lch) {
-  const l = lch[0];
-  const c = lch[1];
-  const h = lch[2];
-  const hr = h / 360 * 2 * Math.PI;
-  const a = c * Math.cos(hr);
-  const b = c * Math.sin(hr);
+  var l = lch[0];
+  var c = lch[1];
+  var h = lch[2];
+  var a;
+  var b;
+  var hr;
+  hr = h / 360 * 2 * Math.PI;
+  a = c * Math.cos(hr);
+  b = c * Math.sin(hr);
   return [l, a, b];
 };
-convert$2.rgb.ansi16 = function(args, saturation = null) {
-  const [r, g, b] = args;
-  let value = saturation === null ? convert$2.rgb.hsv(args)[2] : saturation;
+convert$2.rgb.ansi16 = function(args) {
+  var r = args[0];
+  var g = args[1];
+  var b = args[2];
+  var value = 1 in arguments ? arguments[1] : convert$2.rgb.hsv(args)[2];
   value = Math.round(value / 50);
   if (value === 0) {
     return 30;
   }
-  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+  var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
   if (value === 2) {
     ansi += 60;
   }
@@ -27891,9 +26711,9 @@ convert$2.hsv.ansi16 = function(args) {
   return convert$2.rgb.ansi16(convert$2.hsv.rgb(args), args[2]);
 };
 convert$2.rgb.ansi256 = function(args) {
-  const r = args[0];
-  const g = args[1];
-  const b = args[2];
+  var r = args[0];
+  var g = args[1];
+  var b = args[2];
   if (r === g && g === b) {
     if (r < 8) {
       return 16;
@@ -27903,11 +26723,11 @@ convert$2.rgb.ansi256 = function(args) {
     }
     return Math.round((r - 8) / 247 * 24) + 232;
   }
-  const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+  var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
   return ansi;
 };
 convert$2.ansi16.rgb = function(args) {
-  let color2 = args % 10;
+  var color2 = args % 10;
   if (color2 === 0 || color2 === 7) {
     if (args > 50) {
       color2 += 3.5;
@@ -27915,55 +26735,55 @@ convert$2.ansi16.rgb = function(args) {
     color2 = color2 / 10.5 * 255;
     return [color2, color2, color2];
   }
-  const mult = (~~(args > 50) + 1) * 0.5;
-  const r = (color2 & 1) * mult * 255;
-  const g = (color2 >> 1 & 1) * mult * 255;
-  const b = (color2 >> 2 & 1) * mult * 255;
+  var mult = (~~(args > 50) + 1) * 0.5;
+  var r = (color2 & 1) * mult * 255;
+  var g = (color2 >> 1 & 1) * mult * 255;
+  var b = (color2 >> 2 & 1) * mult * 255;
   return [r, g, b];
 };
 convert$2.ansi256.rgb = function(args) {
   if (args >= 232) {
-    const c = (args - 232) * 10 + 8;
+    var c = (args - 232) * 10 + 8;
     return [c, c, c];
   }
   args -= 16;
-  let rem;
-  const r = Math.floor(args / 36) / 5 * 255;
-  const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
-  const b = rem % 6 / 5 * 255;
+  var rem;
+  var r = Math.floor(args / 36) / 5 * 255;
+  var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+  var b = rem % 6 / 5 * 255;
   return [r, g, b];
 };
 convert$2.rgb.hex = function(args) {
-  const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
-  const string = integer.toString(16).toUpperCase();
+  var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+  var string = integer.toString(16).toUpperCase();
   return "000000".substring(string.length) + string;
 };
 convert$2.hex.rgb = function(args) {
-  const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+  var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
   if (!match) {
     return [0, 0, 0];
   }
-  let colorString2 = match[0];
+  var colorString2 = match[0];
   if (match[0].length === 3) {
-    colorString2 = colorString2.split("").map((char) => {
+    colorString2 = colorString2.split("").map(function(char) {
       return char + char;
     }).join("");
   }
-  const integer = parseInt(colorString2, 16);
-  const r = integer >> 16 & 255;
-  const g = integer >> 8 & 255;
-  const b = integer & 255;
+  var integer = parseInt(colorString2, 16);
+  var r = integer >> 16 & 255;
+  var g = integer >> 8 & 255;
+  var b = integer & 255;
   return [r, g, b];
 };
 convert$2.rgb.hcg = function(rgb) {
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const max2 = Math.max(Math.max(r, g), b);
-  const min = Math.min(Math.min(r, g), b);
-  const chroma = max2 - min;
-  let grayscale;
-  let hue;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var max2 = Math.max(Math.max(r, g), b);
+  var min = Math.min(Math.min(r, g), b);
+  var chroma = max2 - min;
+  var grayscale;
+  var hue;
   if (chroma < 1) {
     grayscale = min / (1 - chroma);
   } else {
@@ -27976,44 +26796,49 @@ convert$2.rgb.hcg = function(rgb) {
   } else if (max2 === g) {
     hue = 2 + (b - r) / chroma;
   } else {
-    hue = 4 + (r - g) / chroma;
+    hue = 4 + (r - g) / chroma + 4;
   }
   hue /= 6;
   hue %= 1;
   return [hue * 360, chroma * 100, grayscale * 100];
 };
 convert$2.hsl.hcg = function(hsl) {
-  const s = hsl[1] / 100;
-  const l = hsl[2] / 100;
-  const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
-  let f = 0;
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var c = 1;
+  var f = 0;
+  if (l < 0.5) {
+    c = 2 * s * l;
+  } else {
+    c = 2 * s * (1 - l);
+  }
   if (c < 1) {
     f = (l - 0.5 * c) / (1 - c);
   }
   return [hsl[0], c * 100, f * 100];
 };
 convert$2.hsv.hcg = function(hsv) {
-  const s = hsv[1] / 100;
-  const v = hsv[2] / 100;
-  const c = s * v;
-  let f = 0;
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var c = s * v;
+  var f = 0;
   if (c < 1) {
     f = (v - c) / (1 - c);
   }
   return [hsv[0], c * 100, f * 100];
 };
 convert$2.hcg.rgb = function(hcg) {
-  const h = hcg[0] / 360;
-  const c = hcg[1] / 100;
-  const g = hcg[2] / 100;
+  var h = hcg[0] / 360;
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
   if (c === 0) {
     return [g * 255, g * 255, g * 255];
   }
-  const pure = [0, 0, 0];
-  const hi = h % 1 * 6;
-  const v = hi % 1;
-  const w = 1 - v;
-  let mg = 0;
+  var pure = [0, 0, 0];
+  var hi = h % 1 * 6;
+  var v = hi % 1;
+  var w = 1 - v;
+  var mg = 0;
   switch (Math.floor(hi)) {
     case 0:
       pure[0] = 1;
@@ -28053,20 +26878,20 @@ convert$2.hcg.rgb = function(hcg) {
   ];
 };
 convert$2.hcg.hsv = function(hcg) {
-  const c = hcg[1] / 100;
-  const g = hcg[2] / 100;
-  const v = c + g * (1 - c);
-  let f = 0;
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var v = c + g * (1 - c);
+  var f = 0;
   if (v > 0) {
     f = c / v;
   }
   return [hcg[0], f * 100, v * 100];
 };
 convert$2.hcg.hsl = function(hcg) {
-  const c = hcg[1] / 100;
-  const g = hcg[2] / 100;
-  const l = g * (1 - c) + 0.5 * c;
-  let s = 0;
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var l = g * (1 - c) + 0.5 * c;
+  var s = 0;
   if (l > 0 && l < 0.5) {
     s = c / (2 * l);
   } else if (l >= 0.5 && l < 1) {
@@ -28075,17 +26900,17 @@ convert$2.hcg.hsl = function(hcg) {
   return [hcg[0], s * 100, l * 100];
 };
 convert$2.hcg.hwb = function(hcg) {
-  const c = hcg[1] / 100;
-  const g = hcg[2] / 100;
-  const v = c + g * (1 - c);
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var v = c + g * (1 - c);
   return [hcg[0], (v - c) * 100, (1 - v) * 100];
 };
 convert$2.hwb.hcg = function(hwb) {
-  const w = hwb[1] / 100;
-  const b = hwb[2] / 100;
-  const v = 1 - b;
-  const c = v - w;
-  let g = 0;
+  var w = hwb[1] / 100;
+  var b = hwb[2] / 100;
+  var v = 1 - b;
+  var c = v - w;
+  var g = 0;
   if (c < 1) {
     g = (v - c) / (1 - c);
   }
@@ -28100,10 +26925,9 @@ convert$2.rgb.apple = function(rgb) {
 convert$2.gray.rgb = function(args) {
   return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
 };
-convert$2.gray.hsl = function(args) {
+convert$2.gray.hsl = convert$2.gray.hsv = function(args) {
   return [0, 0, args[0]];
 };
-convert$2.gray.hsv = convert$2.gray.hsl;
 convert$2.gray.hwb = function(gray) {
   return [0, 100, gray[0]];
 };
@@ -28114,20 +26938,21 @@ convert$2.gray.lab = function(gray) {
   return [gray[0], 0, 0];
 };
 convert$2.gray.hex = function(gray) {
-  const val2 = Math.round(gray[0] / 100 * 255) & 255;
-  const integer = (val2 << 16) + (val2 << 8) + val2;
-  const string = integer.toString(16).toUpperCase();
+  var val2 = Math.round(gray[0] / 100 * 255) & 255;
+  var integer = (val2 << 16) + (val2 << 8) + val2;
+  var string = integer.toString(16).toUpperCase();
   return "000000".substring(string.length) + string;
 };
 convert$2.rgb.gray = function(rgb) {
-  const val2 = (rgb[0] + rgb[1] + rgb[2]) / 3;
+  var val2 = (rgb[0] + rgb[1] + rgb[2]) / 3;
   return [val2 / 255 * 100];
 };
-const conversions$1 = conversions$2;
+var conversionsExports = conversions$2.exports;
+var conversions$1 = conversionsExports;
 function buildGraph() {
-  const graph = {};
-  const models2 = Object.keys(conversions$1);
-  for (let len = models2.length, i = 0; i < len; i++) {
+  var graph = {};
+  var models2 = Object.keys(conversions$1);
+  for (var len = models2.length, i = 0; i < len; i++) {
     graph[models2[i]] = {
       // http://jsperf.com/1-vs-infinity
       // micro-opt, but this is simple.
@@ -28139,15 +26964,15 @@ function buildGraph() {
 }
 __name(buildGraph, "buildGraph");
 function deriveBFS(fromModel) {
-  const graph = buildGraph();
-  const queue = [fromModel];
+  var graph = buildGraph();
+  var queue = [fromModel];
   graph[fromModel].distance = 0;
   while (queue.length) {
-    const current = queue.pop();
-    const adjacents = Object.keys(conversions$1[current]);
-    for (let len = adjacents.length, i = 0; i < len; i++) {
-      const adjacent = adjacents[i];
-      const node = graph[adjacent];
+    var current = queue.pop();
+    var adjacents = Object.keys(conversions$1[current]);
+    for (var len = adjacents.length, i = 0; i < len; i++) {
+      var adjacent = adjacents[i];
+      var node = graph[adjacent];
       if (node.distance === -1) {
         node.distance = graph[current].distance + 1;
         node.parent = current;
@@ -28165,9 +26990,9 @@ function link(from, to) {
 }
 __name(link, "link");
 function wrapConversion(toModel, graph) {
-  const path = [graph[toModel].parent, toModel];
-  let fn = conversions$1[graph[toModel].parent][toModel];
-  let cur = graph[toModel].parent;
+  var path = [graph[toModel].parent, toModel];
+  var fn = conversions$1[graph[toModel].parent][toModel];
+  var cur = graph[toModel].parent;
   while (graph[cur].parent) {
     path.unshift(graph[cur].parent);
     fn = link(conversions$1[graph[cur].parent][cur], fn);
@@ -28178,12 +27003,12 @@ function wrapConversion(toModel, graph) {
 }
 __name(wrapConversion, "wrapConversion");
 var route$1 = /* @__PURE__ */ __name(function(fromModel) {
-  const graph = deriveBFS(fromModel);
-  const conversion = {};
-  const models2 = Object.keys(graph);
-  for (let len = models2.length, i = 0; i < len; i++) {
-    const toModel = models2[i];
-    const node = graph[toModel];
+  var graph = deriveBFS(fromModel);
+  var conversion = {};
+  var models2 = Object.keys(graph);
+  for (var len = models2.length, i = 0; i < len; i++) {
+    var toModel = models2[i];
+    var node = graph[toModel];
     if (node.parent === null) {
       continue;
     }
@@ -28191,18 +27016,17 @@ var route$1 = /* @__PURE__ */ __name(function(fromModel) {
   }
   return conversion;
 }, "route$1");
-const conversions = conversions$2;
-const route = route$1;
-const convert$1 = {};
-const models = Object.keys(conversions);
+var conversions = conversionsExports;
+var route = route$1;
+var convert$1 = {};
+var models = Object.keys(conversions);
 function wrapRaw(fn) {
-  const wrappedFn = /* @__PURE__ */ __name(function(...args) {
-    const arg0 = args[0];
-    if (arg0 === void 0 || arg0 === null) {
-      return arg0;
+  var wrappedFn = /* @__PURE__ */ __name(function(args) {
+    if (args === void 0 || args === null) {
+      return args;
     }
-    if (arg0.length > 1) {
-      args = arg0;
+    if (arguments.length > 1) {
+      args = Array.prototype.slice.call(arguments);
     }
     return fn(args);
   }, "wrappedFn");
@@ -28213,17 +27037,16 @@ function wrapRaw(fn) {
 }
 __name(wrapRaw, "wrapRaw");
 function wrapRounded(fn) {
-  const wrappedFn = /* @__PURE__ */ __name(function(...args) {
-    const arg0 = args[0];
-    if (arg0 === void 0 || arg0 === null) {
-      return arg0;
+  var wrappedFn = /* @__PURE__ */ __name(function(args) {
+    if (args === void 0 || args === null) {
+      return args;
     }
-    if (arg0.length > 1) {
-      args = arg0;
+    if (arguments.length > 1) {
+      args = Array.prototype.slice.call(arguments);
     }
-    const result = fn(args);
+    var result = fn(args);
     if (typeof result === "object") {
-      for (let len = result.length, i = 0; i < len; i++) {
+      for (var len = result.length, i = 0; i < len; i++) {
         result[i] = Math.round(result[i]);
       }
     }
@@ -28235,37 +27058,38 @@ function wrapRounded(fn) {
   return wrappedFn;
 }
 __name(wrapRounded, "wrapRounded");
-models.forEach((fromModel) => {
+models.forEach(function(fromModel) {
   convert$1[fromModel] = {};
   Object.defineProperty(convert$1[fromModel], "channels", { value: conversions[fromModel].channels });
   Object.defineProperty(convert$1[fromModel], "labels", { value: conversions[fromModel].labels });
-  const routes = route(fromModel);
-  const routeModels = Object.keys(routes);
-  routeModels.forEach((toModel) => {
-    const fn = routes[toModel];
+  var routes = route(fromModel);
+  var routeModels = Object.keys(routes);
+  routeModels.forEach(function(toModel) {
+    var fn = routes[toModel];
     convert$1[fromModel][toModel] = wrapRounded(fn);
     convert$1[fromModel][toModel].raw = wrapRaw(fn);
   });
 });
 var colorConvert = convert$1;
-const colorString = colorStringExports;
-const convert = colorConvert;
-const skippedModels = [
-  // To be honest, I don't really feel like keyword belongs in color convert, but eh.
+var colorString = colorStringExports;
+var convert = colorConvert;
+var _slice = [].slice;
+var skippedModels = [
+  // to be honest, I don't really feel like keyword belongs in color convert, but eh.
   "keyword",
-  // Gray conflicts with some method names, and has its own method defined.
+  // gray conflicts with some method names, and has its own method defined.
   "gray",
-  // Shouldn't really be in color-convert either...
+  // shouldn't really be in color-convert either...
   "hex"
 ];
-const hashedModelKeys = {};
-for (const model of Object.keys(convert)) {
-  hashedModelKeys[[...convert[model].labels].sort().join("")] = model;
-}
-const limiters = {};
-function Color(object, model) {
+var hashedModelKeys = {};
+Object.keys(convert).forEach(function(model) {
+  hashedModelKeys[_slice.call(convert[model].labels).sort().join("")] = model;
+});
+var limiters = {};
+function Color(obj, model) {
   if (!(this instanceof Color)) {
-    return new Color(object, model);
+    return new Color(obj, model);
   }
   if (model && model in skippedModels) {
     model = null;
@@ -28273,62 +27097,63 @@ function Color(object, model) {
   if (model && !(model in convert)) {
     throw new Error("Unknown model: " + model);
   }
-  let i;
-  let channels;
-  if (object == null) {
+  var i;
+  var channels;
+  if (obj == null) {
     this.model = "rgb";
     this.color = [0, 0, 0];
     this.valpha = 1;
-  } else if (object instanceof Color) {
-    this.model = object.model;
-    this.color = [...object.color];
-    this.valpha = object.valpha;
-  } else if (typeof object === "string") {
-    const result = colorString.get(object);
+  } else if (obj instanceof Color) {
+    this.model = obj.model;
+    this.color = obj.color.slice();
+    this.valpha = obj.valpha;
+  } else if (typeof obj === "string") {
+    var result = colorString.get(obj);
     if (result === null) {
-      throw new Error("Unable to parse color from string: " + object);
+      throw new Error("Unable to parse color from string: " + obj);
     }
     this.model = result.model;
     channels = convert[this.model].channels;
     this.color = result.value.slice(0, channels);
     this.valpha = typeof result.value[channels] === "number" ? result.value[channels] : 1;
-  } else if (object.length > 0) {
+  } else if (obj.length) {
     this.model = model || "rgb";
     channels = convert[this.model].channels;
-    const newArray = Array.prototype.slice.call(object, 0, channels);
-    this.color = zeroArray(newArray, channels);
-    this.valpha = typeof object[channels] === "number" ? object[channels] : 1;
-  } else if (typeof object === "number") {
+    var newArr = _slice.call(obj, 0, channels);
+    this.color = zeroArray(newArr, channels);
+    this.valpha = typeof obj[channels] === "number" ? obj[channels] : 1;
+  } else if (typeof obj === "number") {
+    obj &= 16777215;
     this.model = "rgb";
     this.color = [
-      object >> 16 & 255,
-      object >> 8 & 255,
-      object & 255
+      obj >> 16 & 255,
+      obj >> 8 & 255,
+      obj & 255
     ];
     this.valpha = 1;
   } else {
     this.valpha = 1;
-    const keys2 = Object.keys(object);
-    if ("alpha" in object) {
+    var keys2 = Object.keys(obj);
+    if ("alpha" in obj) {
       keys2.splice(keys2.indexOf("alpha"), 1);
-      this.valpha = typeof object.alpha === "number" ? object.alpha : 0;
+      this.valpha = typeof obj.alpha === "number" ? obj.alpha : 0;
     }
-    const hashedKeys = keys2.sort().join("");
+    var hashedKeys = keys2.sort().join("");
     if (!(hashedKeys in hashedModelKeys)) {
-      throw new Error("Unable to parse color from object: " + JSON.stringify(object));
+      throw new Error("Unable to parse color from object: " + JSON.stringify(obj));
     }
     this.model = hashedModelKeys[hashedKeys];
-    const { labels } = convert[this.model];
-    const color2 = [];
+    var labels = convert[this.model].labels;
+    var color2 = [];
     for (i = 0; i < labels.length; i++) {
-      color2.push(object[labels[i]]);
+      color2.push(obj[labels[i]]);
     }
     this.color = zeroArray(color2);
   }
   if (limiters[this.model]) {
     channels = convert[this.model].channels;
     for (i = 0; i < channels; i++) {
-      const limit = limiters[this.model][i];
+      var limit = limiters[this.model][i];
       if (limit) {
         this.color[i] = limit(this.color[i]);
       }
@@ -28341,31 +27166,31 @@ function Color(object, model) {
 }
 __name(Color, "Color");
 Color.prototype = {
-  toString() {
+  toString: function() {
     return this.string();
   },
-  toJSON() {
+  toJSON: function() {
     return this[this.model]();
   },
-  string(places) {
-    let self2 = this.model in colorString.to ? this : this.rgb();
+  string: function(places) {
+    var self2 = this.model in colorString.to ? this : this.rgb();
     self2 = self2.round(typeof places === "number" ? places : 1);
-    const args = self2.valpha === 1 ? self2.color : [...self2.color, this.valpha];
+    var args = self2.valpha === 1 ? self2.color : self2.color.concat(this.valpha);
     return colorString.to[self2.model](args);
   },
-  percentString(places) {
-    const self2 = this.rgb().round(typeof places === "number" ? places : 1);
-    const args = self2.valpha === 1 ? self2.color : [...self2.color, this.valpha];
+  percentString: function(places) {
+    var self2 = this.rgb().round(typeof places === "number" ? places : 1);
+    var args = self2.valpha === 1 ? self2.color : self2.color.concat(this.valpha);
     return colorString.to.rgb.percent(args);
   },
-  array() {
-    return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];
+  array: function() {
+    return this.valpha === 1 ? this.color.slice() : this.color.concat(this.valpha);
   },
-  object() {
-    const result = {};
-    const { channels } = convert[this.model];
-    const { labels } = convert[this.model];
-    for (let i = 0; i < channels; i++) {
+  object: function() {
+    var result = {};
+    var channels = convert[this.model].channels;
+    var labels = convert[this.model].labels;
+    for (var i = 0; i < channels; i++) {
       result[labels[i]] = this.color[i];
     }
     if (this.valpha !== 1) {
@@ -28373,8 +27198,8 @@ Color.prototype = {
     }
     return result;
   },
-  unitArray() {
-    const rgb = this.rgb().color;
+  unitArray: function() {
+    var rgb = this.rgb().color;
     rgb[0] /= 255;
     rgb[1] /= 255;
     rgb[2] /= 255;
@@ -28383,8 +27208,8 @@ Color.prototype = {
     }
     return rgb;
   },
-  unitObject() {
-    const rgb = this.rgb().object();
+  unitObject: function() {
+    var rgb = this.rgb().object();
     rgb.r /= 255;
     rgb.g /= 255;
     rgb.b /= 255;
@@ -28393,21 +27218,24 @@ Color.prototype = {
     }
     return rgb;
   },
-  round(places) {
+  round: function(places) {
     places = Math.max(places || 0, 0);
-    return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);
+    return new Color(this.color.map(roundToPlace(places)).concat(this.valpha), this.model);
   },
-  alpha(value) {
-    if (value !== void 0) {
-      return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model);
+  alpha: function(val2) {
+    if (arguments.length) {
+      return new Color(this.color.concat(Math.max(0, Math.min(1, val2))), this.model);
     }
     return this.valpha;
   },
-  // Rgb
+  // rgb
   red: getset("rgb", 0, maxfn(255)),
   green: getset("rgb", 1, maxfn(255)),
   blue: getset("rgb", 2, maxfn(255)),
-  hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360),
+  hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, function(val2) {
+    return (val2 % 360 + 360) % 360;
+  }),
+  // eslint-disable-line brace-style
   saturationl: getset("hsl", 1, maxfn(100)),
   lightness: getset("hsl", 2, maxfn(100)),
   saturationv: getset("hsv", 1, maxfn(100)),
@@ -28420,138 +27248,127 @@ Color.prototype = {
   magenta: getset("cmyk", 1, maxfn(100)),
   yellow: getset("cmyk", 2, maxfn(100)),
   black: getset("cmyk", 3, maxfn(100)),
-  x: getset("xyz", 0, maxfn(95.047)),
+  x: getset("xyz", 0, maxfn(100)),
   y: getset("xyz", 1, maxfn(100)),
-  z: getset("xyz", 2, maxfn(108.833)),
+  z: getset("xyz", 2, maxfn(100)),
   l: getset("lab", 0, maxfn(100)),
   a: getset("lab", 1),
   b: getset("lab", 2),
-  keyword(value) {
-    if (value !== void 0) {
-      return new Color(value);
+  keyword: function(val2) {
+    if (arguments.length) {
+      return new Color(val2);
     }
     return convert[this.model].keyword(this.color);
   },
-  hex(value) {
-    if (value !== void 0) {
-      return new Color(value);
+  hex: function(val2) {
+    if (arguments.length) {
+      return new Color(val2);
     }
     return colorString.to.hex(this.rgb().round().color);
   },
-  hexa(value) {
-    if (value !== void 0) {
-      return new Color(value);
-    }
-    const rgbArray = this.rgb().round().color;
-    let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase();
-    if (alphaHex.length === 1) {
-      alphaHex = "0" + alphaHex;
-    }
-    return colorString.to.hex(rgbArray) + alphaHex;
-  },
-  rgbNumber() {
-    const rgb = this.rgb().color;
+  rgbNumber: function() {
+    var rgb = this.rgb().color;
     return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255;
   },
-  luminosity() {
-    const rgb = this.rgb().color;
-    const lum = [];
-    for (const [i, element] of rgb.entries()) {
-      const chan = element / 255;
-      lum[i] = chan <= 0.04045 ? chan / 12.92 : __pow((chan + 0.055) / 1.055, 2.4);
+  luminosity: function() {
+    var rgb = this.rgb().color;
+    var lum = [];
+    for (var i = 0; i < rgb.length; i++) {
+      var chan = rgb[i] / 255;
+      lum[i] = chan <= 0.03928 ? chan / 12.92 : Math.pow((chan + 0.055) / 1.055, 2.4);
     }
     return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
   },
-  contrast(color2) {
-    const lum1 = this.luminosity();
-    const lum2 = color2.luminosity();
+  contrast: function(color2) {
+    var lum1 = this.luminosity();
+    var lum2 = color2.luminosity();
     if (lum1 > lum2) {
       return (lum1 + 0.05) / (lum2 + 0.05);
     }
     return (lum2 + 0.05) / (lum1 + 0.05);
   },
-  level(color2) {
-    const contrastRatio = this.contrast(color2);
-    if (contrastRatio >= 7) {
+  level: function(color2) {
+    var contrastRatio = this.contrast(color2);
+    if (contrastRatio >= 7.1) {
       return "AAA";
     }
     return contrastRatio >= 4.5 ? "AA" : "";
   },
-  isDark() {
-    const rgb = this.rgb().color;
-    const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4;
+  isDark: function() {
+    var rgb = this.rgb().color;
+    var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1e3;
     return yiq < 128;
   },
-  isLight() {
+  isLight: function() {
     return !this.isDark();
   },
-  negate() {
-    const rgb = this.rgb();
-    for (let i = 0; i < 3; i++) {
+  negate: function() {
+    var rgb = this.rgb();
+    for (var i = 0; i < 3; i++) {
       rgb.color[i] = 255 - rgb.color[i];
     }
     return rgb;
   },
-  lighten(ratio) {
-    const hsl = this.hsl();
+  lighten: function(ratio) {
+    var hsl = this.hsl();
     hsl.color[2] += hsl.color[2] * ratio;
     return hsl;
   },
-  darken(ratio) {
-    const hsl = this.hsl();
+  darken: function(ratio) {
+    var hsl = this.hsl();
     hsl.color[2] -= hsl.color[2] * ratio;
     return hsl;
   },
-  saturate(ratio) {
-    const hsl = this.hsl();
+  saturate: function(ratio) {
+    var hsl = this.hsl();
     hsl.color[1] += hsl.color[1] * ratio;
     return hsl;
   },
-  desaturate(ratio) {
-    const hsl = this.hsl();
+  desaturate: function(ratio) {
+    var hsl = this.hsl();
     hsl.color[1] -= hsl.color[1] * ratio;
     return hsl;
   },
-  whiten(ratio) {
-    const hwb = this.hwb();
+  whiten: function(ratio) {
+    var hwb = this.hwb();
     hwb.color[1] += hwb.color[1] * ratio;
     return hwb;
   },
-  blacken(ratio) {
-    const hwb = this.hwb();
+  blacken: function(ratio) {
+    var hwb = this.hwb();
     hwb.color[2] += hwb.color[2] * ratio;
     return hwb;
   },
-  grayscale() {
-    const rgb = this.rgb().color;
-    const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
-    return Color.rgb(value, value, value);
+  grayscale: function() {
+    var rgb = this.rgb().color;
+    var val2 = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
+    return Color.rgb(val2, val2, val2);
   },
-  fade(ratio) {
+  fade: function(ratio) {
     return this.alpha(this.valpha - this.valpha * ratio);
   },
-  opaquer(ratio) {
+  opaquer: function(ratio) {
     return this.alpha(this.valpha + this.valpha * ratio);
   },
-  rotate(degrees) {
-    const hsl = this.hsl();
-    let hue = hsl.color[0];
+  rotate: function(degrees) {
+    var hsl = this.hsl();
+    var hue = hsl.color[0];
     hue = (hue + degrees) % 360;
     hue = hue < 0 ? 360 + hue : hue;
     hsl.color[0] = hue;
     return hsl;
   },
-  mix(mixinColor, weight) {
+  mix: function(mixinColor, weight) {
     if (!mixinColor || !mixinColor.rgb) {
       throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
     }
-    const color1 = mixinColor.rgb();
-    const color2 = this.rgb();
-    const p = weight === void 0 ? 0.5 : weight;
-    const w = 2 * p - 1;
-    const a = color1.alpha() - color2.alpha();
-    const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2;
-    const w2 = 1 - w1;
+    var color1 = mixinColor.rgb();
+    var color2 = this.rgb();
+    var p = weight === void 0 ? 0.5 : weight;
+    var w = 2 * p - 1;
+    var a = color1.alpha() - color2.alpha();
+    var w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2;
+    var w2 = 1 - w1;
     return Color.rgb(
       w1 * color1.red() + w2 * color2.red(),
       w1 * color1.green() + w2 * color2.green(),
@@ -28560,52 +27377,52 @@ Color.prototype = {
     );
   }
 };
-for (const model of Object.keys(convert)) {
-  if (skippedModels.includes(model)) {
-    continue;
+Object.keys(convert).forEach(function(model) {
+  if (skippedModels.indexOf(model) !== -1) {
+    return;
   }
-  const { channels } = convert[model];
-  Color.prototype[model] = function(...args) {
+  var channels = convert[model].channels;
+  Color.prototype[model] = function() {
     if (this.model === model) {
       return new Color(this);
     }
-    if (args.length > 0) {
-      return new Color(args, model);
+    if (arguments.length) {
+      return new Color(arguments, model);
     }
-    return new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model);
+    var newAlpha = typeof arguments[channels] === "number" ? channels : this.valpha;
+    return new Color(assertArray(convert[this.model][model].raw(this.color)).concat(newAlpha), model);
   };
-  Color[model] = function(...args) {
-    let color2 = args[0];
+  Color[model] = function(color2) {
     if (typeof color2 === "number") {
-      color2 = zeroArray(args, channels);
+      color2 = zeroArray(_slice.call(arguments), channels);
     }
     return new Color(color2, model);
   };
-}
-function roundTo(number, places) {
-  return Number(number.toFixed(places));
+});
+function roundTo(num, places) {
+  return Number(num.toFixed(places));
 }
 __name(roundTo, "roundTo");
 function roundToPlace(places) {
-  return function(number) {
-    return roundTo(number, places);
+  return function(num) {
+    return roundTo(num, places);
   };
 }
 __name(roundToPlace, "roundToPlace");
 function getset(model, channel, modifier) {
   model = Array.isArray(model) ? model : [model];
-  for (const m of model) {
+  model.forEach(function(m) {
     (limiters[m] || (limiters[m] = []))[channel] = modifier;
-  }
+  });
   model = model[0];
-  return function(value) {
-    let result;
-    if (value !== void 0) {
+  return function(val2) {
+    var result;
+    if (arguments.length) {
       if (modifier) {
-        value = modifier(value);
+        val2 = modifier(val2);
       }
       result = this[model]();
-      result.color[channel] = value;
+      result.color[channel] = val2;
       return result;
     }
     result = this[model]().color[channel];
@@ -28622,17 +27439,17 @@ function maxfn(max2) {
   };
 }
 __name(maxfn, "maxfn");
-function assertArray(value) {
-  return Array.isArray(value) ? value : [value];
+function assertArray(val2) {
+  return Array.isArray(val2) ? val2 : [val2];
 }
 __name(assertArray, "assertArray");
-function zeroArray(array, length) {
-  for (let i = 0; i < length; i++) {
-    if (typeof array[i] !== "number") {
-      array[i] = 0;
+function zeroArray(arr, length) {
+  for (var i = 0; i < length; i++) {
+    if (typeof arr[i] !== "number") {
+      arr[i] = 0;
     }
   }
-  return array;
+  return arr;
 }
 __name(zeroArray, "zeroArray");
 var color = Color;