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

package/dist/node_modules/.pnpm/buffer-from@0.1.2/node_modules/buffer-from/index.js

@@ -0,0 +1,46 @@
+var toString = Object.prototype.toString;
+var isModern = typeof Buffer.alloc === "function" && typeof Buffer.allocUnsafe === "function" && typeof Buffer.from === "function";
+function isArrayBuffer(input) {
+  return toString.call(input).slice(8, -1) === "ArrayBuffer";
+}
+function fromArrayBuffer(obj, byteOffset, length) {
+  byteOffset >>>= 0;
+  var maxLength = obj.byteLength - byteOffset;
+  if (maxLength < 0) {
+    throw new RangeError("'offset' is out of bounds");
+  }
+  if (length === void 0) {
+    length = maxLength;
+  } else {
+    length >>>= 0;
+    if (length > maxLength) {
+      throw new RangeError("'length' is out of bounds");
+    }
+  }
+  return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
+}
+function fromString(string, encoding) {
+  if (typeof encoding !== "string" || encoding === "") {
+    encoding = "utf8";
+  }
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding');
+  }
+  return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
+}
+function bufferFrom(value, encodingOrOffset, length) {
+  if (typeof value === "number") {
+    throw new TypeError('"value" argument must not be a number');
+  }
+  if (isArrayBuffer(value)) {
+    return fromArrayBuffer(value, encodingOrOffset, length);
+  }
+  if (typeof value === "string") {
+    return fromString(value, encodingOrOffset);
+  }
+  return isModern ? Buffer.from(value) : new Buffer(value);
+}
+var bufferFrom_1 = bufferFrom;
+export {
+  bufferFrom_1 as b
+};

package/dist/node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../../_virtual/util.cjs");
+const ___viteBrowserExternal_commonjsProxy = require("../../../../../../_virtual/___vite-browser-external.cjs");
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === "[object Array]";
+}
+util.__exports.isArray = isArray;
+function isBoolean(arg) {
+  return typeof arg === "boolean";
+}
+util.__exports.isBoolean = isBoolean;
+function isNull(arg) {
+  return arg === null;
+}
+util.__exports.isNull = isNull;
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+util.__exports.isNullOrUndefined = isNullOrUndefined;
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+util.__exports.isNumber = isNumber;
+function isString(arg) {
+  return typeof arg === "string";
+}
+util.__exports.isString = isString;
+function isSymbol(arg) {
+  return typeof arg === "symbol";
+}
+util.__exports.isSymbol = isSymbol;
+function isUndefined(arg) {
+  return arg === void 0;
+}
+util.__exports.isUndefined = isUndefined;
+function isRegExp(re) {
+  return objectToString(re) === "[object RegExp]";
+}
+util.__exports.isRegExp = isRegExp;
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+util.__exports.isObject = isObject;
+function isDate(d) {
+  return objectToString(d) === "[object Date]";
+}
+util.__exports.isDate = isDate;
+function isError(e) {
+  return objectToString(e) === "[object Error]" || e instanceof Error;
+}
+util.__exports.isError = isError;
+function isFunction(arg) {
+  return typeof arg === "function";
+}
+util.__exports.isFunction = isFunction;
+function isPrimitive(arg) {
+  return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+  typeof arg === "undefined";
+}
+util.__exports.isPrimitive = isPrimitive;
+util.__exports.isBuffer = ___viteBrowserExternal_commonjsProxy.default.Buffer.isBuffer;
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+exports.default = util.__exports;

package/dist/node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.js

@@ -0,0 +1,69 @@
+import { __exports as util } from "../../../../../../_virtual/util.js";
+import require$$1 from "../../../../../../_virtual/___vite-browser-external.js";
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === "[object Array]";
+}
+util.isArray = isArray;
+function isBoolean(arg) {
+  return typeof arg === "boolean";
+}
+util.isBoolean = isBoolean;
+function isNull(arg) {
+  return arg === null;
+}
+util.isNull = isNull;
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+util.isNullOrUndefined = isNullOrUndefined;
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+util.isNumber = isNumber;
+function isString(arg) {
+  return typeof arg === "string";
+}
+util.isString = isString;
+function isSymbol(arg) {
+  return typeof arg === "symbol";
+}
+util.isSymbol = isSymbol;
+function isUndefined(arg) {
+  return arg === void 0;
+}
+util.isUndefined = isUndefined;
+function isRegExp(re) {
+  return objectToString(re) === "[object RegExp]";
+}
+util.isRegExp = isRegExp;
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+util.isObject = isObject;
+function isDate(d) {
+  return objectToString(d) === "[object Date]";
+}
+util.isDate = isDate;
+function isError(e) {
+  return objectToString(e) === "[object Error]" || e instanceof Error;
+}
+util.isError = isError;
+function isFunction(arg) {
+  return typeof arg === "function";
+}
+util.isFunction = isFunction;
+function isPrimitive(arg) {
+  return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+  typeof arg === "undefined";
+}
+util.isPrimitive = isPrimitive;
+util.isBuffer = require$$1.Buffer.isBuffer;
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+export {
+  util as default
+};

