@tidbcloud/uikit 2.0.0-beta.103 → 2.0.0-beta.104

package/dist/node_modules/.pnpm/string_decoder@1.1.1/node_modules/string_decoder/lib/string_decoder.cjs

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string_decoder = require("../../../../../../_virtual/string_decoder.cjs");
+const index = require("../../../../safe-buffer@5.1.2/node_modules/safe-buffer/index.cjs");
+var hasRequiredString_decoder;
+function requireString_decoder() {
+  if (hasRequiredString_decoder) return string_decoder.__exports;
+  hasRequiredString_decoder = 1;
+  var Buffer = index.safeBufferExports.Buffer;
+  var isEncoding = Buffer.isEncoding || function(encoding) {
+    encoding = "" + encoding;
+    switch (encoding && encoding.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":
+          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" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+    return nenc || enc;
+  }
+  string_decoder.__exports.StringDecoder = StringDecoder;
+  function StringDecoder(encoding) {
+    this.encoding = normalizeEncoding(encoding);
+    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;
+    }
+    this.lastNeed = 0;
+    this.lastTotal = 0;
+    this.lastChar = Buffer.allocUnsafe(nb);
+  }
+  StringDecoder.prototype.write = function(buf) {
+    if (buf.length === 0) return "";
+    var r;
+    var i;
+    if (this.lastNeed) {
+      r = this.fillLast(buf);
+      if (r === void 0) return "";
+      i = this.lastNeed;
+      this.lastNeed = 0;
+    } else {
+      i = 0;
+    }
+    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+    return r || "";
+  };
+  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(self, buf, i) {
+    var j = buf.length - 1;
+    if (j < i) return 0;
+    var nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) self.lastNeed = nb - 1;
+      return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) self.lastNeed = nb - 2;
+      return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) {
+        if (nb === 2) nb = 0;
+        else self.lastNeed = nb - 3;
+      }
+      return nb;
+    }
+    return 0;
+  }
+  function utf8CheckExtraBytes(self, buf, p) {
+    if ((buf[0] & 192) !== 128) {
+      self.lastNeed = 0;
+      return "�";
+    }
+    if (self.lastNeed > 1 && buf.length > 1) {
+      if ((buf[1] & 192) !== 128) {
+        self.lastNeed = 1;
+        return "�";
+      }
+      if (self.lastNeed > 2 && buf.length > 2) {
+        if ((buf[2] & 192) !== 128) {
+          self.lastNeed = 2;
+          return "�";
+        }
+      }
+    }
+  }
+  function utf8FillLast(buf) {
+    var p = this.lastTotal - this.lastNeed;
+    var r = utf8CheckExtraBytes(this, buf);
+    if (r !== void 0) return r;
+    if (this.lastNeed <= buf.length) {
+      buf.copy(this.lastChar, p, 0, this.lastNeed);
+      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    }
+    buf.copy(this.lastChar, p, 0, buf.length);
+    this.lastNeed -= buf.length;
+  }
+  function utf8Text(buf, i) {
+    var total = utf8CheckIncomplete(this, buf, i);
+    if (!this.lastNeed) return buf.toString("utf8", i);
+    this.lastTotal = total;
+    var end = buf.length - (total - this.lastNeed);
+    buf.copy(this.lastChar, 0, end);
+    return buf.toString("utf8", i, end);
+  }
+  function utf8End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + "�";
+    return r;
+  }
+  function utf16Text(buf, i) {
+    if ((buf.length - i) % 2 === 0) {
+      var r = buf.toString("utf16le", i);
+      if (r) {
+        var c = r.charCodeAt(r.length - 1);
+        if (c >= 55296 && c <= 56319) {
+          this.lastNeed = 2;
+          this.lastTotal = 4;
+          this.lastChar[0] = buf[buf.length - 2];
+          this.lastChar[1] = buf[buf.length - 1];
+          return r.slice(0, -1);
+        }
+      }
+      return r;
+    }
+    this.lastNeed = 1;
+    this.lastTotal = 2;
+    this.lastChar[0] = buf[buf.length - 1];
+    return buf.toString("utf16le", i, buf.length - 1);
+  }
+  function utf16End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) {
+      var end = this.lastTotal - this.lastNeed;
+      return r + this.lastChar.toString("utf16le", 0, end);
+    }
+    return r;
+  }
+  function base64Text(buf, i) {
+    var n = (buf.length - i) % 3;
+    if (n === 0) return buf.toString("base64", i);
+    this.lastNeed = 3 - n;
+    this.lastTotal = 3;
+    if (n === 1) {
+      this.lastChar[0] = buf[buf.length - 1];
+    } else {
+      this.lastChar[0] = buf[buf.length - 2];
+      this.lastChar[1] = buf[buf.length - 1];
+    }
+    return buf.toString("base64", i, buf.length - n);
+  }
+  function base64End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+    return r;
+  }
+  function simpleWrite(buf) {
+    return buf.toString(this.encoding);
+  }
+  function simpleEnd(buf) {
+    return buf && buf.length ? this.write(buf) : "";
+  }
+  return string_decoder.__exports;
+}
+exports.__require = requireString_decoder;

