ueberdb2 4.1.32 → 4.1.33

package/dist/index.js

@@ -31305,7 +31305,7 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       return 1;
     return 0;
   };
-  Buffer2.isEncoding = function isEncoding(encoding2) {
+  Buffer2.isEncoding = function isEncoding2(encoding2) {
     switch (String(encoding2).toLowerCase()) {
       case "hex":
       case "utf8":
@@ -50112,325 +50112,312 @@ function requireEncoding() {
 }
 var string_decoder = {};
 var safeBuffer$1 = { exports: {} };
-var hasRequiredSafeBuffer$1;
-function requireSafeBuffer$1() {
-  if (hasRequiredSafeBuffer$1)
-    return safeBuffer$1.exports;
-  hasRequiredSafeBuffer$1 = 1;
-  (function(module2, exports2) {
-    var buffer2 = buffer$3;
-    var Buffer2 = buffer2.Buffer;
-    function copyProps(src2, dst) {
-      for (var key2 in src2) {
-        dst[key2] = src2[key2];
-      }
+(function(module2, exports2) {
+  var buffer2 = buffer$3;
+  var Buffer2 = buffer2.Buffer;
+  function copyProps(src2, dst) {
+    for (var key2 in src2) {
+      dst[key2] = src2[key2];
     }
-    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
-      module2.exports = buffer2;
-    } else {
-      copyProps(buffer2, exports2);
-      exports2.Buffer = SafeBuffer;
+  }
+  if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+    module2.exports = buffer2;
+  } else {
+    copyProps(buffer2, exports2);
+    exports2.Buffer = SafeBuffer;
+  }
+  function SafeBuffer(arg, encodingOrOffset, length) {
+    return Buffer2(arg, encodingOrOffset, length);
+  }
+  copyProps(Buffer2, SafeBuffer);
+  SafeBuffer.from = function(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      throw new TypeError("Argument must not be a number");
     }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer2(arg, encodingOrOffset, length);
+    return Buffer2(arg, encodingOrOffset, length);
+  };
+  SafeBuffer.alloc = function(size, fill, encoding2) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
     }
-    copyProps(Buffer2, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
-        throw new TypeError("Argument must not be a number");
-      }
-      return Buffer2(arg, encodingOrOffset, length);
-    };
-    SafeBuffer.alloc = function(size, fill, encoding2) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      var buf = Buffer2(size);
-      if (fill !== void 0) {
-        if (typeof encoding2 === "string") {
-          buf.fill(fill, encoding2);
-        } else {
-          buf.fill(fill);
-        }
+    var buf = Buffer2(size);
+    if (fill !== void 0) {
+      if (typeof encoding2 === "string") {
+        buf.fill(fill, encoding2);
       } else {
-        buf.fill(0);
+        buf.fill(fill);
       }
-      return buf;
-    };
-    SafeBuffer.allocUnsafe = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return Buffer2(size);
-    };
-    SafeBuffer.allocUnsafeSlow = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return buffer2.SlowBuffer(size);
-    };
-  })(safeBuffer$1, safeBuffer$1.exports);
-  return safeBuffer$1.exports;
-}
-var hasRequiredString_decoder;
-function requireString_decoder() {
-  if (hasRequiredString_decoder)
-    return string_decoder;
-  hasRequiredString_decoder = 1;
-  var Buffer2 = requireSafeBuffer$1().Buffer;
-  var isEncoding = Buffer2.isEncoding || function(encoding2) {
-    encoding2 = "" + encoding2;
-    switch (encoding2 && encoding2.toLowerCase()) {
-      case "hex":
+    } else {
+      buf.fill(0);
+    }
+    return buf;
+  };
+  SafeBuffer.allocUnsafe = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return Buffer2(size);
+  };
+  SafeBuffer.allocUnsafeSlow = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return buffer2.SlowBuffer(size);
+  };
+})(safeBuffer$1, safeBuffer$1.exports);
+var safeBufferExports = safeBuffer$1.exports;
+var Buffer$3 = safeBufferExports.Buffer;
+var isEncoding = Buffer$3.isEncoding || function(encoding2) {
+  encoding2 = "" + encoding2;
+  switch (encoding2 && encoding2.toLowerCase()) {
+    case "hex":
+    case "utf8":
+    case "utf-8":
+    case "ascii":
+    case "binary":
+    case "base64":
+    case "ucs2":
+    case "ucs-2":
+    case "utf16le":
+    case "utf-16le":
+    case "raw":
+      return true;
+    default:
+      return false;
+  }
+};
+function _normalizeEncoding(enc) {
+  if (!enc)
+    return "utf8";
+  var retried;
+  while (true) {
+    switch (enc) {
       case "utf8":
       case "utf-8":
-      case "ascii":
-      case "binary":
-      case "base64":
+        return "utf8";
       case "ucs2":
       case "ucs-2":
       case "utf16le":
       case "utf-16le":
-      case "raw":
-        return true;
-      default:
-        return false;
-    }
-  };
-  function _normalizeEncoding(enc) {
-    if (!enc)
-      return "utf8";
-    var retried;
-    while (true) {
-      switch (enc) {
-        case "utf8":
-        case "utf-8":
-          return "utf8";
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return "utf16le";
-        case "latin1":
-        case "binary":
-          return "latin1";
-        case "base64":
-        case "ascii":
-        case "hex":
-          return enc;
-        default:
-          if (retried)
-            return;
-          enc = ("" + enc).toLowerCase();
-          retried = true;
-      }
-    }
-  }
-  function normalizeEncoding(enc) {
-    var nenc = _normalizeEncoding(enc);
-    if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc)))
-      throw new Error("Unknown encoding: " + enc);
-    return nenc || enc;
-  }
-  string_decoder.StringDecoder = StringDecoder;
-  function StringDecoder(encoding2) {
-    this.encoding = normalizeEncoding(encoding2);
-    var nb;
-    switch (this.encoding) {
-      case "utf16le":
-        this.text = utf16Text;
-        this.end = utf16End;
-        nb = 4;
-        break;
-      case "utf8":
-        this.fillLast = utf8FillLast;
-        nb = 4;
-        break;
+        return "utf16le";
+      case "latin1":
+      case "binary":
+        return "latin1";
       case "base64":
-        this.text = base64Text;
-        this.end = base64End;
-        nb = 3;
-        break;
+      case "ascii":
+      case "hex":
+        return enc;
       default:
-        this.write = simpleWrite;
-        this.end = simpleEnd;
-        return;
-    }
-    this.lastNeed = 0;
-    this.lastTotal = 0;
-    this.lastChar = Buffer2.allocUnsafe(nb);
+        if (retried)
+          return;
+        enc = ("" + enc).toLowerCase();
+        retried = true;
+    }
+  }
+}
+function normalizeEncoding(enc) {
+  var nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== "string" && (Buffer$3.isEncoding === isEncoding || !isEncoding(enc)))
+    throw new Error("Unknown encoding: " + enc);
+  return nenc || enc;
+}
+string_decoder.StringDecoder = StringDecoder;
+function StringDecoder(encoding2) {
+  this.encoding = normalizeEncoding(encoding2);
+  var nb;
+  switch (this.encoding) {
+    case "utf16le":
+      this.text = utf16Text;
+      this.end = utf16End;
+      nb = 4;
+      break;
+    case "utf8":
+      this.fillLast = utf8FillLast;
+      nb = 4;
+      break;
+    case "base64":
+      this.text = base64Text;
+      this.end = base64End;
+      nb = 3;
+      break;
+    default:
+      this.write = simpleWrite;
+      this.end = simpleEnd;
+      return;
   }
-  StringDecoder.prototype.write = function(buf) {
-    if (buf.length === 0)
+  this.lastNeed = 0;
+  this.lastTotal = 0;
+  this.lastChar = Buffer$3.allocUnsafe(nb);
+}
+StringDecoder.prototype.write = function(buf) {
+  if (buf.length === 0)
+    return "";
+  var r2;
+  var i2;
+  if (this.lastNeed) {
+    r2 = this.fillLast(buf);
+    if (r2 === void 0)
       return "";
-    var r2;
-    var i2;
-    if (this.lastNeed) {
-      r2 = this.fillLast(buf);
-      if (r2 === void 0)
-        return "";
-      i2 = this.lastNeed;
-      this.lastNeed = 0;
-    } else {
-      i2 = 0;
-    }
-    if (i2 < buf.length)
-      return r2 ? r2 + this.text(buf, i2) : this.text(buf, i2);
-    return r2 || "";
-  };
-  StringDecoder.prototype.end = utf8End;
-  StringDecoder.prototype.text = utf8Text;
-  StringDecoder.prototype.fillLast = function(buf) {
-    if (this.lastNeed <= buf.length) {
-      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
-      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-    }
-    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
-    this.lastNeed -= buf.length;
-  };
-  function utf8CheckByte(byte) {
-    if (byte <= 127)
-      return 0;
-    else if (byte >> 5 === 6)
-      return 2;
-    else if (byte >> 4 === 14)
-      return 3;
-    else if (byte >> 3 === 30)
-      return 4;
-    return byte >> 6 === 2 ? -1 : -2;
-  }
-  function utf8CheckIncomplete(self2, buf, i2) {
-    var j2 = buf.length - 1;
-    if (j2 < i2)
-      return 0;
-    var nb = utf8CheckByte(buf[j2]);
-    if (nb >= 0) {
-      if (nb > 0)
-        self2.lastNeed = nb - 1;
-      return nb;
-    }
-    if (--j2 < i2 || nb === -2)
-      return 0;
-    nb = utf8CheckByte(buf[j2]);
-    if (nb >= 0) {
-      if (nb > 0)
-        self2.lastNeed = nb - 2;
-      return nb;
-    }
-    if (--j2 < i2 || nb === -2)
-      return 0;
-    nb = utf8CheckByte(buf[j2]);
-    if (nb >= 0) {
-      if (nb > 0) {
-        if (nb === 2)
-          nb = 0;
-        else
-          self2.lastNeed = nb - 3;
-      }
-      return nb;
-    }
+    i2 = this.lastNeed;
+    this.lastNeed = 0;
+  } else {
+    i2 = 0;
+  }
+  if (i2 < buf.length)
+    return r2 ? r2 + this.text(buf, i2) : this.text(buf, i2);
+  return r2 || "";
+};
+StringDecoder.prototype.end = utf8End;
+StringDecoder.prototype.text = utf8Text;
+StringDecoder.prototype.fillLast = function(buf) {
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+  this.lastNeed -= buf.length;
+};
+function utf8CheckByte(byte) {
+  if (byte <= 127)
+    return 0;
+  else if (byte >> 5 === 6)
+    return 2;
+  else if (byte >> 4 === 14)
+    return 3;
+  else if (byte >> 3 === 30)
+    return 4;
+  return byte >> 6 === 2 ? -1 : -2;
+}
+function utf8CheckIncomplete(self2, buf, i2) {
+  var j2 = buf.length - 1;
+  if (j2 < i2)
     return 0;
+  var nb = utf8CheckByte(buf[j2]);
+  if (nb >= 0) {
+    if (nb > 0)
+      self2.lastNeed = nb - 1;
+    return nb;
   }
-  function utf8CheckExtraBytes(self2, buf, p2) {
-    if ((buf[0] & 192) !== 128) {
-      self2.lastNeed = 0;
-      return "�";
-    }
-    if (self2.lastNeed > 1 && buf.length > 1) {
-      if ((buf[1] & 192) !== 128) {
-        self2.lastNeed = 1;
-        return "�";
-      }
-      if (self2.lastNeed > 2 && buf.length > 2) {
-        if ((buf[2] & 192) !== 128) {
-          self2.lastNeed = 2;
-          return "�";
-        }
-      }
-    }
+  if (--j2 < i2 || nb === -2)
+    return 0;
+  nb = utf8CheckByte(buf[j2]);
+  if (nb >= 0) {
+    if (nb > 0)
+      self2.lastNeed = nb - 2;
+    return nb;
   }
-  function utf8FillLast(buf) {
-    var p2 = this.lastTotal - this.lastNeed;
-    var r2 = utf8CheckExtraBytes(this, buf);
-    if (r2 !== void 0)
-      return r2;
-    if (this.lastNeed <= buf.length) {
-      buf.copy(this.lastChar, p2, 0, this.lastNeed);
-      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  if (--j2 < i2 || nb === -2)
+    return 0;
+  nb = utf8CheckByte(buf[j2]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2)
+        nb = 0;
+      else
+        self2.lastNeed = nb - 3;
     }
-    buf.copy(this.lastChar, p2, 0, buf.length);
-    this.lastNeed -= buf.length;
-  }
-  function utf8Text(buf, i2) {
-    var total = utf8CheckIncomplete(this, buf, i2);
-    if (!this.lastNeed)
-      return buf.toString("utf8", i2);
-    this.lastTotal = total;
-    var end2 = buf.length - (total - this.lastNeed);
-    buf.copy(this.lastChar, 0, end2);
-    return buf.toString("utf8", i2, end2);
+    return nb;
   }
-  function utf8End(buf) {
-    var r2 = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed)
-      return r2 + "�";
-    return r2;
+  return 0;
+}
+function utf8CheckExtraBytes(self2, buf, p2) {
+  if ((buf[0] & 192) !== 128) {
+    self2.lastNeed = 0;
+    return "�";
   }
-  function utf16Text(buf, i2) {
-    if ((buf.length - i2) % 2 === 0) {
-      var r2 = buf.toString("utf16le", i2);
-      if (r2) {
-        var c2 = r2.charCodeAt(r2.length - 1);
-        if (c2 >= 55296 && c2 <= 56319) {
-          this.lastNeed = 2;
-          this.lastTotal = 4;
-          this.lastChar[0] = buf[buf.length - 2];
-          this.lastChar[1] = buf[buf.length - 1];
-          return r2.slice(0, -1);
-        }
+  if (self2.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 192) !== 128) {
+      self2.lastNeed = 1;
+      return "�";
+    }
+    if (self2.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 192) !== 128) {
+        self2.lastNeed = 2;
+        return "�";
       }
-      return r2;
     }
-    this.lastNeed = 1;
-    this.lastTotal = 2;
-    this.lastChar[0] = buf[buf.length - 1];
-    return buf.toString("utf16le", i2, buf.length - 1);
   }
-  function utf16End(buf) {
-    var r2 = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed) {
-      var end2 = this.lastTotal - this.lastNeed;
-      return r2 + this.lastChar.toString("utf16le", 0, end2);
-    }
+}
+function utf8FillLast(buf) {
+  var p2 = this.lastTotal - this.lastNeed;
+  var r2 = utf8CheckExtraBytes(this, buf);
+  if (r2 !== void 0)
     return r2;
-  }
-  function base64Text(buf, i2) {
-    var n2 = (buf.length - i2) % 3;
-    if (n2 === 0)
-      return buf.toString("base64", i2);
-    this.lastNeed = 3 - n2;
-    this.lastTotal = 3;
-    if (n2 === 1) {
-      this.lastChar[0] = buf[buf.length - 1];
-    } else {
-      this.lastChar[0] = buf[buf.length - 2];
-      this.lastChar[1] = buf[buf.length - 1];
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p2, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p2, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+function utf8Text(buf, i2) {
+  var total = utf8CheckIncomplete(this, buf, i2);
+  if (!this.lastNeed)
+    return buf.toString("utf8", i2);
+  this.lastTotal = total;
+  var end2 = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end2);
+  return buf.toString("utf8", i2, end2);
+}
+function utf8End(buf) {
+  var r2 = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed)
+    return r2 + "�";
+  return r2;
+}
+function utf16Text(buf, i2) {
+  if ((buf.length - i2) % 2 === 0) {
+    var r2 = buf.toString("utf16le", i2);
+    if (r2) {
+      var c2 = r2.charCodeAt(r2.length - 1);
+      if (c2 >= 55296 && c2 <= 56319) {
+        this.lastNeed = 2;
+        this.lastTotal = 4;
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+        return r2.slice(0, -1);
+      }
     }
-    return buf.toString("base64", i2, buf.length - n2);
-  }
-  function base64End(buf) {
-    var r2 = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed)
-      return r2 + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
     return r2;
   }
-  function simpleWrite(buf) {
-    return buf.toString(this.encoding);
+  this.lastNeed = 1;
+  this.lastTotal = 2;
+  this.lastChar[0] = buf[buf.length - 1];
+  return buf.toString("utf16le", i2, buf.length - 1);
+}
+function utf16End(buf) {
+  var r2 = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    var end2 = this.lastTotal - this.lastNeed;
+    return r2 + this.lastChar.toString("utf16le", 0, end2);
   }
-  function simpleEnd(buf) {
-    return buf && buf.length ? this.write(buf) : "";
+  return r2;
+}
+function base64Text(buf, i2) {
+  var n2 = (buf.length - i2) % 3;
+  if (n2 === 0)
+    return buf.toString("base64", i2);
+  this.lastNeed = 3 - n2;
+  this.lastTotal = 3;
+  if (n2 === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
   }
-  return string_decoder;
+  return buf.toString("base64", i2, buf.length - n2);
+}
+function base64End(buf) {
+  var r2 = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed)
+    return r2 + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+  return r2;
+}
+function simpleWrite(buf) {
+  return buf.toString(this.encoding);
+}
+function simpleEnd(buf) {
+  return buf && buf.length ? this.write(buf) : "";
 }
 var util$b;
 var hasRequiredUtil$5;