package/dist/node_modules/.pnpm/duplexer2@0.1.4/node_modules/duplexer2/index.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../_virtual/index3.cjs");
+const readableBrowser = require("../../../readable-stream@2.3.8/node_modules/readable-stream/readable-browser.cjs");
+var stream = readableBrowser.readableBrowserExports;
+function DuplexWrapper(options, writable, readable) {
+  if (typeof readable === "undefined") {
+    readable = writable;
+    writable = options;
+    options = null;
+  }
+  stream.Duplex.call(this, options);
+  if (typeof readable.read !== "function") {
+    readable = new stream.Readable(options).wrap(readable);
+  }
+  this._writable = writable;
+  this._readable = readable;
+  this._waiting = false;
+  var self = this;
+  writable.once("finish", function() {
+    self.end();
+  });
+  this.once("finish", function() {
+    writable.end();
+  });
+  readable.on("readable", function() {
+    if (self._waiting) {
+      self._waiting = false;
+      self._read();
+    }
+  });
+  readable.once("end", function() {
+    self.push(null);
+  });
+  if (!options || typeof options.bubbleErrors === "undefined" || options.bubbleErrors) {
+    writable.on("error", function(err) {
+      self.emit("error", err);
+    });
+    readable.on("error", function(err) {
+      self.emit("error", err);
+    });
+  }
+}
+DuplexWrapper.prototype = Object.create(stream.Duplex.prototype, { constructor: { value: DuplexWrapper } });
+DuplexWrapper.prototype._write = function _write(input, encoding, done) {
+  this._writable.write(input, encoding, done);
+};
+DuplexWrapper.prototype._read = function _read() {
+  var buf;
+  var reads = 0;
+  while ((buf = this._readable.read()) !== null) {
+    this.push(buf);
+    reads++;
+  }
+  if (reads === 0) {
+    this._waiting = true;
+  }
+};
+index.__module.exports = function duplex2(options, writable, readable) {
+  return new DuplexWrapper(options, writable, readable);
+};
+index.__module.exports.DuplexWrapper = DuplexWrapper;
+var duplexer2Exports = index.__module.exports;
+exports.duplexer2Exports = duplexer2Exports;

package/dist/node_modules/.pnpm/duplexer2@0.1.4/node_modules/duplexer2/index.js

@@ -0,0 +1,64 @@
+import { __module as duplexer2 } from "../../../../../_virtual/index3.js";
+import { r as readableBrowserExports } from "../../../readable-stream@2.3.8/node_modules/readable-stream/readable-browser.js";
+var stream = readableBrowserExports;
+function DuplexWrapper(options, writable, readable) {
+  if (typeof readable === "undefined") {
+    readable = writable;
+    writable = options;
+    options = null;
+  }
+  stream.Duplex.call(this, options);
+  if (typeof readable.read !== "function") {
+    readable = new stream.Readable(options).wrap(readable);
+  }
+  this._writable = writable;
+  this._readable = readable;
+  this._waiting = false;
+  var self = this;
+  writable.once("finish", function() {
+    self.end();
+  });
+  this.once("finish", function() {
+    writable.end();
+  });
+  readable.on("readable", function() {
+    if (self._waiting) {
+      self._waiting = false;
+      self._read();
+    }
+  });
+  readable.once("end", function() {
+    self.push(null);
+  });
+  if (!options || typeof options.bubbleErrors === "undefined" || options.bubbleErrors) {
+    writable.on("error", function(err) {
+      self.emit("error", err);
+    });
+    readable.on("error", function(err) {
+      self.emit("error", err);
+    });
+  }
+}
+DuplexWrapper.prototype = Object.create(stream.Duplex.prototype, { constructor: { value: DuplexWrapper } });
+DuplexWrapper.prototype._write = function _write(input, encoding, done) {
+  this._writable.write(input, encoding, done);
+};
+DuplexWrapper.prototype._read = function _read() {
+  var buf;
+  var reads = 0;
+  while ((buf = this._readable.read()) !== null) {
+    this.push(buf);
+    reads++;
+  }
+  if (reads === 0) {
+    this._waiting = true;
+  }
+};
+duplexer2.exports = function duplex2(options, writable, readable) {
+  return new DuplexWrapper(options, writable, readable);
+};
+duplexer2.exports.DuplexWrapper = DuplexWrapper;
+var duplexer2Exports = duplexer2.exports;
+export {
+  duplexer2Exports as d
+};