package/dist/node_modules/.pnpm/string_decoder@1.1.1/node_modules/string_decoder/lib/string_decoder.js

@@ -0,0 +1,242 @@
+import { __exports as string_decoder } from "../../../../../../_virtual/string_decoder.js";
+import { s as safeBufferExports } from "../../../../safe-buffer@5.1.2/node_modules/safe-buffer/index.js";
+var hasRequiredString_decoder;
+function requireString_decoder() {
+  if (hasRequiredString_decoder) return string_decoder;
+  hasRequiredString_decoder = 1;
+  var Buffer = safeBufferExports.Buffer;
+  var isEncoding = Buffer.isEncoding || function(encoding) {
+    encoding = "" + encoding;
+    switch (encoding && encoding.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":
+          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" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+    return nenc || enc;
+  }
+  string_decoder.StringDecoder = StringDecoder;
+  function StringDecoder(encoding) {
+    this.encoding = normalizeEncoding(encoding);
+    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;
+    }
+    this.lastNeed = 0;
+    this.lastTotal = 0;
+    this.lastChar = Buffer.allocUnsafe(nb);
+  }
+  StringDecoder.prototype.write = function(buf) {
+    if (buf.length === 0) return "";
+    var r;
+    var i;
+    if (this.lastNeed) {
+      r = this.fillLast(buf);
+      if (r === void 0) return "";
+      i = this.lastNeed;
+      this.lastNeed = 0;
+    } else {
+      i = 0;
+    }
+    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+    return r || "";
+  };
+  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(self, buf, i) {
+    var j = buf.length - 1;
+    if (j < i) return 0;
+    var nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) self.lastNeed = nb - 1;
+      return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) self.lastNeed = nb - 2;
+      return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+      if (nb > 0) {
+        if (nb === 2) nb = 0;
+        else self.lastNeed = nb - 3;
+      }
+      return nb;
+    }
+    return 0;
+  }
+  function utf8CheckExtraBytes(self, buf, p) {
+    if ((buf[0] & 192) !== 128) {
+      self.lastNeed = 0;
+      return "�";
+    }
+    if (self.lastNeed > 1 && buf.length > 1) {
+      if ((buf[1] & 192) !== 128) {
+        self.lastNeed = 1;
+        return "�";
+      }
+      if (self.lastNeed > 2 && buf.length > 2) {
+        if ((buf[2] & 192) !== 128) {
+          self.lastNeed = 2;
+          return "�";
+        }
+      }
+    }
+  }
+  function utf8FillLast(buf) {
+    var p = this.lastTotal - this.lastNeed;
+    var r = utf8CheckExtraBytes(this, buf);
+    if (r !== void 0) return r;
+    if (this.lastNeed <= buf.length) {
+      buf.copy(this.lastChar, p, 0, this.lastNeed);
+      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    }
+    buf.copy(this.lastChar, p, 0, buf.length);
+    this.lastNeed -= buf.length;
+  }
+  function utf8Text(buf, i) {
+    var total = utf8CheckIncomplete(this, buf, i);
+    if (!this.lastNeed) return buf.toString("utf8", i);
+    this.lastTotal = total;
+    var end = buf.length - (total - this.lastNeed);
+    buf.copy(this.lastChar, 0, end);
+    return buf.toString("utf8", i, end);
+  }
+  function utf8End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + "�";
+    return r;
+  }
+  function utf16Text(buf, i) {
+    if ((buf.length - i) % 2 === 0) {
+      var r = buf.toString("utf16le", i);
+      if (r) {
+        var c = r.charCodeAt(r.length - 1);
+        if (c >= 55296 && c <= 56319) {
+          this.lastNeed = 2;
+          this.lastTotal = 4;
+          this.lastChar[0] = buf[buf.length - 2];
+          this.lastChar[1] = buf[buf.length - 1];
+          return r.slice(0, -1);
+        }
+      }
+      return r;
+    }
+    this.lastNeed = 1;
+    this.lastTotal = 2;
+    this.lastChar[0] = buf[buf.length - 1];
+    return buf.toString("utf16le", i, buf.length - 1);
+  }
+  function utf16End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) {
+      var end = this.lastTotal - this.lastNeed;
+      return r + this.lastChar.toString("utf16le", 0, end);
+    }
+    return r;
+  }
+  function base64Text(buf, i) {
+    var n = (buf.length - i) % 3;
+    if (n === 0) return buf.toString("base64", i);
+    this.lastNeed = 3 - n;
+    this.lastTotal = 3;
+    if (n === 1) {
+      this.lastChar[0] = buf[buf.length - 1];
+    } else {
+      this.lastChar[0] = buf[buf.length - 2];
+      this.lastChar[1] = buf[buf.length - 1];
+    }
+    return buf.toString("base64", i, buf.length - n);
+  }
+  function base64End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+    return r;
+  }
+  function simpleWrite(buf) {
+    return buf.toString(this.encoding);
+  }
+  function simpleEnd(buf) {
+    return buf && buf.length ? this.write(buf) : "";
+  }
+  return string_decoder;
+}
+export {
+  requireString_decoder as __require
+};