@@ -50450,7 +50437,7 @@ function requireUtil$5() {
   const { DOMException: DOMException2 } = requireConstants$6();
   const { serializeAMimeType, parseMIMEType } = requireDataURL();
   const { types: types2 } = require$$0$9;
-  const { StringDecoder } = requireString_decoder();
+  const { StringDecoder: StringDecoder2 } = string_decoder;
   const { btoa: btoa2 } = buffer$3;
   const staticPropertyDescriptors = {
     enumerable: true,
@@ -50541,7 +50528,7 @@ function requireUtil$5() {
           dataURL2 += serializeAMimeType(parsed);
         }
         dataURL2 += ";base64,";
-        const decoder2 = new StringDecoder("latin1");
+        const decoder2 = new StringDecoder2("latin1");
         for (const chunk of bytes) {
           dataURL2 += btoa2(decoder2.write(chunk));
         }
@@ -50570,7 +50557,7 @@ function requireUtil$5() {
       }
       case "BinaryString": {
         let binaryString = "";
-        const decoder2 = new StringDecoder("latin1");
+        const decoder2 = new StringDecoder2("latin1");
         for (const chunk of bytes) {
           binaryString += decoder2.write(chunk);
         }
@@ -182053,7 +182040,7 @@ function require_stream_readable$1() {
   var destroyImpl = destroy_1$1;
   var _require = state, getHighWaterMark2 = _require.getHighWaterMark;
   var _require$codes2 = errorsBrowser.codes, ERR_INVALID_ARG_TYPE = _require$codes2.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes2.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED2 = _require$codes2.ERR_METHOD_NOT_IMPLEMENTED, ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes2.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
-  var StringDecoder;
+  var StringDecoder2;
   var createReadableStreamAsyncIterator;
   var from;
   requireInherits_browser()(Readable2, Stream2);
@@ -182101,9 +182088,9 @@ function require_stream_readable$1() {
     this.decoder = null;
     this.encoding = null;
     if (options2.encoding) {
-      if (!StringDecoder)
-        StringDecoder = requireString_decoder().StringDecoder;
-      this.decoder = new StringDecoder(options2.encoding);
+      if (!StringDecoder2)
+        StringDecoder2 = string_decoder.StringDecoder;
+      this.decoder = new StringDecoder2(options2.encoding);
       this.encoding = options2.encoding;
     }
   }
@@ -182235,9 +182222,9 @@ function require_stream_readable$1() {
     return this._readableState.flowing === false;
   };
   Readable2.prototype.setEncoding = function(enc) {
-    if (!StringDecoder)
-      StringDecoder = requireString_decoder().StringDecoder;
-    var decoder2 = new StringDecoder(enc);
+    if (!StringDecoder2)
+      StringDecoder2 = string_decoder.StringDecoder;
+    var decoder2 = new StringDecoder2(enc);
     this._readableState.decoder = decoder2;
     this._readableState.encoding = this._readableState.decoder.encoding;
     var p2 = this._readableState.buffer.head;
@@ -195861,12 +195848,12 @@ function requireInternal() {
   }
   InternalCodec.prototype.encoder = InternalEncoder;
   InternalCodec.prototype.decoder = InternalDecoder;
-  var StringDecoder = requireString_decoder().StringDecoder;
-  if (!StringDecoder.prototype.end)
-    StringDecoder.prototype.end = function() {
+  var StringDecoder2 = string_decoder.StringDecoder;
+  if (!StringDecoder2.prototype.end)
+    StringDecoder2.prototype.end = function() {
     };
   function InternalDecoder(options2, codec) {
-    this.decoder = new StringDecoder(codec.enc);
+    this.decoder = new StringDecoder2(codec.enc);
   }
   InternalDecoder.prototype.write = function(buf) {
     if (!Buffer2.isBuffer(buf)) {
@@ -224435,7 +224422,7 @@ function require_stream_readable() {
   }
   var BufferList2 = requireBufferList();
   var destroyImpl = requireDestroy();
-  var StringDecoder;
+  var StringDecoder2;
   util2.inherits(Readable2, Stream2);
   var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
   function prependListener2(emitter, event, fn) {
@@ -224485,9 +224472,9 @@ function require_stream_readable() {
     this.decoder = null;
     this.encoding = null;
     if (options2.encoding) {
-      if (!StringDecoder)
-        StringDecoder = requireString_decoder().StringDecoder;
-      this.decoder = new StringDecoder(options2.encoding);
+      if (!StringDecoder2)
+        StringDecoder2 = string_decoder.StringDecoder;
+      this.decoder = new StringDecoder2(options2.encoding);
       this.encoding = options2.encoding;
     }
   }
@@ -224614,9 +224601,9 @@ function require_stream_readable() {
     return this._readableState.flowing === false;
   };
   Readable2.prototype.setEncoding = function(enc) {
-    if (!StringDecoder)
-      StringDecoder = requireString_decoder().StringDecoder;
-    this._readableState.decoder = new StringDecoder(enc);
+    if (!StringDecoder2)
+      StringDecoder2 = string_decoder.StringDecoder;
+    this._readableState.decoder = new StringDecoder2(enc);
     this._readableState.encoding = enc;
     return this;
   };
@@ -230421,7 +230408,7 @@ function requireSplit2() {
     return split2;
   hasRequiredSplit2 = 1;
   const { Transform: Transform2 } = require$$1$4;
-  const { StringDecoder } = requireString_decoder();
+  const { StringDecoder: StringDecoder2 } = string_decoder;
   const kLast = Symbol("last");
   const kDecoder = Symbol("decoder");
   function transform2(chunk, enc, cb) {
@@ -230502,7 +230489,7 @@ function requireSplit2() {
     options2.readableObjectMode = true;
     const stream2 = new Transform2(options2);
     stream2[kLast] = "";
-    stream2[kDecoder] = new StringDecoder("utf8");
+    stream2[kDecoder] = new StringDecoder2("utf8");
     stream2.matcher = matcher;
     stream2.mapper = mapper2;
     stream2.maxLength = options2.maxLength;
@@ -238929,7 +238916,7 @@ class BufferComposer {
 buffer.default = BufferComposer;
 var string = {};
 Object.defineProperty(string, "__esModule", { value: true });
-const string_decoder_1 = requireString_decoder();
+const string_decoder_1 = string_decoder;
 class StringComposer {
   constructor() {
     Object.defineProperty(this, "decoder", {

package/package.json

@@ -62,7 +62,7 @@
     "url": "https://github.com/ether/ueberDB.git"
   },
   "main": "./dist/index.js",
-  "version": "4.1.32",
+  "version": "4.1.33",
   "bugs": {
     "url": "https://github.com/ether/ueberDB/issues"
   },

package/dist/index.d.ts

@@ -1 +0,0 @@
-export * from './index'