package/dist/node_modules/.pnpm/html-tokenize@2.0.1/node_modules/html-tokenize/index.cjs

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const _commonjsHelpers = require("../../../../../_virtual/_commonjsHelpers.cjs");
+const index = require("../../../buffer-from@0.1.2/node_modules/buffer-from/index.cjs");
+const readable = require("../../../readable-stream@1.0.34/node_modules/readable-stream/readable.cjs");
+const inherits_browser = require("../../../inherits@2.0.4/node_modules/inherits/inherits_browser.cjs");
+var bufferFrom = index.bufferFrom_1;
+var Transform = readable.readableExports.Transform;
+var inherits = inherits_browser.inherits_browserExports;
+inherits(Tokenize, Transform);
+var htmlTokenize = Tokenize;
+var codes = {
+  lt: "<".charCodeAt(0),
+  gt: ">".charCodeAt(0),
+  slash: "/".charCodeAt(0),
+  dquote: '"'.charCodeAt(0),
+  squote: "'".charCodeAt(0),
+  equal: "=".charCodeAt(0)
+};
+var strings = {
+  endScript: bufferFrom("<\/script"),
+  endStyle: bufferFrom("</style"),
+  endTitle: bufferFrom("</title"),
+  comment: bufferFrom("<!--"),
+  endComment: bufferFrom("-->"),
+  cdata: bufferFrom("<![CDATA["),
+  endCdata: bufferFrom("]]>")
+};
+var states = {
+  "TagNameState": 1,
+  "AttributeNameState": 2,
+  "BeforeAttributeValueState": 3,
+  "AttributeValueState": 4
+};
+function Tokenize() {
+  if (!(this instanceof Tokenize)) return new Tokenize();
+  Transform.call(this);
+  this._readableState.objectMode = true;
+  this.state = "text";
+  this.tagState = null;
+  this.quoteState = null;
+  this.raw = null;
+  this.buffers = [];
+  this._last = [];
+}
+Tokenize.prototype._transform = function(buf, enc, next) {
+  var i = 0;
+  var offset = 0;
+  if (this._prev) {
+    buf = Buffer.concat([this._prev, buf]);
+    i = this._prev.length - 1;
+    offset = this._offset;
+    this._prev = null;
+    this._offset = 0;
+  }
+  for (; i < buf.length; i++) {
+    var b = buf[i];
+    this._last.push(b);
+    if (this._last.length > 9) this._last.shift();
+    if (this.raw) {
+      var parts = this._testRaw(buf, offset, i);
+      if (parts) {
+        this.push(["text", parts[0]]);
+        if (this.raw === strings.endComment || this.raw === strings.endCdata) {
+          this.state = "text";
+          this.buffers = [];
+          this.push(["close", parts[1]]);
+        } else {
+          this.state = "open";
+          this.buffers = [parts[1]];
+        }
+        this.raw = null;
+        offset = i + 1;
+      }
+    } else if (this.state === "text" && b === codes.lt && i === buf.length - 1) {
+      this._prev = buf;
+      this._offset = offset;
+      return next();
+    } else if (this.state === "text" && b === codes.lt && !isWhiteSpace(buf[i + 1])) {
+      if (i > 0 && i - offset > 0) {
+        this.buffers.push(buf.slice(offset, i));
+      }
+      offset = i;
+      this.state = "open";
+      this.tagState = states.TagNameState;
+      this._pushState("text");
+    } else if (this.tagState === states.TagNameState && isWhiteSpace(b)) {
+      this.tagState = states.AttributeNameState;
+    } else if (this.tagState === states.AttributeNameState && b === codes.equal) {
+      this.tagState = states.BeforeAttributeValueState;
+    } else if (this.tagState === states.BeforeAttributeValueState && isWhiteSpace(b)) ;
+    else if (this.tagState === states.BeforeAttributeValueState && b !== codes.gt) {
+      this.tagState = states.AttributeValueState;
+      if (b === codes.dquote) {
+        this.quoteState = "double";
+      } else if (b === codes.squote) {
+        this.quoteState = "single";
+      } else {
+        this.quoteState = null;
+      }
+    } else if (this.tagState === states.AttributeValueState && !this.quoteState && isWhiteSpace(b)) {
+      this.tagState = states.AttributeNameState;
+    } else if (this.tagState === states.AttributeValueState && this.quoteState === "double" && b === codes.dquote) {
+      this.quoteState = null;
+      this.tagState = states.AttributeNameState;
+    } else if (this.tagState === states.AttributeValueState && this.quoteState === "single" && b === codes.squote) {
+      this.quoteState = null;
+      this.tagState = states.AttributeNameState;
+    } else if (this.state === "open" && b === codes.gt && !this.quoteState) {
+      this.buffers.push(buf.slice(offset, i + 1));
+      offset = i + 1;
+      this.state = "text";
+      this.tagState = null;
+      if (this._getChar(1) === codes.slash) {
+        this._pushState("close");
+      } else {
+        var tag = this._getTag();
+        if (tag === "script") this.raw = strings.endScript;
+        if (tag === "style") this.raw = strings.endStyle;
+        if (tag === "title") this.raw = strings.endTitle;
+        this._pushState("open");
+      }
+    } else if (this.state === "open" && compare(this._last, strings.comment)) {
+      this.buffers.push(buf.slice(offset, i + 1));
+      offset = i + 1;
+      this.state = "text";
+      this.raw = strings.endComment;
+      this._pushState("open");
+    } else if (this.state === "open" && compare(this._last, strings.cdata)) {
+      this.buffers.push(buf.slice(offset, i + 1));
+      offset = i + 1;
+      this.state = "text";
+      this.raw = strings.endCdata;
+      this._pushState("open");
+    }
+  }
+  if (offset < buf.length) this.buffers.push(buf.slice(offset));
+  next();
+};
+Tokenize.prototype._flush = function(next) {
+  if (this.state === "text") this._pushState("text");
+  this.push(null);
+  next();
+};
+Tokenize.prototype._pushState = function(ev) {
+  if (this.buffers.length === 0) return;
+  var buf = Buffer.concat(this.buffers);
+  this.buffers = [];
+  this.push([ev, buf]);
+};
+Tokenize.prototype._getChar = function(i) {
+  var offset = 0;
+  for (var j = 0; j < this.buffers.length; j++) {
+    var buf = this.buffers[j];
+    if (offset + buf.length > i) {
+      return buf[i - offset];
+    }
+    offset += buf;
+  }
+};
+Tokenize.prototype._getTag = function() {
+  var offset = 0;
+  var tag = "";
+  for (var j = 0; j < this.buffers.length; j++) {
+    var buf = this.buffers[j];
+    for (var k = 0; k < buf.length; k++) {
+      if (offset === 0 && k === 0) continue;
+      var c = String.fromCharCode(buf[k]);
+      if (/[^\w-!\[\]]/.test(c)) {
+        return tag.toLowerCase();
+      } else tag += c;
+    }
+    offset += buf.length;
+  }
+};
+Tokenize.prototype._testRaw = function(buf, offset, index2) {
+  var raw = this.raw, last = this._last;
+  if (!compare(last, raw)) return;
+  this.buffers.push(buf.slice(offset, index2 + 1));
+  var buf = Buffer.concat(this.buffers);
+  var k = buf.length - raw.length;
+  return [buf.slice(0, k), buf.slice(k)];
+};
+function compare(a, b) {
+  if (a.length < b.length) return false;
+  for (var i = a.length - 1, j = b.length - 1; i >= 0 && j >= 0; i--, j--) {
+    if (lower(a[i]) !== lower(b[j])) return false;
+  }
+  return true;
+}
+function lower(n) {
+  if (n >= 65 && n <= 90) return n + 32;
+  return n;
+}
+function isWhiteSpace(b) {
+  return b === 32 || b === 9 || b === 10 || b === 12 || b === 13;
+}
+const tokenize = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(htmlTokenize);
+exports.default = tokenize;