package/dist/node_modules/.pnpm/through@2.3.8/node_modules/through/index.cjs

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const _commonjsHelpers = require("../../../../../_virtual/_commonjsHelpers.cjs");
+const index = require("../../../../../_virtual/index.cjs");
+const ___viteBrowserExternal_commonjsProxy = require("../../../../../_virtual/___vite-browser-external.cjs");
+(function(module2, exports2) {
+  var Stream = ___viteBrowserExternal_commonjsProxy.default;
+  module2.exports = through2;
+  through2.through = through2;
+  function through2(write, end, opts) {
+    write = write || function(data) {
+      this.queue(data);
+    };
+    end = end || function() {
+      this.queue(null);
+    };
+    var ended = false, destroyed = false, buffer = [], _ended = false;
+    var stream = new Stream();
+    stream.readable = stream.writable = true;
+    stream.paused = false;
+    stream.autoDestroy = !(opts && opts.autoDestroy === false);
+    stream.write = function(data) {
+      write.call(this, data);
+      return !stream.paused;
+    };
+    function drain() {
+      while (buffer.length && !stream.paused) {
+        var data = buffer.shift();
+        if (null === data)
+          return stream.emit("end");
+        else
+          stream.emit("data", data);
+      }
+    }
+    stream.queue = stream.push = function(data) {
+      if (_ended) return stream;
+      if (data === null) _ended = true;
+      buffer.push(data);
+      drain();
+      return stream;
+    };
+    stream.on("end", function() {
+      stream.readable = false;
+      if (!stream.writable && stream.autoDestroy)
+        process.nextTick(function() {
+          stream.destroy();
+        });
+    });
+    function _end() {
+      stream.writable = false;
+      end.call(stream);
+      if (!stream.readable && stream.autoDestroy)
+        stream.destroy();
+    }
+    stream.end = function(data) {
+      if (ended) return;
+      ended = true;
+      if (arguments.length) stream.write(data);
+      _end();
+      return stream;
+    };
+    stream.destroy = function() {
+      if (destroyed) return;
+      destroyed = true;
+      ended = true;
+      buffer.length = 0;
+      stream.writable = stream.readable = false;
+      stream.emit("close");
+      return stream;
+    };
+    stream.pause = function() {
+      if (stream.paused) return;
+      stream.paused = true;
+      return stream;
+    };
+    stream.resume = function() {
+      if (stream.paused) {
+        stream.paused = false;
+        stream.emit("resume");
+      }
+      drain();
+      if (!stream.paused)
+        stream.emit("drain");
+      return stream;
+    };
+    return stream;
+  }
+})(index.__module);
+var throughExports = index.__module.exports;
+const through = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(throughExports);
+exports.default = through;

package/dist/node_modules/.pnpm/through@2.3.8/node_modules/through/index.js

@@ -0,0 +1,91 @@
+import { getDefaultExportFromCjs } from "../../../../../_virtual/_commonjsHelpers.js";
+import { __module as through$1 } from "../../../../../_virtual/index.js";
+import require$$1 from "../../../../../_virtual/___vite-browser-external.js";
+(function(module, exports) {
+  var Stream = require$$1;
+  module.exports = through2;
+  through2.through = through2;
+  function through2(write, end, opts) {
+    write = write || function(data) {
+      this.queue(data);
+    };
+    end = end || function() {
+      this.queue(null);
+    };
+    var ended = false, destroyed = false, buffer = [], _ended = false;
+    var stream = new Stream();
+    stream.readable = stream.writable = true;
+    stream.paused = false;
+    stream.autoDestroy = !(opts && opts.autoDestroy === false);
+    stream.write = function(data) {
+      write.call(this, data);
+      return !stream.paused;
+    };
+    function drain() {
+      while (buffer.length && !stream.paused) {
+        var data = buffer.shift();
+        if (null === data)
+          return stream.emit("end");
+        else
+          stream.emit("data", data);
+      }
+    }
+    stream.queue = stream.push = function(data) {
+      if (_ended) return stream;
+      if (data === null) _ended = true;
+      buffer.push(data);
+      drain();
+      return stream;
+    };
+    stream.on("end", function() {
+      stream.readable = false;
+      if (!stream.writable && stream.autoDestroy)
+        process.nextTick(function() {
+          stream.destroy();
+        });
+    });
+    function _end() {
+      stream.writable = false;
+      end.call(stream);
+      if (!stream.readable && stream.autoDestroy)
+        stream.destroy();
+    }
+    stream.end = function(data) {
+      if (ended) return;
+      ended = true;
+      if (arguments.length) stream.write(data);
+      _end();
+      return stream;
+    };
+    stream.destroy = function() {
+      if (destroyed) return;
+      destroyed = true;
+      ended = true;
+      buffer.length = 0;
+      stream.writable = stream.readable = false;
+      stream.emit("close");
+      return stream;
+    };
+    stream.pause = function() {
+      if (stream.paused) return;
+      stream.paused = true;
+      return stream;
+    };
+    stream.resume = function() {
+      if (stream.paused) {
+        stream.paused = false;
+        stream.emit("resume");
+      }
+      drain();
+      if (!stream.paused)
+        stream.emit("drain");
+      return stream;
+    };
+    return stream;
+  }
+})(through$1);
+var throughExports = through$1.exports;
+const through = /* @__PURE__ */ getDefaultExportFromCjs(throughExports);
+export {
+  through as default
+};

package/dist/node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/browser.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _commonjsHelpers = require("../../../../../_virtual/_commonjsHelpers.cjs");
+var browser = deprecate;
+function deprecate(fn, msg) {
+  if (config("noDeprecation")) {
+    return fn;
+  }
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config("throwDeprecation")) {
+        throw new Error(msg);
+      } else if (config("traceDeprecation")) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+  return deprecated;
+}
+function config(name) {
+  try {
+    if (!_commonjsHelpers.commonjsGlobal.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = _commonjsHelpers.commonjsGlobal.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === "true";
+}
+exports.browser = browser;