回退版本

node_modules/.vite/deps/chunk-AC2VUBZ6.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};
+//# sourceMappingURL=chunk-AC2VUBZ6.js.map

node_modules/.vite/deps/chunk-AC2VUBZ6.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

node_modules/.vite/deps/chunk-KRTWMFYD.js

@@ -0,0 +1,4126 @@
+import {
+  __esm,
+  __export
+} from "./chunk-AC2VUBZ6.js";
+
+// node_modules/tslib/tslib.es6.js
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __rest(s, e) {
+  var t = {};
+  for (var p in s)
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1)
+      throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length === "number")
+    return {
+      next: function() {
+        if (o && i >= o.length)
+          o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArrays() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+    s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++)
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+      r[k] = a[j];
+  return r;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+        if (!ar)
+          ar = Array.prototype.slice.call(from, 0, i);
+        ar[i] = from[i];
+      }
+    }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+var extendStatics, __assign;
+var init_tslib_es6 = __esm({
+  "node_modules/tslib/tslib.es6.js"() {
+    extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+        d2.__proto__ = b2;
+      } || function(d2, b2) {
+        for (var p in b2)
+          if (Object.prototype.hasOwnProperty.call(b2, p))
+            d2[p] = b2[p];
+      };
+      return extendStatics(d, b);
+    };
+    __assign = function() {
+      __assign = Object.assign || function __assign2(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/is-nil.js
+var isNil, is_nil_default;
+var init_is_nil = __esm({
+  "node_modules/@antv/util/esm/is-nil.js"() {
+    isNil = function(value) {
+      return value === null || value === void 0;
+    };
+    is_nil_default = isNil;
+  }
+});
+
+// node_modules/@antv/util/esm/is-object.js
+var is_object_default;
+var init_is_object = __esm({
+  "node_modules/@antv/util/esm/is-object.js"() {
+    is_object_default = function(value) {
+      var type = typeof value;
+      return value !== null && type === "object" || type === "function";
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/is-type.js
+var toString, isType, is_type_default;
+var init_is_type = __esm({
+  "node_modules/@antv/util/esm/is-type.js"() {
+    toString = {}.toString;
+    isType = function(value, type) {
+      return toString.call(value) === "[object " + type + "]";
+    };
+    is_type_default = isType;
+  }
+});
+
+// node_modules/@antv/util/esm/is-array.js
+var is_array_default;
+var init_is_array = __esm({
+  "node_modules/@antv/util/esm/is-array.js"() {
+    init_is_type();
+    is_array_default = function(value) {
+      return Array.isArray ? Array.isArray(value) : is_type_default(value, "Array");
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/each.js
+function each(elements, func) {
+  if (!elements) {
+    return;
+  }
+  var rst;
+  if (is_array_default(elements)) {
+    for (var i = 0, len3 = elements.length; i < len3; i++) {
+      rst = func(elements[i], i);
+      if (rst === false) {
+        break;
+      }
+    }
+  } else if (is_object_default(elements)) {
+    for (var k in elements) {
+      if (elements.hasOwnProperty(k)) {
+        rst = func(elements[k], k);
+        if (rst === false) {
+          break;
+        }
+      }
+    }
+  }
+}
+var each_default;
+var init_each = __esm({
+  "node_modules/@antv/util/esm/each.js"() {
+    init_is_array();
+    init_is_object();
+    each_default = each;
+  }
+});
+
+// node_modules/@antv/util/esm/is-object-like.js
+var isObjectLike, is_object_like_default;
+var init_is_object_like = __esm({
+  "node_modules/@antv/util/esm/is-object-like.js"() {
+    isObjectLike = function(value) {
+      return typeof value === "object" && value !== null;
+    };
+    is_object_like_default = isObjectLike;
+  }
+});
+
+// node_modules/@antv/util/esm/is-plain-object.js
+var isPlainObject, is_plain_object_default;
+var init_is_plain_object = __esm({
+  "node_modules/@antv/util/esm/is-plain-object.js"() {
+    init_is_object_like();
+    init_is_type();
+    isPlainObject = function(value) {
+      if (!is_object_like_default(value) || !is_type_default(value, "Object")) {
+        return false;
+      }
+      if (Object.getPrototypeOf(value) === null) {
+        return true;
+      }
+      var proto = value;
+      while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+      }
+      return Object.getPrototypeOf(value) === proto;
+    };
+    is_plain_object_default = isPlainObject;
+  }
+});
+
+// node_modules/@antv/util/esm/reduce.js
+var reduce, reduce_default;
+var init_reduce = __esm({
+  "node_modules/@antv/util/esm/reduce.js"() {
+    init_each();
+    init_is_array();
+    init_is_plain_object();
+    reduce = function(arr, fn, init) {
+      if (!is_array_default(arr) && !is_plain_object_default(arr)) {
+        return arr;
+      }
+      var result = init;
+      each_default(arr, function(data, i) {
+        result = fn(result, data, i);
+      });
+      return result;
+    };
+    reduce_default = reduce;
+  }
+});
+
+// node_modules/@antv/util/esm/is-string.js
+var is_string_default;
+var init_is_string = __esm({
+  "node_modules/@antv/util/esm/is-string.js"() {
+    init_is_type();
+    is_string_default = function(str4) {
+      return is_type_default(str4, "String");
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/is-number.js
+var isNumber, is_number_default;
+var init_is_number = __esm({
+  "node_modules/@antv/util/esm/is-number.js"() {
+    init_is_type();
+    isNumber = function(value) {
+      return is_type_default(value, "Number");
+    };
+    is_number_default = isNumber;
+  }
+});
+
+// node_modules/@antv/util/esm/is-function.js
+var is_function_default;
+var init_is_function = __esm({
+  "node_modules/@antv/util/esm/is-function.js"() {
+    init_is_type();
+    is_function_default = function(value) {
+      return is_type_default(value, "Function");
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/values.js
+var values, values_default;
+var init_values = __esm({
+  "node_modules/@antv/util/esm/values.js"() {
+    init_each();
+    init_is_function();
+    values = Object.values ? function(obj) {
+      return Object.values(obj);
+    } : function(obj) {
+      var result = [];
+      each_default(obj, function(value, key) {
+        if (!(is_function_default(obj) && key === "prototype")) {
+          result.push(value);
+        }
+      });
+      return result;
+    };
+    values_default = values;
+  }
+});
+
+// node_modules/@antv/util/esm/mix.js
+function _mix(dist3, obj) {
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key) && key !== "constructor" && obj[key] !== void 0) {
+      dist3[key] = obj[key];
+    }
+  }
+}
+function mix(dist3, src1, src2, src3) {
+  if (src1)
+    _mix(dist3, src1);
+  if (src2)
+    _mix(dist3, src2);
+  if (src3)
+    _mix(dist3, src3);
+  return dist3;
+}
+var init_mix = __esm({
+  "node_modules/@antv/util/esm/mix.js"() {
+  }
+});
+
+// node_modules/@antv/util/esm/memoize.js
+var memoize_default;
+var init_memoize = __esm({
+  "node_modules/@antv/util/esm/memoize.js"() {
+    init_is_function();
+    memoize_default = function(f, resolver) {
+      if (!is_function_default(f)) {
+        throw new TypeError("Expected a function");
+      }
+      var memoized = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        var key = resolver ? resolver.apply(this, args) : args[0];
+        var cache = memoized.cache;
+        if (cache.has(key)) {
+          return cache.get(key);
+        }
+        var result = f.apply(this, args);
+        cache.set(key, result);
+        return result;
+      };
+      memoized.cache = /* @__PURE__ */ new Map();
+      return memoized;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/deep-mix.js
+function _deepMix(dist3, src, level, maxLevel) {
+  level = level || 0;
+  maxLevel = maxLevel || MAX_MIX_LEVEL;
+  for (var key in src) {
+    if (src.hasOwnProperty(key)) {
+      var value = src[key];
+      if (value !== null && is_plain_object_default(value)) {
+        if (!is_plain_object_default(dist3[key])) {
+          dist3[key] = {};
+        }
+        if (level < maxLevel) {
+          _deepMix(dist3[key], value, level + 1, maxLevel);
+        } else {
+          dist3[key] = src[key];
+        }
+      } else if (is_array_default(value)) {
+        dist3[key] = [];
+        dist3[key] = dist3[key].concat(value);
+      } else if (value !== void 0) {
+        dist3[key] = value;
+      }
+    }
+  }
+}
+var MAX_MIX_LEVEL, deepMix, deep_mix_default;
+var init_deep_mix = __esm({
+  "node_modules/@antv/util/esm/deep-mix.js"() {
+    init_is_array();
+    init_is_plain_object();
+    MAX_MIX_LEVEL = 5;
+    deepMix = function(rst) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+      }
+      for (var i = 0; i < args.length; i += 1) {
+        _deepMix(rst, args[i]);
+      }
+      return rst;
+    };
+    deep_mix_default = deepMix;
+  }
+});
+
+// node_modules/@antv/util/esm/get.js
+var get_default;
+var init_get = __esm({
+  "node_modules/@antv/util/esm/get.js"() {
+    init_is_string();
+    get_default = function(obj, key, defaultValue) {
+      var p = 0;
+      var keyArr = is_string_default(key) ? key.split(".") : key;
+      while (obj && p < keyArr.length) {
+        obj = obj[keyArr[p++]];
+      }
+      return obj === void 0 || p < keyArr.length ? defaultValue : obj;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/is-array-like.js
+var isArrayLike, is_array_like_default;
+var init_is_array_like = __esm({
+  "node_modules/@antv/util/esm/is-array-like.js"() {
+    isArrayLike = function(value) {
+      return value !== null && typeof value !== "function" && isFinite(value.length);
+    };
+    is_array_like_default = isArrayLike;
+  }
+});
+
+// node_modules/@antv/util/esm/contains.js
+var contains, contains_default;
+var init_contains = __esm({
+  "node_modules/@antv/util/esm/contains.js"() {
+    init_is_array_like();
+    contains = function(arr, value) {
+      if (!is_array_like_default(arr)) {
+        return false;
+      }
+      return arr.indexOf(value) > -1;
+    };
+    contains_default = contains;
+  }
+});
+
+// node_modules/@antv/util/esm/filter.js
+var filter, filter_default;
+var init_filter = __esm({
+  "node_modules/@antv/util/esm/filter.js"() {
+    init_is_array_like();
+    filter = function(arr, func) {
+      if (!is_array_like_default(arr)) {
+        return arr;
+      }
+      var result = [];
+      for (var index = 0; index < arr.length; index++) {
+        var value = arr[index];
+        if (func(value, index)) {
+          result.push(value);
+        }
+      }
+      return result;
+    };
+    filter_default = filter;
+  }
+});
+
+// node_modules/@antv/util/esm/difference.js
+var difference, difference_default;
+var init_difference = __esm({
+  "node_modules/@antv/util/esm/difference.js"() {
+    init_filter();
+    init_contains();
+    difference = function(arr, values2) {
+      if (values2 === void 0) {
+        values2 = [];
+      }
+      return filter_default(arr, function(value) {
+        return !contains_default(values2, value);
+      });
+    };
+    difference_default = difference;
+  }
+});
+
+// node_modules/@antv/util/esm/keys.js
+var keys, keys_default;
+var init_keys = __esm({
+  "node_modules/@antv/util/esm/keys.js"() {
+    init_each();
+    init_is_function();
+    keys = Object.keys ? function(obj) {
+      return Object.keys(obj);
+    } : function(obj) {
+      var result = [];
+      each_default(obj, function(value, key) {
+        if (!(is_function_default(obj) && key === "prototype")) {
+          result.push(key);
+        }
+      });
+      return result;
+    };
+    keys_default = keys;
+  }
+});
+
+// node_modules/@antv/util/esm/is-match.js
+function isMatch(obj, attrs) {
+  var _keys = keys_default(attrs);
+  var length5 = _keys.length;
+  if (is_nil_default(obj))
+    return !length5;
+  for (var i = 0; i < length5; i += 1) {
+    var key = _keys[i];
+    if (attrs[key] !== obj[key] || !(key in obj)) {
+      return false;
+    }
+  }
+  return true;
+}
+var is_match_default;
+var init_is_match = __esm({
+  "node_modules/@antv/util/esm/is-match.js"() {
+    init_is_nil();
+    init_keys();
+    is_match_default = isMatch;
+  }
+});
+
+// node_modules/@antv/util/esm/find.js
+function find(arr, predicate) {
+  if (!is_array_default(arr))
+    return null;
+  var _predicate;
+  if (is_function_default(predicate)) {
+    _predicate = predicate;
+  }
+  if (is_plain_object_default(predicate)) {
+    _predicate = function(a) {
+      return is_match_default(a, predicate);
+    };
+  }
+  if (_predicate) {
+    for (var i = 0; i < arr.length; i += 1) {
+      if (_predicate(arr[i])) {
+        return arr[i];
+      }
+    }
+  }
+  return null;
+}
+var find_default;
+var init_find = __esm({
+  "node_modules/@antv/util/esm/find.js"() {
+    init_is_function();
+    init_is_match();
+    init_is_array();
+    init_is_plain_object();
+    find_default = find;
+  }
+});
+
+// node_modules/@antv/util/esm/find-index.js
+function findIndex(arr, predicate, fromIndex) {
+  if (fromIndex === void 0) {
+    fromIndex = 0;
+  }
+  for (var i = fromIndex; i < arr.length; i++) {
+    if (predicate(arr[i], i)) {
+      return i;
+    }
+  }
+  return -1;
+}
+var find_index_default;
+var init_find_index = __esm({
+  "node_modules/@antv/util/esm/find-index.js"() {
+    find_index_default = findIndex;
+  }
+});
+
+// node_modules/@antv/util/esm/first-value.js
+var firstValue, first_value_default;
+var init_first_value = __esm({
+  "node_modules/@antv/util/esm/first-value.js"() {
+    init_is_nil();
+    init_is_array();
+    firstValue = function(data, name) {
+      var rst = null;
+      for (var i = 0; i < data.length; i++) {
+        var obj = data[i];
+        var value = obj[name];
+        if (!is_nil_default(value)) {
+          if (is_array_default(value)) {
+            rst = value[0];
+          } else {
+            rst = value;
+          }
+          break;
+        }
+      }
+      return rst;
+    };
+    first_value_default = firstValue;
+  }
+});
+
+// node_modules/@antv/util/esm/flatten.js
+var flatten, flatten_default;
+var init_flatten = __esm({
+  "node_modules/@antv/util/esm/flatten.js"() {
+    init_is_array();
+    flatten = function(arr) {
+      if (!is_array_default(arr)) {
+        return [];
+      }
+      var rst = [];
+      for (var i = 0; i < arr.length; i++) {
+        rst = rst.concat(arr[i]);
+      }
+      return rst;
+    };
+    flatten_default = flatten;
+  }
+});
+
+// node_modules/@antv/util/esm/flatten-deep.js
+var flattenDeep, flatten_deep_default;
+var init_flatten_deep = __esm({
+  "node_modules/@antv/util/esm/flatten-deep.js"() {
+    init_is_array();
+    flattenDeep = function(arr, result) {
+      if (result === void 0) {
+        result = [];
+      }
+      if (!is_array_default(arr)) {
+        result.push(arr);
+      } else {
+        for (var i = 0; i < arr.length; i += 1) {
+          flattenDeep(arr[i], result);
+        }
+      }
+      return result;
+    };
+    flatten_deep_default = flattenDeep;
+  }
+});
+
+// node_modules/@antv/util/esm/max.js
+var max_default;
+var init_max = __esm({
+  "node_modules/@antv/util/esm/max.js"() {
+    init_is_array();
+    max_default = function(arr) {
+      if (!is_array_default(arr)) {
+        return void 0;
+      }
+      return arr.reduce(function(prev, curr) {
+        return Math.max(prev, curr);
+      }, arr[0]);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/min.js
+var min_default;
+var init_min = __esm({
+  "node_modules/@antv/util/esm/min.js"() {
+    init_is_array();
+    min_default = function(arr) {
+      if (!is_array_default(arr)) {
+        return void 0;
+      }
+      return arr.reduce(function(prev, curr) {
+        return Math.min(prev, curr);
+      }, arr[0]);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/get-range.js
+var getRange, get_range_default;
+var init_get_range = __esm({
+  "node_modules/@antv/util/esm/get-range.js"() {
+    init_is_array();
+    init_max();
+    init_min();
+    getRange = function(values2) {
+      var filterValues = values2.filter(function(v) {
+        return !isNaN(v);
+      });
+      if (!filterValues.length) {
+        return {
+          min: 0,
+          max: 0
+        };
+      }
+      if (is_array_default(values2[0])) {
+        var tmp = [];
+        for (var i = 0; i < values2.length; i++) {
+          tmp = tmp.concat(values2[i]);
+        }
+        filterValues = tmp;
+      }
+      var max3 = max_default(filterValues);
+      var min3 = min_default(filterValues);
+      return {
+        min: min3,
+        max: max3
+      };
+    };
+    get_range_default = getRange;
+  }
+});
+
+// node_modules/@antv/util/esm/pull.js
+var arrPrototype, splice, indexOf, pull, pull_default;
+var init_pull = __esm({
+  "node_modules/@antv/util/esm/pull.js"() {
+    arrPrototype = Array.prototype;
+    splice = arrPrototype.splice;
+    indexOf = arrPrototype.indexOf;
+    pull = function(arr) {
+      var values2 = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        values2[_i - 1] = arguments[_i];
+      }
+      for (var i = 0; i < values2.length; i++) {
+        var value = values2[i];
+        var fromIndex = -1;
+        while ((fromIndex = indexOf.call(arr, value)) > -1) {
+          splice.call(arr, fromIndex, 1);
+        }
+      }
+      return arr;
+    };
+    pull_default = pull;
+  }
+});
+
+// node_modules/@antv/util/esm/pull-at.js
+var splice2, pullAt, pull_at_default;
+var init_pull_at = __esm({
+  "node_modules/@antv/util/esm/pull-at.js"() {
+    init_is_array_like();
+    splice2 = Array.prototype.splice;
+    pullAt = function pullAt2(arr, indexes) {
+      if (!is_array_like_default(arr)) {
+        return [];
+      }
+      var length5 = arr ? indexes.length : 0;
+      var last2 = length5 - 1;
+      while (length5--) {
+        var previous = void 0;
+        var index = indexes[length5];
+        if (length5 === last2 || index !== previous) {
+          previous = index;
+          splice2.call(arr, index, 1);
+        }
+      }
+      return arr;
+    };
+    pull_at_default = pullAt;
+  }
+});
+
+// node_modules/@antv/util/esm/remove.js
+var remove, remove_default;
+var init_remove = __esm({
+  "node_modules/@antv/util/esm/remove.js"() {
+    init_is_array_like();
+    init_pull_at();
+    remove = function(arr, predicate) {
+      var result = [];
+      if (!is_array_like_default(arr)) {
+        return result;
+      }
+      var i = -1;
+      var indexes = [];
+      var length5 = arr.length;
+      while (++i < length5) {
+        var value = arr[i];
+        if (predicate(value, i, arr)) {
+          result.push(value);
+          indexes.push(i);
+        }
+      }
+      pull_at_default(arr, indexes);
+      return result;
+    };
+    remove_default = remove;
+  }
+});
+
+// node_modules/@antv/util/esm/sort-by.js
+function sortBy(arr, key) {
+  var comparer;
+  if (is_function_default(key)) {
+    comparer = function(a, b) {
+      return key(a) - key(b);
+    };
+  } else {
+    var keys_1 = [];
+    if (is_string_default(key)) {
+      keys_1.push(key);
+    } else if (is_array_default(key)) {
+      keys_1 = key;
+    }
+    comparer = function(a, b) {
+      for (var i = 0; i < keys_1.length; i += 1) {
+        var prop = keys_1[i];
+        if (a[prop] > b[prop]) {
+          return 1;
+        }
+        if (a[prop] < b[prop]) {
+          return -1;
+        }
+      }
+      return 0;
+    };
+  }
+  arr.sort(comparer);
+  return arr;
+}
+var sort_by_default;
+var init_sort_by = __esm({
+  "node_modules/@antv/util/esm/sort-by.js"() {
+    init_is_array();
+    init_is_string();
+    init_is_function();
+    sort_by_default = sortBy;
+  }
+});
+
+// node_modules/@antv/util/esm/uniq.js
+function uniq(arr, cache) {
+  if (cache === void 0) {
+    cache = /* @__PURE__ */ new Map();
+  }
+  var r = [];
+  if (Array.isArray(arr)) {
+    for (var i = 0, len3 = arr.length; i < len3; i++) {
+      var item = arr[i];
+      if (!cache.has(item)) {
+        r.push(item);
+        cache.set(item, true);
+      }
+    }
+  }
+  return r;
+}
+var init_uniq = __esm({
+  "node_modules/@antv/util/esm/uniq.js"() {
+  }
+});
+
+// node_modules/@antv/util/esm/union.js
+var union, union_default;
+var init_union = __esm({
+  "node_modules/@antv/util/esm/union.js"() {
+    init_uniq();
+    union = function() {
+      var sources = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+      }
+      return uniq([].concat.apply([], sources));
+    };
+    union_default = union;
+  }
+});
+
+// node_modules/@antv/util/esm/values-of-key.js
+var values_of_key_default;
+var init_values_of_key = __esm({
+  "node_modules/@antv/util/esm/values-of-key.js"() {
+    init_is_array();
+    init_is_nil();
+    values_of_key_default = function(data, name) {
+      var rst = [];
+      var tmpMap = {};
+      for (var i = 0; i < data.length; i++) {
+        var obj = data[i];
+        var value = obj[name];
+        if (!is_nil_default(value)) {
+          if (!is_array_default(value)) {
+            value = [value];
+          }
+          for (var j = 0; j < value.length; j++) {
+            var val = value[j];
+            if (!tmpMap[val]) {
+              rst.push(val);
+              tmpMap[val] = true;
+            }
+          }
+        }
+      }
+      return rst;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/head.js
+function head(o) {
+  if (is_array_like_default(o)) {
+    return o[0];
+  }
+  return void 0;
+}
+var init_head = __esm({
+  "node_modules/@antv/util/esm/head.js"() {
+    init_is_array_like();
+  }
+});
+
+// node_modules/@antv/util/esm/last.js
+function last(o) {
+  if (is_array_like_default(o)) {
+    var arr = o;
+    return arr[arr.length - 1];
+  }
+  return void 0;
+}
+var init_last = __esm({
+  "node_modules/@antv/util/esm/last.js"() {
+    init_is_array_like();
+  }
+});
+
+// node_modules/@antv/util/esm/starts-with.js
+function startsWith(arr, e) {
+  return is_array_default(arr) || is_string_default(arr) ? arr[0] === e : false;
+}
+var starts_with_default;
+var init_starts_with = __esm({
+  "node_modules/@antv/util/esm/starts-with.js"() {
+    init_is_array();
+    init_is_string();
+    starts_with_default = startsWith;
+  }
+});
+
+// node_modules/@antv/util/esm/ends-with.js
+function endsWith(arr, e) {
+  return is_array_default(arr) || is_string_default(arr) ? arr[arr.length - 1] === e : false;
+}
+var ends_with_default;
+var init_ends_with = __esm({
+  "node_modules/@antv/util/esm/ends-with.js"() {
+    init_is_array();
+    init_is_string();
+    ends_with_default = endsWith;
+  }
+});
+
+// node_modules/@antv/util/esm/every.js
+var every, every_default;
+var init_every = __esm({
+  "node_modules/@antv/util/esm/every.js"() {
+    every = function(arr, func) {
+      for (var i = 0; i < arr.length; i++) {
+        if (!func(arr[i], i))
+          return false;
+      }
+      return true;
+    };
+    every_default = every;
+  }
+});
+
+// node_modules/@antv/util/esm/some.js
+var some, some_default;
+var init_some = __esm({
+  "node_modules/@antv/util/esm/some.js"() {
+    some = function(arr, func) {
+      for (var i = 0; i < arr.length; i++) {
+        if (func(arr[i], i))
+          return true;
+      }
+      return false;
+    };
+    some_default = some;
+  }
+});
+
+// node_modules/@antv/util/esm/group-by.js
+function groupBy(data, condition) {
+  if (!condition || !is_array_default(data)) {
+    return {};
+  }
+  var result = {};
+  var predicate = is_function_default(condition) ? condition : function(item2) {
+    return item2[condition];
+  };
+  var key;
+  for (var i = 0; i < data.length; i++) {
+    var item = data[i];
+    key = predicate(item);
+    if (hasOwnProperty.call(result, key)) {
+      result[key].push(item);
+    } else {
+      result[key] = [item];
+    }
+  }
+  return result;
+}
+var hasOwnProperty, group_by_default;
+var init_group_by = __esm({
+  "node_modules/@antv/util/esm/group-by.js"() {
+    init_is_array();
+    init_is_function();
+    hasOwnProperty = Object.prototype.hasOwnProperty;
+    group_by_default = groupBy;
+  }
+});
+
+// node_modules/@antv/util/esm/group-to-map.js
+function groupToMap(data, condition) {
+  if (!condition) {
+    return {
+      0: data
+    };
+  }
+  if (!is_function_default(condition)) {
+    var paramscondition_1 = is_array_default(condition) ? condition : condition.replace(/\s+/g, "").split("*");
+    condition = function(row) {
+      var unique = "_";
+      for (var i = 0, l = paramscondition_1.length; i < l; i++) {
+        unique += row[paramscondition_1[i]] && row[paramscondition_1[i]].toString();
+      }
+      return unique;
+    };
+  }
+  return group_by_default(data, condition);
+}
+var init_group_to_map = __esm({
+  "node_modules/@antv/util/esm/group-to-map.js"() {
+    init_is_array();
+    init_is_function();
+    init_group_by();
+  }
+});
+
+// node_modules/@antv/util/esm/group.js
+var group_default;
+var init_group = __esm({
+  "node_modules/@antv/util/esm/group.js"() {
+    init_group_to_map();
+    group_default = function(data, condition) {
+      if (!condition) {
+        return [data];
+      }
+      var groups = groupToMap(data, condition);
+      var array = [];
+      for (var i in groups) {
+        array.push(groups[i]);
+      }
+      return array;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/get-wrap-behavior.js
+function getWrapBehavior(obj, action) {
+  return obj["_wrap_" + action];
+}
+var get_wrap_behavior_default;
+var init_get_wrap_behavior = __esm({
+  "node_modules/@antv/util/esm/get-wrap-behavior.js"() {
+    get_wrap_behavior_default = getWrapBehavior;
+  }
+});
+
+// node_modules/@antv/util/esm/wrap-behavior.js
+function wrapBehavior(obj, action) {
+  if (obj["_wrap_" + action]) {
+    return obj["_wrap_" + action];
+  }
+  var method = function(e) {
+    obj[action](e);
+  };
+  obj["_wrap_" + action] = method;
+  return method;
+}
+var wrap_behavior_default;
+var init_wrap_behavior = __esm({
+  "node_modules/@antv/util/esm/wrap-behavior.js"() {
+    wrap_behavior_default = wrapBehavior;
+  }
+});
+
+// node_modules/@antv/util/esm/number2color.js
+function numberToColor(num) {
+  var color = numColorCache[num];
+  if (!color) {
+    var str4 = num.toString(16);
+    for (var i = str4.length; i < 6; i++) {
+      str4 = "0" + str4;
+    }
+    color = "#" + str4;
+    numColorCache[num] = color;
+  }
+  return color;
+}
+var numColorCache, number2color_default;
+var init_number2color = __esm({
+  "node_modules/@antv/util/esm/number2color.js"() {
+    numColorCache = {};
+    number2color_default = numberToColor;
+  }
+});
+
+// node_modules/@antv/util/esm/parse-radius.js
+function parseRadius(radius) {
+  var r1 = 0, r2 = 0, r3 = 0, r4 = 0;
+  if (is_array_default(radius)) {
+    if (radius.length === 1) {
+      r1 = r2 = r3 = r4 = radius[0];
+    } else if (radius.length === 2) {
+      r1 = r3 = radius[0];
+      r2 = r4 = radius[1];
+    } else if (radius.length === 3) {
+      r1 = radius[0];
+      r2 = r4 = radius[1];
+      r3 = radius[2];
+    } else {
+      r1 = radius[0];
+      r2 = radius[1];
+      r3 = radius[2];
+      r4 = radius[3];
+    }
+  } else {
+    r1 = r2 = r3 = r4 = radius;
+  }
+  return {
+    r1,
+    r2,
+    r3,
+    r4
+  };
+}
+var parse_radius_default;
+var init_parse_radius = __esm({
+  "node_modules/@antv/util/esm/parse-radius.js"() {
+    init_is_array();
+    parse_radius_default = parseRadius;
+  }
+});
+
+// node_modules/@antv/util/esm/clamp.js
+var clamp, clamp_default;
+var init_clamp = __esm({
+  "node_modules/@antv/util/esm/clamp.js"() {
+    clamp = function(a, min3, max3) {
+      if (a < min3) {
+        return min3;
+      } else if (a > max3) {
+        return max3;
+      }
+      return a;
+    };
+    clamp_default = clamp;
+  }
+});
+
+// node_modules/@antv/util/esm/fixed-base.js
+var fixedBase, fixed_base_default;
+var init_fixed_base = __esm({
+  "node_modules/@antv/util/esm/fixed-base.js"() {
+    fixedBase = function(v, base) {
+      var str4 = base.toString();
+      var index = str4.indexOf(".");
+      if (index === -1) {
+        return Math.round(v);
+      }
+      var length5 = str4.substr(index + 1).length;
+      if (length5 > 20) {
+        length5 = 20;
+      }
+      return parseFloat(v.toFixed(length5));
+    };
+    fixed_base_default = fixedBase;
+  }
+});
+
+// node_modules/@antv/util/esm/is-decimal.js
+var isDecimal, is_decimal_default;
+var init_is_decimal = __esm({
+  "node_modules/@antv/util/esm/is-decimal.js"() {
+    init_is_number();
+    isDecimal = function(num) {
+      return is_number_default(num) && num % 1 !== 0;
+    };
+    is_decimal_default = isDecimal;
+  }
+});
+
+// node_modules/@antv/util/esm/is-even.js
+var isEven, is_even_default;
+var init_is_even = __esm({
+  "node_modules/@antv/util/esm/is-even.js"() {
+    init_is_number();
+    isEven = function(num) {
+      return is_number_default(num) && num % 2 === 0;
+    };
+    is_even_default = isEven;
+  }
+});
+
+// node_modules/@antv/util/esm/is-integer.js
+var isInteger, is_integer_default;
+var init_is_integer = __esm({
+  "node_modules/@antv/util/esm/is-integer.js"() {
+    init_is_number();
+    isInteger = Number.isInteger ? Number.isInteger : function(num) {
+      return is_number_default(num) && num % 1 === 0;
+    };
+    is_integer_default = isInteger;
+  }
+});
+
+// node_modules/@antv/util/esm/is-negative.js
+var isNegative, is_negative_default;
+var init_is_negative = __esm({
+  "node_modules/@antv/util/esm/is-negative.js"() {
+    init_is_number();
+    isNegative = function(num) {
+      return is_number_default(num) && num < 0;
+    };
+    is_negative_default = isNegative;
+  }
+});
+
+// node_modules/@antv/util/esm/is-number-equal.js
+function isNumberEqual(a, b, precision) {
+  if (precision === void 0) {
+    precision = PRECISION;
+  }
+  return Math.abs(a - b) < precision;
+}
+var PRECISION;
+var init_is_number_equal = __esm({
+  "node_modules/@antv/util/esm/is-number-equal.js"() {
+    PRECISION = 1e-5;
+  }
+});
+
+// node_modules/@antv/util/esm/is-odd.js
+var isOdd, is_odd_default;
+var init_is_odd = __esm({
+  "node_modules/@antv/util/esm/is-odd.js"() {
+    init_is_number();
+    isOdd = function(num) {
+      return is_number_default(num) && num % 2 !== 0;
+    };
+    is_odd_default = isOdd;
+  }
+});
+
+// node_modules/@antv/util/esm/is-positive.js
+var isPositive, is_positive_default;
+var init_is_positive = __esm({
+  "node_modules/@antv/util/esm/is-positive.js"() {
+    init_is_number();
+    isPositive = function(num) {
+      return is_number_default(num) && num > 0;
+    };
+    is_positive_default = isPositive;
+  }
+});
+
+// node_modules/@antv/util/esm/max-by.js
+var max_by_default;
+var init_max_by = __esm({
+  "node_modules/@antv/util/esm/max-by.js"() {
+    init_is_array();
+    init_is_function();
+    max_by_default = function(arr, fn) {
+      if (!is_array_default(arr)) {
+        return void 0;
+      }
+      var maxItem;
+      var max3 = -Infinity;
+      for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        var v = is_function_default(fn) ? fn(item) : item[fn];
+        if (v > max3) {
+          maxItem = item;
+          max3 = v;
+        }
+      }
+      return maxItem;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/min-by.js
+var min_by_default;
+var init_min_by = __esm({
+  "node_modules/@antv/util/esm/min-by.js"() {
+    init_is_array();
+    init_is_function();
+    min_by_default = function(arr, fn) {
+      if (!is_array_default(arr)) {
+        return void 0;
+      }
+      var minItem;
+      var min3 = Infinity;
+      for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        var v = is_function_default(fn) ? fn(item) : item[fn];
+        if (v < min3) {
+          minItem = item;
+          min3 = v;
+        }
+      }
+      return minItem;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/mod.js
+var mod, mod_default;
+var init_mod = __esm({
+  "node_modules/@antv/util/esm/mod.js"() {
+    mod = function(n, m) {
+      return (n % m + m) % m;
+    };
+    mod_default = mod;
+  }
+});
+
+// node_modules/@antv/util/esm/to-degree.js
+var DEGREE, toDegree, to_degree_default;
+var init_to_degree = __esm({
+  "node_modules/@antv/util/esm/to-degree.js"() {
+    DEGREE = 180 / Math.PI;
+    toDegree = function(radian) {
+      return DEGREE * radian;
+    };
+    to_degree_default = toDegree;
+  }
+});
+
+// node_modules/@antv/util/esm/to-integer.js
+var to_integer_default;
+var init_to_integer = __esm({
+  "node_modules/@antv/util/esm/to-integer.js"() {
+    to_integer_default = parseInt;
+  }
+});
+
+// node_modules/@antv/util/esm/to-radian.js
+var RADIAN, toRadian, to_radian_default;
+var init_to_radian = __esm({
+  "node_modules/@antv/util/esm/to-radian.js"() {
+    RADIAN = Math.PI / 180;
+    toRadian = function(degree2) {
+      return RADIAN * degree2;
+    };
+    to_radian_default = toRadian;
+  }
+});
+
+// node_modules/@antv/util/esm/for-in.js
+var for_in_default;
+var init_for_in = __esm({
+  "node_modules/@antv/util/esm/for-in.js"() {
+    init_each();
+    for_in_default = each_default;
+  }
+});
+
+// node_modules/@antv/util/esm/has.js
+var has_default;
+var init_has = __esm({
+  "node_modules/@antv/util/esm/has.js"() {
+    has_default = function(obj, key) {
+      return obj.hasOwnProperty(key);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/has-key.js
+var has_key_default;
+var init_has_key = __esm({
+  "node_modules/@antv/util/esm/has-key.js"() {
+    init_has();
+    has_key_default = has_default;
+  }
+});
+
+// node_modules/@antv/util/esm/has-value.js
+var has_value_default;
+var init_has_value = __esm({
+  "node_modules/@antv/util/esm/has-value.js"() {
+    init_contains();
+    init_values();
+    has_value_default = function(obj, value) {
+      return contains_default(values_default(obj), value);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/to-string.js
+var to_string_default;
+var init_to_string = __esm({
+  "node_modules/@antv/util/esm/to-string.js"() {
+    init_is_nil();
+    to_string_default = function(value) {
+      if (is_nil_default(value))
+        return "";
+      return value.toString();
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/lower-case.js
+var lowerCase, lower_case_default;
+var init_lower_case = __esm({
+  "node_modules/@antv/util/esm/lower-case.js"() {
+    init_to_string();
+    lowerCase = function(str4) {
+      return to_string_default(str4).toLowerCase();
+    };
+    lower_case_default = lowerCase;
+  }
+});
+
+// node_modules/@antv/util/esm/lower-first.js
+var lowerFirst, lower_first_default;
+var init_lower_first = __esm({
+  "node_modules/@antv/util/esm/lower-first.js"() {
+    init_to_string();
+    lowerFirst = function(value) {
+      var str4 = to_string_default(value);
+      return str4.charAt(0).toLowerCase() + str4.substring(1);
+    };
+    lower_first_default = lowerFirst;
+  }
+});
+
+// node_modules/@antv/util/esm/substitute.js
+function substitute(str4, o) {
+  if (!str4 || !o) {
+    return str4;
+  }
+  return str4.replace(/\\?\{([^{}]+)\}/g, function(match, name) {
+    if (match.charAt(0) === "\\") {
+      return match.slice(1);
+    }
+    return o[name] === void 0 ? "" : o[name];
+  });
+}
+var substitute_default;
+var init_substitute = __esm({
+  "node_modules/@antv/util/esm/substitute.js"() {
+    substitute_default = substitute;
+  }
+});
+
+// node_modules/@antv/util/esm/upper-case.js
+var upperCase, upper_case_default;
+var init_upper_case = __esm({
+  "node_modules/@antv/util/esm/upper-case.js"() {
+    init_to_string();
+    upperCase = function(str4) {
+      return to_string_default(str4).toUpperCase();
+    };
+    upper_case_default = upperCase;
+  }
+});
+
+// node_modules/@antv/util/esm/upper-first.js
+var upperFirst, upper_first_default;
+var init_upper_first = __esm({
+  "node_modules/@antv/util/esm/upper-first.js"() {
+    init_to_string();
+    upperFirst = function(value) {
+      var str4 = to_string_default(value);
+      return str4.charAt(0).toUpperCase() + str4.substring(1);
+    };
+    upper_first_default = upperFirst;
+  }
+});
+
+// node_modules/@antv/util/esm/get-type.js
+var toString2, getType, get_type_default;
+var init_get_type = __esm({
+  "node_modules/@antv/util/esm/get-type.js"() {
+    toString2 = {}.toString;
+    getType = function(value) {
+      return toString2.call(value).replace(/^\[object /, "").replace(/]$/, "");
+    };
+    get_type_default = getType;
+  }
+});
+
+// node_modules/@antv/util/esm/is-arguments.js
+var isArguments, is_arguments_default;
+var init_is_arguments = __esm({
+  "node_modules/@antv/util/esm/is-arguments.js"() {
+    init_is_type();
+    isArguments = function(value) {
+      return is_type_default(value, "Arguments");
+    };
+    is_arguments_default = isArguments;
+  }
+});
+
+// node_modules/@antv/util/esm/is-boolean.js
+var isBoolean, is_boolean_default;
+var init_is_boolean = __esm({
+  "node_modules/@antv/util/esm/is-boolean.js"() {
+    init_is_type();
+    isBoolean = function(value) {
+      return is_type_default(value, "Boolean");
+    };
+    is_boolean_default = isBoolean;
+  }
+});
+
+// node_modules/@antv/util/esm/is-date.js
+var isDate, is_date_default;
+var init_is_date = __esm({
+  "node_modules/@antv/util/esm/is-date.js"() {
+    init_is_type();
+    isDate = function(value) {
+      return is_type_default(value, "Date");
+    };
+    is_date_default = isDate;
+  }
+});
+
+// node_modules/@antv/util/esm/is-error.js
+var isError, is_error_default;
+var init_is_error = __esm({
+  "node_modules/@antv/util/esm/is-error.js"() {
+    init_is_type();
+    isError = function(value) {
+      return is_type_default(value, "Error");
+    };
+    is_error_default = isError;
+  }
+});
+
+// node_modules/@antv/util/esm/is-finite.js
+function is_finite_default(value) {
+  return is_number_default(value) && isFinite(value);
+}
+var init_is_finite = __esm({
+  "node_modules/@antv/util/esm/is-finite.js"() {
+    init_is_number();
+  }
+});
+
+// node_modules/@antv/util/esm/is-null.js
+var isNull, is_null_default;
+var init_is_null = __esm({
+  "node_modules/@antv/util/esm/is-null.js"() {
+    isNull = function(value) {
+      return value === null;
+    };
+    is_null_default = isNull;
+  }
+});
+
+// node_modules/@antv/util/esm/is-prototype.js
+var objectProto, isPrototype, is_prototype_default;
+var init_is_prototype = __esm({
+  "node_modules/@antv/util/esm/is-prototype.js"() {
+    objectProto = Object.prototype;
+    isPrototype = function(value) {
+      var Ctor = value && value.constructor;
+      var proto = typeof Ctor === "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    };
+    is_prototype_default = isPrototype;
+  }
+});
+
+// node_modules/@antv/util/esm/is-reg-exp.js
+var isRegExp, is_reg_exp_default;
+var init_is_reg_exp = __esm({
+  "node_modules/@antv/util/esm/is-reg-exp.js"() {
+    init_is_type();
+    isRegExp = function(str4) {
+      return is_type_default(str4, "RegExp");
+    };
+    is_reg_exp_default = isRegExp;
+  }
+});
+
+// node_modules/@antv/util/esm/is-undefined.js
+var isUndefined, is_undefined_default;
+var init_is_undefined = __esm({
+  "node_modules/@antv/util/esm/is-undefined.js"() {
+    isUndefined = function(value) {
+      return value === void 0;
+    };
+    is_undefined_default = isUndefined;
+  }
+});
+
+// node_modules/@antv/util/esm/is-element.js
+var isElement, is_element_default;
+var init_is_element = __esm({
+  "node_modules/@antv/util/esm/is-element.js"() {
+    isElement = function(o) {
+      return o instanceof Element || o instanceof HTMLDocument;
+    };
+    is_element_default = isElement;
+  }
+});
+
+// node_modules/@antv/util/esm/request-animation-frame.js
+function requestAnimationFrame(fn) {
+  var method = window.requestAnimationFrame || window.webkitRequestAnimationFrame || // @ts-ignore
+  window.mozRequestAnimationFrame || // @ts-ignore
+  window.msRequestAnimationFrame || function(f) {
+    return setTimeout(f, 16);
+  };
+  return method(fn);
+}
+var init_request_animation_frame = __esm({
+  "node_modules/@antv/util/esm/request-animation-frame.js"() {
+  }
+});
+
+// node_modules/@antv/util/esm/clear-animation-frame.js
+function cancelAnimationFrame(handler) {
+  var method = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || // @ts-ignore
+  window.mozCancelAnimationFrame || // @ts-ignore
+  window.msCancelAnimationFrame || clearTimeout;
+  method(handler);
+}
+var init_clear_animation_frame = __esm({
+  "node_modules/@antv/util/esm/clear-animation-frame.js"() {
+  }
+});
+
+// node_modules/@antv/util/esm/augment.js
+var augment, augment_default;
+var init_augment = __esm({
+  "node_modules/@antv/util/esm/augment.js"() {
+    init_mix();
+    init_is_function();
+    augment = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      var c = args[0];
+      for (var i = 1; i < args.length; i++) {
+        var obj = args[i];
+        if (is_function_default(obj)) {
+          obj = obj.prototype;
+        }
+        mix(c.prototype, obj);
+      }
+    };
+    augment_default = augment;
+  }
+});
+
+// node_modules/@antv/util/esm/clone.js
+var clone, clone_default;
+var init_clone = __esm({
+  "node_modules/@antv/util/esm/clone.js"() {
+    init_is_array();
+    clone = function(obj) {
+      if (typeof obj !== "object" || obj === null) {
+        return obj;
+      }
+      var rst;
+      if (is_array_default(obj)) {
+        rst = [];
+        for (var i = 0, l = obj.length; i < l; i++) {
+          if (typeof obj[i] === "object" && obj[i] != null) {
+            rst[i] = clone(obj[i]);
+          } else {
+            rst[i] = obj[i];
+          }
+        }
+      } else {
+        rst = {};
+        for (var k in obj) {
+          if (typeof obj[k] === "object" && obj[k] != null) {
+            rst[k] = clone(obj[k]);
+          } else {
+            rst[k] = obj[k];
+          }
+        }
+      }
+      return rst;
+    };
+    clone_default = clone;
+  }
+});
+
+// node_modules/@antv/util/esm/debounce.js
+function debounce(func, wait, immediate) {
+  var timeout;
+  return function() {
+    var context = this, args = arguments;
+    var later = function() {
+      timeout = null;
+      if (!immediate) {
+        func.apply(context, args);
+      }
+    };
+    var callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow) {
+      func.apply(context, args);
+    }
+  };
+}
+var debounce_default;
+var init_debounce = __esm({
+  "node_modules/@antv/util/esm/debounce.js"() {
+    debounce_default = debounce;
+  }
+});
+
+// node_modules/@antv/util/esm/extend.js
+var extend, extend_default;
+var init_extend = __esm({
+  "node_modules/@antv/util/esm/extend.js"() {
+    init_mix();
+    init_is_function();
+    extend = function(subclass, superclass, overrides, staticOverrides) {
+      if (!is_function_default(superclass)) {
+        overrides = superclass;
+        superclass = subclass;
+        subclass = function() {
+        };
+      }
+      var create6 = Object.create ? function(proto, c) {
+        return Object.create(proto, {
+          constructor: {
+            value: c
+          }
+        });
+      } : function(proto, c) {
+        function Tmp() {
+        }
+        Tmp.prototype = proto;
+        var o = new Tmp();
+        o.constructor = c;
+        return o;
+      };
+      var superObj = create6(superclass.prototype, subclass);
+      subclass.prototype = mix(superObj, subclass.prototype);
+      subclass.superclass = create6(superclass.prototype, superclass);
+      mix(superObj, overrides);
+      mix(subclass, staticOverrides);
+      return subclass;
+    };
+    extend_default = extend;
+  }
+});
+
+// node_modules/@antv/util/esm/index-of.js
+var indexOf2, index_of_default;
+var init_index_of = __esm({
+  "node_modules/@antv/util/esm/index-of.js"() {
+    init_is_array_like();
+    indexOf2 = function(arr, obj) {
+      if (!is_array_like_default(arr)) {
+        return -1;
+      }
+      var m = Array.prototype.indexOf;
+      if (m) {
+        return m.call(arr, obj);
+      }
+      var index = -1;
+      for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === obj) {
+          index = i;
+          break;
+        }
+      }
+      return index;
+    };
+    index_of_default = indexOf2;
+  }
+});
+
+// node_modules/@antv/util/esm/is-empty.js
+function isEmpty(value) {
+  if (is_nil_default(value)) {
+    return true;
+  }
+  if (is_array_like_default(value)) {
+    return !value.length;
+  }
+  var type = get_type_default(value);
+  if (type === "Map" || type === "Set") {
+    return !value.size;
+  }
+  if (is_prototype_default(value)) {
+    return !Object.keys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty2.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+var hasOwnProperty2, is_empty_default;
+var init_is_empty = __esm({
+  "node_modules/@antv/util/esm/is-empty.js"() {
+    init_is_nil();
+    init_is_array_like();
+    init_get_type();
+    init_is_prototype();
+    hasOwnProperty2 = Object.prototype.hasOwnProperty;
+    is_empty_default = isEmpty;
+  }
+});
+
+// node_modules/@antv/util/esm/is-equal.js
+var isEqual, is_equal_default;
+var init_is_equal = __esm({
+  "node_modules/@antv/util/esm/is-equal.js"() {
+    init_is_object_like();
+    init_is_array_like();
+    init_is_string();
+    isEqual = function(value, other) {
+      if (value === other) {
+        return true;
+      }
+      if (!value || !other) {
+        return false;
+      }
+      if (is_string_default(value) || is_string_default(other)) {
+        return false;
+      }
+      if (is_array_like_default(value) || is_array_like_default(other)) {
+        if (value.length !== other.length) {
+          return false;
+        }
+        var rst = true;
+        for (var i = 0; i < value.length; i++) {
+          rst = isEqual(value[i], other[i]);
+          if (!rst) {
+            break;
+          }
+        }
+        return rst;
+      }
+      if (is_object_like_default(value) || is_object_like_default(other)) {
+        var valueKeys = Object.keys(value);
+        var otherKeys = Object.keys(other);
+        if (valueKeys.length !== otherKeys.length) {
+          return false;
+        }
+        var rst = true;
+        for (var i = 0; i < valueKeys.length; i++) {
+          rst = isEqual(value[valueKeys[i]], other[valueKeys[i]]);
+          if (!rst) {
+            break;
+          }
+        }
+        return rst;
+      }
+      return false;
+    };
+    is_equal_default = isEqual;
+  }
+});
+
+// node_modules/@antv/util/esm/is-equal-with.js
+var is_equal_with_default;
+var init_is_equal_with = __esm({
+  "node_modules/@antv/util/esm/is-equal-with.js"() {
+    init_is_function();
+    init_is_equal();
+    is_equal_with_default = function(value, other, fn) {
+      if (!is_function_default(fn)) {
+        return is_equal_default(value, other);
+      }
+      return !!fn(value, other);
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/map.js
+var map, map_default;
+var init_map = __esm({
+  "node_modules/@antv/util/esm/map.js"() {
+    init_is_array_like();
+    map = function(arr, func) {
+      if (!is_array_like_default(arr)) {
+        return arr;
+      }
+      var result = [];
+      for (var index = 0; index < arr.length; index++) {
+        var value = arr[index];
+        result.push(func(value, index));
+      }
+      return result;
+    };
+    map_default = map;
+  }
+});
+
+// node_modules/@antv/util/esm/map-values.js
+var identity, map_values_default;
+var init_map_values = __esm({
+  "node_modules/@antv/util/esm/map-values.js"() {
+    init_is_nil();
+    init_is_object();
+    identity = function(v) {
+      return v;
+    };
+    map_values_default = function(object, func) {
+      if (func === void 0) {
+        func = identity;
+      }
+      var r = {};
+      if (is_object_default(object) && !is_nil_default(object)) {
+        Object.keys(object).forEach(function(key) {
+          r[key] = func(object[key], key);
+        });
+      }
+      return r;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/set.js
+var set_default;
+var init_set = __esm({
+  "node_modules/@antv/util/esm/set.js"() {
+    init_is_object();
+    init_is_string();
+    init_is_number();
+    set_default = function(obj, path, value) {
+      var o = obj;
+      var keyArr = is_string_default(path) ? path.split(".") : path;
+      keyArr.forEach(function(key, idx) {
+        if (idx < keyArr.length - 1) {
+          if (!is_object_default(o[key])) {
+            o[key] = is_number_default(keyArr[idx + 1]) ? [] : {};
+          }
+          o = o[key];
+        } else {
+          o[key] = value;
+        }
+      });
+      return obj;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/pick.js
+var hasOwnProperty3, pick_default;
+var init_pick = __esm({
+  "node_modules/@antv/util/esm/pick.js"() {
+    init_each();
+    init_is_plain_object();
+    hasOwnProperty3 = Object.prototype.hasOwnProperty;
+    pick_default = function(object, keys2) {
+      if (object === null || !is_plain_object_default(object)) {
+        return {};
+      }
+      var result = {};
+      each_default(keys2, function(key) {
+        if (hasOwnProperty3.call(object, key)) {
+          result[key] = object[key];
+        }
+      });
+      return result;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/omit.js
+var omit_default;
+var init_omit = __esm({
+  "node_modules/@antv/util/esm/omit.js"() {
+    init_reduce();
+    omit_default = function(obj, keys2) {
+      return reduce_default(obj, function(r, curr, key) {
+        if (!keys2.includes(key)) {
+          r[key] = curr;
+        }
+        return r;
+      }, {});
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/throttle.js
+var throttle_default;
+var init_throttle = __esm({
+  "node_modules/@antv/util/esm/throttle.js"() {
+    throttle_default = function(func, wait, options) {
+      var timeout, context, args, result;
+      var previous = 0;
+      if (!options)
+        options = {};
+      var later = function() {
+        previous = options.leading === false ? 0 : Date.now();
+        timeout = null;
+        result = func.apply(context, args);
+        if (!timeout)
+          context = args = null;
+      };
+      var throttled = function() {
+        var now = Date.now();
+        if (!previous && options.leading === false)
+          previous = now;
+        var remaining = wait - (now - previous);
+        context = this;
+        args = arguments;
+        if (remaining <= 0 || remaining > wait) {
+          if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
+          }
+          previous = now;
+          result = func.apply(context, args);
+          if (!timeout)
+            context = args = null;
+        } else if (!timeout && options.trailing !== false) {
+          timeout = setTimeout(later, remaining);
+        }
+        return result;
+      };
+      throttled.cancel = function() {
+        clearTimeout(timeout);
+        previous = 0;
+        timeout = context = args = null;
+      };
+      return throttled;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/to-array.js
+var to_array_default;
+var init_to_array = __esm({
+  "node_modules/@antv/util/esm/to-array.js"() {
+    init_is_array_like();
+    to_array_default = function(value) {
+      return is_array_like_default(value) ? Array.prototype.slice.call(value) : [];
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/unique-id.js
+var map2, unique_id_default;
+var init_unique_id = __esm({
+  "node_modules/@antv/util/esm/unique-id.js"() {
+    map2 = {};
+    unique_id_default = function(prefix) {
+      prefix = prefix || "g";
+      if (!map2[prefix]) {
+        map2[prefix] = 1;
+      } else {
+        map2[prefix] += 1;
+      }
+      return prefix + map2[prefix];
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/noop.js
+var noop_default;
+var init_noop = __esm({
+  "node_modules/@antv/util/esm/noop.js"() {
+    noop_default = function() {
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/identity.js
+var identity_default;
+var init_identity = __esm({
+  "node_modules/@antv/util/esm/identity.js"() {
+    identity_default = function(v) {
+      return v;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/size.js
+function size(o) {
+  if (is_nil_default(o)) {
+    return 0;
+  }
+  if (is_array_like_default(o)) {
+    return o.length;
+  }
+  return Object.keys(o).length;
+}
+var init_size = __esm({
+  "node_modules/@antv/util/esm/size.js"() {
+    init_is_nil();
+    init_is_array_like();
+  }
+});
+
+// node_modules/@antv/util/esm/measure-text-width.js
+var ctx, measure_text_width_default;
+var init_measure_text_width = __esm({
+  "node_modules/@antv/util/esm/measure-text-width.js"() {
+    init_tslib_es6();
+    init_values();
+    init_memoize();
+    init_is_string();
+    measure_text_width_default = memoize_default(function(text, font) {
+      if (font === void 0) {
+        font = {};
+      }
+      var fontSize = font.fontSize, fontFamily = font.fontFamily, fontWeight = font.fontWeight, fontStyle = font.fontStyle, fontVariant = font.fontVariant;
+      if (!ctx) {
+        ctx = document.createElement("canvas").getContext("2d");
+      }
+      ctx.font = [fontStyle, fontVariant, fontWeight, fontSize + "px", fontFamily].join(" ");
+      return ctx.measureText(is_string_default(text) ? text : "").width;
+    }, function(text, font) {
+      if (font === void 0) {
+        font = {};
+      }
+      return __spreadArrays([text], values_default(font)).join("");
+    });
+  }
+});
+
+// node_modules/@antv/util/esm/get-ellipsis-text.js
+var get_ellipsis_text_default;
+var init_get_ellipsis_text = __esm({
+  "node_modules/@antv/util/esm/get-ellipsis-text.js"() {
+    init_is_string();
+    init_to_string();
+    init_measure_text_width();
+    get_ellipsis_text_default = function(text, maxWidth, font, str4) {
+      if (str4 === void 0) {
+        str4 = "...";
+      }
+      var STEP = 16;
+      var PLACEHOLDER_WIDTH = measure_text_width_default(str4, font);
+      var leftText = !is_string_default(text) ? to_string_default(text) : text;
+      var leftWidth = maxWidth;
+      var r = [];
+      var currentText;
+      var currentWidth;
+      if (measure_text_width_default(text, font) <= maxWidth) {
+        return text;
+      }
+      while (true) {
+        currentText = leftText.substr(0, STEP);
+        currentWidth = measure_text_width_default(currentText, font);
+        if (currentWidth + PLACEHOLDER_WIDTH > leftWidth) {
+          if (currentWidth > leftWidth) {
+            break;
+          }
+        }
+        r.push(currentText);
+        leftWidth -= currentWidth;
+        leftText = leftText.substr(STEP);
+        if (!leftText) {
+          return r.join("");
+        }
+      }
+      while (true) {
+        currentText = leftText.substr(0, 1);
+        currentWidth = measure_text_width_default(currentText, font);
+        if (currentWidth + PLACEHOLDER_WIDTH > leftWidth) {
+          break;
+        }
+        r.push(currentText);
+        leftWidth -= currentWidth;
+        leftText = leftText.substr(1);
+        if (!leftText) {
+          return r.join("");
+        }
+      }
+      return "" + r.join("") + str4;
+    };
+  }
+});
+
+// node_modules/@antv/util/esm/cache.js
+var default_1, cache_default;
+var init_cache = __esm({
+  "node_modules/@antv/util/esm/cache.js"() {
+    default_1 = /** @class */
+    function() {
+      function default_12() {
+        this.map = {};
+      }
+      default_12.prototype.has = function(key) {
+        return this.map[key] !== void 0;
+      };
+      default_12.prototype.get = function(key, def) {
+        var v = this.map[key];
+        return v === void 0 ? def : v;
+      };
+      default_12.prototype.set = function(key, value) {
+        this.map[key] = value;
+      };
+      default_12.prototype.clear = function() {
+        this.map = {};
+      };
+      default_12.prototype.delete = function(key) {
+        delete this.map[key];
+      };
+      default_12.prototype.size = function() {
+        return Object.keys(this.map).length;
+      };
+      return default_12;
+    }();
+    cache_default = default_1;
+  }
+});
+
+// node_modules/@antv/util/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  Cache: () => cache_default,
+  assign: () => mix,
+  augment: () => augment_default,
+  clamp: () => clamp_default,
+  clearAnimationFrame: () => cancelAnimationFrame,
+  clone: () => clone_default,
+  contains: () => contains_default,
+  debounce: () => debounce_default,
+  deepMix: () => deep_mix_default,
+  difference: () => difference_default,
+  each: () => each_default,
+  endsWith: () => ends_with_default,
+  every: () => every_default,
+  extend: () => extend_default,
+  filter: () => filter_default,
+  find: () => find_default,
+  findIndex: () => find_index_default,
+  firstValue: () => first_value_default,
+  fixedBase: () => fixed_base_default,
+  flatten: () => flatten_default,
+  flattenDeep: () => flatten_deep_default,
+  forIn: () => for_in_default,
+  get: () => get_default,
+  getEllipsisText: () => get_ellipsis_text_default,
+  getRange: () => get_range_default,
+  getType: () => get_type_default,
+  getWrapBehavior: () => get_wrap_behavior_default,
+  group: () => group_default,
+  groupBy: () => group_by_default,
+  groupToMap: () => groupToMap,
+  has: () => has_default,
+  hasKey: () => has_key_default,
+  hasValue: () => has_value_default,
+  head: () => head,
+  identity: () => identity_default,
+  includes: () => contains_default,
+  indexOf: () => index_of_default,
+  isArguments: () => is_arguments_default,
+  isArray: () => is_array_default,
+  isArrayLike: () => is_array_like_default,
+  isBoolean: () => is_boolean_default,
+  isDate: () => is_date_default,
+  isDecimal: () => is_decimal_default,
+  isElement: () => is_element_default,
+  isEmpty: () => is_empty_default,
+  isEqual: () => is_equal_default,
+  isEqualWith: () => is_equal_with_default,
+  isError: () => is_error_default,
+  isEven: () => is_even_default,
+  isFinite: () => is_finite_default,
+  isFunction: () => is_function_default,
+  isInteger: () => is_integer_default,
+  isMatch: () => is_match_default,
+  isNegative: () => is_negative_default,
+  isNil: () => is_nil_default,
+  isNull: () => is_null_default,
+  isNumber: () => is_number_default,
+  isNumberEqual: () => isNumberEqual,
+  isObject: () => is_object_default,
+  isObjectLike: () => is_object_like_default,
+  isOdd: () => is_odd_default,
+  isPlainObject: () => is_plain_object_default,
+  isPositive: () => is_positive_default,
+  isPrototype: () => is_prototype_default,
+  isRegExp: () => is_reg_exp_default,
+  isString: () => is_string_default,
+  isType: () => is_type_default,
+  isUndefined: () => is_undefined_default,
+  keys: () => keys_default,
+  last: () => last,
+  lowerCase: () => lower_case_default,
+  lowerFirst: () => lower_first_default,
+  map: () => map_default,
+  mapValues: () => map_values_default,
+  max: () => max_default,
+  maxBy: () => max_by_default,
+  measureTextWidth: () => measure_text_width_default,
+  memoize: () => memoize_default,
+  min: () => min_default,
+  minBy: () => min_by_default,
+  mix: () => mix,
+  mod: () => mod_default,
+  noop: () => noop_default,
+  number2color: () => number2color_default,
+  omit: () => omit_default,
+  parseRadius: () => parse_radius_default,
+  pick: () => pick_default,
+  pull: () => pull_default,
+  pullAt: () => pull_at_default,
+  reduce: () => reduce_default,
+  remove: () => remove_default,
+  requestAnimationFrame: () => requestAnimationFrame,
+  set: () => set_default,
+  size: () => size,
+  some: () => some_default,
+  sortBy: () => sort_by_default,
+  startsWith: () => starts_with_default,
+  substitute: () => substitute_default,
+  throttle: () => throttle_default,
+  toArray: () => to_array_default,
+  toDegree: () => to_degree_default,
+  toInteger: () => to_integer_default,
+  toRadian: () => to_radian_default,
+  toString: () => to_string_default,
+  union: () => union_default,
+  uniq: () => uniq,
+  uniqueId: () => unique_id_default,
+  upperCase: () => upper_case_default,
+  upperFirst: () => upper_first_default,
+  values: () => values_default,
+  valuesOfKey: () => values_of_key_default,
+  wrapBehavior: () => wrap_behavior_default
+});
+var init_esm = __esm({
+  "node_modules/@antv/util/esm/index.js"() {
+    init_contains();
+    init_difference();
+    init_find();
+    init_find_index();
+    init_first_value();
+    init_flatten();
+    init_flatten_deep();
+    init_get_range();
+    init_pull();
+    init_pull_at();
+    init_reduce();
+    init_remove();
+    init_sort_by();
+    init_union();
+    init_uniq();
+    init_values_of_key();
+    init_head();
+    init_last();
+    init_starts_with();
+    init_ends_with();
+    init_filter();
+    init_every();
+    init_some();
+    init_group();
+    init_group_by();
+    init_group_to_map();
+    init_get_wrap_behavior();
+    init_wrap_behavior();
+    init_number2color();
+    init_parse_radius();
+    init_clamp();
+    init_fixed_base();
+    init_is_decimal();
+    init_is_even();
+    init_is_integer();
+    init_is_negative();
+    init_is_number_equal();
+    init_is_odd();
+    init_is_positive();
+    init_max();
+    init_max_by();
+    init_min();
+    init_min_by();
+    init_mod();
+    init_to_degree();
+    init_to_integer();
+    init_to_radian();
+    init_for_in();
+    init_has();
+    init_has_key();
+    init_has_value();
+    init_keys();
+    init_is_match();
+    init_values();
+    init_lower_case();
+    init_lower_first();
+    init_substitute();
+    init_upper_case();
+    init_upper_first();
+    init_get_type();
+    init_is_arguments();
+    init_is_array();
+    init_is_array_like();
+    init_is_boolean();
+    init_is_date();
+    init_is_error();
+    init_is_function();
+    init_is_finite();
+    init_is_nil();
+    init_is_null();
+    init_is_number();
+    init_is_object();
+    init_is_object_like();
+    init_is_plain_object();
+    init_is_prototype();
+    init_is_reg_exp();
+    init_is_string();
+    init_is_type();
+    init_is_undefined();
+    init_is_element();
+    init_request_animation_frame();
+    init_clear_animation_frame();
+    init_augment();
+    init_clone();
+    init_debounce();
+    init_memoize();
+    init_deep_mix();
+    init_each();
+    init_extend();
+    init_index_of();
+    init_is_empty();
+    init_is_equal();
+    init_is_equal_with();
+    init_map();
+    init_map_values();
+    init_mix();
+    init_get();
+    init_set();
+    init_pick();
+    init_omit();
+    init_throttle();
+    init_to_array();
+    init_to_string();
+    init_unique_id();
+    init_noop();
+    init_identity();
+    init_size();
+    init_measure_text_width();
+    init_get_ellipsis_text();
+    init_cache();
+  }
+});
+
+// node_modules/gl-matrix/esm/common.js
+var EPSILON, ARRAY_TYPE, RANDOM, degree;
+var init_common = __esm({
+  "node_modules/gl-matrix/esm/common.js"() {
+    EPSILON = 1e-6;
+    ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+    RANDOM = Math.random;
+    degree = Math.PI / 180;
+    if (!Math.hypot)
+      Math.hypot = function() {
+        var y = 0, i = arguments.length;
+        while (i--) {
+          y += arguments[i] * arguments[i];
+        }
+        return Math.sqrt(y);
+      };
+  }
+});
+
+// node_modules/gl-matrix/esm/mat2.js
+var init_mat2 = __esm({
+  "node_modules/gl-matrix/esm/mat2.js"() {
+    init_common();
+  }
+});
+
+// node_modules/gl-matrix/esm/mat2d.js
+var init_mat2d = __esm({
+  "node_modules/gl-matrix/esm/mat2d.js"() {
+    init_common();
+  }
+});
+
+// node_modules/gl-matrix/esm/mat3.js
+var mat3_exports = {};
+__export(mat3_exports, {
+  add: () => add,
+  adjoint: () => adjoint,
+  clone: () => clone2,
+  copy: () => copy,
+  create: () => create,
+  determinant: () => determinant,
+  equals: () => equals,
+  exactEquals: () => exactEquals,
+  frob: () => frob,
+  fromMat2d: () => fromMat2d,
+  fromMat4: () => fromMat4,
+  fromQuat: () => fromQuat,
+  fromRotation: () => fromRotation,
+  fromScaling: () => fromScaling,
+  fromTranslation: () => fromTranslation,
+  fromValues: () => fromValues,
+  identity: () => identity2,
+  invert: () => invert,
+  mul: () => mul,
+  multiply: () => multiply,
+  multiplyScalar: () => multiplyScalar,
+  multiplyScalarAndAdd: () => multiplyScalarAndAdd,
+  normalFromMat4: () => normalFromMat4,
+  projection: () => projection,
+  rotate: () => rotate,
+  scale: () => scale,
+  set: () => set,
+  str: () => str,
+  sub: () => sub,
+  subtract: () => subtract,
+  translate: () => translate,
+  transpose: () => transpose
+});
+function create() {
+  var out = new ARRAY_TYPE(9);
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+  }
+  out[0] = 1;
+  out[4] = 1;
+  out[8] = 1;
+  return out;
+}
+function fromMat4(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[4];
+  out[4] = a[5];
+  out[5] = a[6];
+  out[6] = a[8];
+  out[7] = a[9];
+  out[8] = a[10];
+  return out;
+}
+function clone2(a) {
+  var out = new ARRAY_TYPE(9);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  return out;
+}
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  return out;
+}
+function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+  var out = new ARRAY_TYPE(9);
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m10;
+  out[4] = m11;
+  out[5] = m12;
+  out[6] = m20;
+  out[7] = m21;
+  out[8] = m22;
+  return out;
+}
+function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m10;
+  out[4] = m11;
+  out[5] = m12;
+  out[6] = m20;
+  out[7] = m21;
+  out[8] = m22;
+  return out;
+}
+function identity2(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 1;
+  out[5] = 0;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 1;
+  return out;
+}
+function transpose(out, a) {
+  if (out === a) {
+    var a01 = a[1], a02 = a[2], a12 = a[5];
+    out[1] = a[3];
+    out[2] = a[6];
+    out[3] = a01;
+    out[5] = a[7];
+    out[6] = a02;
+    out[7] = a12;
+  } else {
+    out[0] = a[0];
+    out[1] = a[3];
+    out[2] = a[6];
+    out[3] = a[1];
+    out[4] = a[4];
+    out[5] = a[7];
+    out[6] = a[2];
+    out[7] = a[5];
+    out[8] = a[8];
+  }
+  return out;
+}
+function invert(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2];
+  var a10 = a[3], a11 = a[4], a12 = a[5];
+  var a20 = a[6], a21 = a[7], a22 = a[8];
+  var b01 = a22 * a11 - a12 * a21;
+  var b11 = -a22 * a10 + a12 * a20;
+  var b21 = a21 * a10 - a11 * a20;
+  var det = a00 * b01 + a01 * b11 + a02 * b21;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = b01 * det;
+  out[1] = (-a22 * a01 + a02 * a21) * det;
+  out[2] = (a12 * a01 - a02 * a11) * det;
+  out[3] = b11 * det;
+  out[4] = (a22 * a00 - a02 * a20) * det;
+  out[5] = (-a12 * a00 + a02 * a10) * det;
+  out[6] = b21 * det;
+  out[7] = (-a21 * a00 + a01 * a20) * det;
+  out[8] = (a11 * a00 - a01 * a10) * det;
+  return out;
+}
+function adjoint(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2];
+  var a10 = a[3], a11 = a[4], a12 = a[5];
+  var a20 = a[6], a21 = a[7], a22 = a[8];
+  out[0] = a11 * a22 - a12 * a21;
+  out[1] = a02 * a21 - a01 * a22;
+  out[2] = a01 * a12 - a02 * a11;
+  out[3] = a12 * a20 - a10 * a22;
+  out[4] = a00 * a22 - a02 * a20;
+  out[5] = a02 * a10 - a00 * a12;
+  out[6] = a10 * a21 - a11 * a20;
+  out[7] = a01 * a20 - a00 * a21;
+  out[8] = a00 * a11 - a01 * a10;
+  return out;
+}
+function determinant(a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2];
+  var a10 = a[3], a11 = a[4], a12 = a[5];
+  var a20 = a[6], a21 = a[7], a22 = a[8];
+  return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
+}
+function multiply(out, a, b) {
+  var a00 = a[0], a01 = a[1], a02 = a[2];
+  var a10 = a[3], a11 = a[4], a12 = a[5];
+  var a20 = a[6], a21 = a[7], a22 = a[8];
+  var b00 = b[0], b01 = b[1], b02 = b[2];
+  var b10 = b[3], b11 = b[4], b12 = b[5];
+  var b20 = b[6], b21 = b[7], b22 = b[8];
+  out[0] = b00 * a00 + b01 * a10 + b02 * a20;
+  out[1] = b00 * a01 + b01 * a11 + b02 * a21;
+  out[2] = b00 * a02 + b01 * a12 + b02 * a22;
+  out[3] = b10 * a00 + b11 * a10 + b12 * a20;
+  out[4] = b10 * a01 + b11 * a11 + b12 * a21;
+  out[5] = b10 * a02 + b11 * a12 + b12 * a22;
+  out[6] = b20 * a00 + b21 * a10 + b22 * a20;
+  out[7] = b20 * a01 + b21 * a11 + b22 * a21;
+  out[8] = b20 * a02 + b21 * a12 + b22 * a22;
+  return out;
+}
+function translate(out, a, v) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a10 = a[3], a11 = a[4], a12 = a[5], a20 = a[6], a21 = a[7], a22 = a[8], x = v[0], y = v[1];
+  out[0] = a00;
+  out[1] = a01;
+  out[2] = a02;
+  out[3] = a10;
+  out[4] = a11;
+  out[5] = a12;
+  out[6] = x * a00 + y * a10 + a20;
+  out[7] = x * a01 + y * a11 + a21;
+  out[8] = x * a02 + y * a12 + a22;
+  return out;
+}
+function rotate(out, a, rad) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a10 = a[3], a11 = a[4], a12 = a[5], a20 = a[6], a21 = a[7], a22 = a[8], s = Math.sin(rad), c = Math.cos(rad);
+  out[0] = c * a00 + s * a10;
+  out[1] = c * a01 + s * a11;
+  out[2] = c * a02 + s * a12;
+  out[3] = c * a10 - s * a00;
+  out[4] = c * a11 - s * a01;
+  out[5] = c * a12 - s * a02;
+  out[6] = a20;
+  out[7] = a21;
+  out[8] = a22;
+  return out;
+}
+function scale(out, a, v) {
+  var x = v[0], y = v[1];
+  out[0] = x * a[0];
+  out[1] = x * a[1];
+  out[2] = x * a[2];
+  out[3] = y * a[3];
+  out[4] = y * a[4];
+  out[5] = y * a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  return out;
+}
+function fromTranslation(out, v) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 1;
+  out[5] = 0;
+  out[6] = v[0];
+  out[7] = v[1];
+  out[8] = 1;
+  return out;
+}
+function fromRotation(out, rad) {
+  var s = Math.sin(rad), c = Math.cos(rad);
+  out[0] = c;
+  out[1] = s;
+  out[2] = 0;
+  out[3] = -s;
+  out[4] = c;
+  out[5] = 0;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 1;
+  return out;
+}
+function fromScaling(out, v) {
+  out[0] = v[0];
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = v[1];
+  out[5] = 0;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 1;
+  return out;
+}
+function fromMat2d(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = 0;
+  out[3] = a[2];
+  out[4] = a[3];
+  out[5] = 0;
+  out[6] = a[4];
+  out[7] = a[5];
+  out[8] = 1;
+  return out;
+}
+function fromQuat(out, q) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var yx = y * x2;
+  var yy = y * y2;
+  var zx = z * x2;
+  var zy = z * y2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  out[0] = 1 - yy - zz;
+  out[3] = yx - wz;
+  out[6] = zx + wy;
+  out[1] = yx + wz;
+  out[4] = 1 - xx - zz;
+  out[7] = zy - wx;
+  out[2] = zx - wy;
+  out[5] = zy + wx;
+  out[8] = 1 - xx - yy;
+  return out;
+}
+function normalFromMat4(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32;
+  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  return out;
+}
+function projection(out, width, height) {
+  out[0] = 2 / width;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = -2 / height;
+  out[5] = 0;
+  out[6] = -1;
+  out[7] = 1;
+  out[8] = 1;
+  return out;
+}
+function str(a) {
+  return "mat3(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ", " + a[8] + ")";
+}
+function frob(a) {
+  return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
+}
+function add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  out[3] = a[3] + b[3];
+  out[4] = a[4] + b[4];
+  out[5] = a[5] + b[5];
+  out[6] = a[6] + b[6];
+  out[7] = a[7] + b[7];
+  out[8] = a[8] + b[8];
+  return out;
+}
+function subtract(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  out[3] = a[3] - b[3];
+  out[4] = a[4] - b[4];
+  out[5] = a[5] - b[5];
+  out[6] = a[6] - b[6];
+  out[7] = a[7] - b[7];
+  out[8] = a[8] - b[8];
+  return out;
+}
+function multiplyScalar(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  out[3] = a[3] * b;
+  out[4] = a[4] * b;
+  out[5] = a[5] * b;
+  out[6] = a[6] * b;
+  out[7] = a[7] * b;
+  out[8] = a[8] * b;
+  return out;
+}
+function multiplyScalarAndAdd(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  out[2] = a[2] + b[2] * scale5;
+  out[3] = a[3] + b[3] * scale5;
+  out[4] = a[4] + b[4] * scale5;
+  out[5] = a[5] + b[5] * scale5;
+  out[6] = a[6] + b[6] * scale5;
+  out[7] = a[7] + b[7] * scale5;
+  out[8] = a[8] + b[8] * scale5;
+  return out;
+}
+function exactEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];
+}
+function equals(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5], a6 = a[6], a7 = a[7], a8 = a[8];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1, Math.abs(a8), Math.abs(b8));
+}
+var mul, sub;
+var init_mat3 = __esm({
+  "node_modules/gl-matrix/esm/mat3.js"() {
+    init_common();
+    mul = multiply;
+    sub = subtract;
+  }
+});
+
+// node_modules/gl-matrix/esm/mat4.js
+var init_mat4 = __esm({
+  "node_modules/gl-matrix/esm/mat4.js"() {
+    init_common();
+  }
+});
+
+// node_modules/gl-matrix/esm/vec3.js
+var vec3_exports = {};
+__export(vec3_exports, {
+  add: () => add2,
+  angle: () => angle,
+  bezier: () => bezier,
+  ceil: () => ceil,
+  clone: () => clone3,
+  copy: () => copy2,
+  create: () => create2,
+  cross: () => cross,
+  dist: () => dist,
+  distance: () => distance,
+  div: () => div,
+  divide: () => divide,
+  dot: () => dot,
+  equals: () => equals2,
+  exactEquals: () => exactEquals2,
+  floor: () => floor,
+  forEach: () => forEach,
+  fromValues: () => fromValues2,
+  hermite: () => hermite,
+  inverse: () => inverse,
+  len: () => len,
+  length: () => length,
+  lerp: () => lerp,
+  max: () => max,
+  min: () => min,
+  mul: () => mul2,
+  multiply: () => multiply2,
+  negate: () => negate,
+  normalize: () => normalize,
+  random: () => random,
+  rotateX: () => rotateX,
+  rotateY: () => rotateY,
+  rotateZ: () => rotateZ,
+  round: () => round,
+  scale: () => scale2,
+  scaleAndAdd: () => scaleAndAdd,
+  set: () => set2,
+  sqrDist: () => sqrDist,
+  sqrLen: () => sqrLen,
+  squaredDistance: () => squaredDistance,
+  squaredLength: () => squaredLength,
+  str: () => str2,
+  sub: () => sub2,
+  subtract: () => subtract2,
+  transformMat3: () => transformMat3,
+  transformMat4: () => transformMat4,
+  transformQuat: () => transformQuat,
+  zero: () => zero
+});
+function create2() {
+  var out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function clone3(a) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function length(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return Math.hypot(x, y, z);
+}
+function fromValues2(x, y, z) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function copy2(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function set2(out, x, y, z) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function add2(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+function subtract2(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  return out;
+}
+function multiply2(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  out[2] = a[2] * b[2];
+  return out;
+}
+function divide(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  out[2] = a[2] / b[2];
+  return out;
+}
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  out[2] = Math.ceil(a[2]);
+  return out;
+}
+function floor(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  out[2] = Math.floor(a[2]);
+  return out;
+}
+function min(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  out[2] = Math.min(a[2], b[2]);
+  return out;
+}
+function max(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  out[2] = Math.max(a[2], b[2]);
+  return out;
+}
+function round(out, a) {
+  out[0] = Math.round(a[0]);
+  out[1] = Math.round(a[1]);
+  out[2] = Math.round(a[2]);
+  return out;
+}
+function scale2(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  return out;
+}
+function scaleAndAdd(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  out[2] = a[2] + b[2] * scale5;
+  return out;
+}
+function distance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return Math.hypot(x, y, z);
+}
+function squaredDistance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return x * x + y * y + z * z;
+}
+function squaredLength(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return x * x + y * y + z * z;
+}
+function negate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  return out;
+}
+function inverse(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  out[2] = 1 / a[2];
+  return out;
+}
+function normalize(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var len3 = x * x + y * y + z * z;
+  if (len3 > 0) {
+    len3 = 1 / Math.sqrt(len3);
+  }
+  out[0] = a[0] * len3;
+  out[1] = a[1] * len3;
+  out[2] = a[2] * len3;
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2];
+  var bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function lerp(out, a, b, t) {
+  var ax = a[0];
+  var ay = a[1];
+  var az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  return out;
+}
+function hermite(out, a, b, c, d, t) {
+  var factorTimes2 = t * t;
+  var factor1 = factorTimes2 * (2 * t - 3) + 1;
+  var factor2 = factorTimes2 * (t - 2) + t;
+  var factor3 = factorTimes2 * (t - 1);
+  var factor4 = factorTimes2 * (3 - 2 * t);
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function bezier(out, a, b, c, d, t) {
+  var inverseFactor = 1 - t;
+  var inverseFactorTimesTwo = inverseFactor * inverseFactor;
+  var factorTimes2 = t * t;
+  var factor1 = inverseFactorTimesTwo * inverseFactor;
+  var factor2 = 3 * t * inverseFactorTimesTwo;
+  var factor3 = 3 * factorTimes2 * inverseFactor;
+  var factor4 = factorTimes2 * t;
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function random(out, scale5) {
+  scale5 = scale5 || 1;
+  var r = RANDOM() * 2 * Math.PI;
+  var z = RANDOM() * 2 - 1;
+  var zScale = Math.sqrt(1 - z * z) * scale5;
+  out[0] = Math.cos(r) * zScale;
+  out[1] = Math.sin(r) * zScale;
+  out[2] = z * scale5;
+  return out;
+}
+function transformMat4(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+function transformMat3(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  out[0] = x * m[0] + y * m[3] + z * m[6];
+  out[1] = x * m[1] + y * m[4] + z * m[7];
+  out[2] = x * m[2] + y * m[5] + z * m[8];
+  return out;
+}
+function transformQuat(out, a, q) {
+  var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  var x = a[0], y = a[1], z = a[2];
+  var uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
+  var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx;
+  var w2 = qw * 2;
+  uvx *= w2;
+  uvy *= w2;
+  uvz *= w2;
+  uuvx *= 2;
+  uuvy *= 2;
+  uuvz *= 2;
+  out[0] = x + uvx + uuvx;
+  out[1] = y + uvy + uuvy;
+  out[2] = z + uvz + uuvz;
+  return out;
+}
+function rotateX(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0];
+  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateY(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+  r[1] = p[1];
+  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateZ(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+  r[2] = p[2];
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function angle(a, b) {
+  var ax = a[0], ay = a[1], az = a[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a, b) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+function zero(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  return out;
+}
+function str2(a) {
+  return "vec3(" + a[0] + ", " + a[1] + ", " + a[2] + ")";
+}
+function exactEquals2(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function equals2(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2];
+  var b0 = b[0], b1 = b[1], b2 = b[2];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+}
+var sub2, mul2, div, dist, sqrDist, len, sqrLen, forEach;
+var init_vec3 = __esm({
+  "node_modules/gl-matrix/esm/vec3.js"() {
+    init_common();
+    sub2 = subtract2;
+    mul2 = multiply2;
+    div = divide;
+    dist = distance;
+    sqrDist = squaredDistance;
+    len = length;
+    sqrLen = squaredLength;
+    forEach = function() {
+      var vec = create2();
+      return function(a, stride, offset, count, fn, arg) {
+        var i, l;
+        if (!stride) {
+          stride = 3;
+        }
+        if (!offset) {
+          offset = 0;
+        }
+        if (count) {
+          l = Math.min(count * stride + offset, a.length);
+        } else {
+          l = a.length;
+        }
+        for (i = offset; i < l; i += stride) {
+          vec[0] = a[i];
+          vec[1] = a[i + 1];
+          vec[2] = a[i + 2];
+          fn(vec, vec, arg);
+          a[i] = vec[0];
+          a[i + 1] = vec[1];
+          a[i + 2] = vec[2];
+        }
+        return a;
+      };
+    }();
+  }
+});
+
+// node_modules/gl-matrix/esm/vec4.js
+function create3() {
+  var out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+function normalize2(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var w = a[3];
+  var len3 = x * x + y * y + z * z + w * w;
+  if (len3 > 0) {
+    len3 = 1 / Math.sqrt(len3);
+  }
+  out[0] = x * len3;
+  out[1] = y * len3;
+  out[2] = z * len3;
+  out[3] = w * len3;
+  return out;
+}
+var forEach2;
+var init_vec4 = __esm({
+  "node_modules/gl-matrix/esm/vec4.js"() {
+    init_common();
+    forEach2 = function() {
+      var vec = create3();
+      return function(a, stride, offset, count, fn, arg) {
+        var i, l;
+        if (!stride) {
+          stride = 4;
+        }
+        if (!offset) {
+          offset = 0;
+        }
+        if (count) {
+          l = Math.min(count * stride + offset, a.length);
+        } else {
+          l = a.length;
+        }
+        for (i = offset; i < l; i += stride) {
+          vec[0] = a[i];
+          vec[1] = a[i + 1];
+          vec[2] = a[i + 2];
+          vec[3] = a[i + 3];
+          fn(vec, vec, arg);
+          a[i] = vec[0];
+          a[i + 1] = vec[1];
+          a[i + 2] = vec[2];
+          a[i + 3] = vec[3];
+        }
+        return a;
+      };
+    }();
+  }
+});
+
+// node_modules/gl-matrix/esm/quat.js
+function create4() {
+  var out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  out[3] = 1;
+  return out;
+}
+function setAxisAngle(out, axis, rad) {
+  rad = rad * 0.5;
+  var s = Math.sin(rad);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(rad);
+  return out;
+}
+function slerp(out, a, b, t) {
+  var ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  var bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  var omega, cosom, sinom, scale0, scale1;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (1 - cosom > EPSILON) {
+    omega = Math.acos(cosom);
+    sinom = Math.sin(omega);
+    scale0 = Math.sin((1 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+function fromMat3(out, m) {
+  var fTrace = m[0] + m[4] + m[8];
+  var fRoot;
+  if (fTrace > 0) {
+    fRoot = Math.sqrt(fTrace + 1);
+    out[3] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[0] = (m[5] - m[7]) * fRoot;
+    out[1] = (m[6] - m[2]) * fRoot;
+    out[2] = (m[1] - m[3]) * fRoot;
+  } else {
+    var i = 0;
+    if (m[4] > m[0])
+      i = 1;
+    if (m[8] > m[i * 3 + i])
+      i = 2;
+    var j = (i + 1) % 3;
+    var k = (i + 2) % 3;
+    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1);
+    out[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+  }
+  return out;
+}
+var normalize3, rotationTo, sqlerp, setAxes;
+var init_quat = __esm({
+  "node_modules/gl-matrix/esm/quat.js"() {
+    init_common();
+    init_mat3();
+    init_vec3();
+    init_vec4();
+    normalize3 = normalize2;
+    rotationTo = function() {
+      var tmpvec3 = create2();
+      var xUnitVec3 = fromValues2(1, 0, 0);
+      var yUnitVec3 = fromValues2(0, 1, 0);
+      return function(out, a, b) {
+        var dot5 = dot(a, b);
+        if (dot5 < -0.999999) {
+          cross(tmpvec3, xUnitVec3, a);
+          if (len(tmpvec3) < 1e-6)
+            cross(tmpvec3, yUnitVec3, a);
+          normalize(tmpvec3, tmpvec3);
+          setAxisAngle(out, tmpvec3, Math.PI);
+          return out;
+        } else if (dot5 > 0.999999) {
+          out[0] = 0;
+          out[1] = 0;
+          out[2] = 0;
+          out[3] = 1;
+          return out;
+        } else {
+          cross(tmpvec3, a, b);
+          out[0] = tmpvec3[0];
+          out[1] = tmpvec3[1];
+          out[2] = tmpvec3[2];
+          out[3] = 1 + dot5;
+          return normalize3(out, out);
+        }
+      };
+    }();
+    sqlerp = function() {
+      var temp1 = create4();
+      var temp2 = create4();
+      return function(out, a, b, c, d, t) {
+        slerp(temp1, a, d, t);
+        slerp(temp2, b, c, t);
+        slerp(out, temp1, temp2, 2 * t * (1 - t));
+        return out;
+      };
+    }();
+    setAxes = function() {
+      var matr = create();
+      return function(out, view, right, up) {
+        matr[0] = right[0];
+        matr[3] = right[1];
+        matr[6] = right[2];
+        matr[1] = up[0];
+        matr[4] = up[1];
+        matr[7] = up[2];
+        matr[2] = -view[0];
+        matr[5] = -view[1];
+        matr[8] = -view[2];
+        return normalize3(out, fromMat3(out, matr));
+      };
+    }();
+  }
+});
+
+// node_modules/gl-matrix/esm/quat2.js
+var init_quat2 = __esm({
+  "node_modules/gl-matrix/esm/quat2.js"() {
+    init_common();
+    init_quat();
+    init_mat4();
+  }
+});
+
+// node_modules/gl-matrix/esm/vec2.js
+var vec2_exports = {};
+__export(vec2_exports, {
+  add: () => add4,
+  angle: () => angle2,
+  ceil: () => ceil2,
+  clone: () => clone5,
+  copy: () => copy5,
+  create: () => create5,
+  cross: () => cross2,
+  dist: () => dist2,
+  distance: () => distance2,
+  div: () => div2,
+  divide: () => divide2,
+  dot: () => dot4,
+  equals: () => equals4,
+  exactEquals: () => exactEquals4,
+  floor: () => floor2,
+  forEach: () => forEach3,
+  fromValues: () => fromValues4,
+  inverse: () => inverse2,
+  len: () => len2,
+  length: () => length4,
+  lerp: () => lerp3,
+  max: () => max2,
+  min: () => min2,
+  mul: () => mul3,
+  multiply: () => multiply3,
+  negate: () => negate2,
+  normalize: () => normalize4,
+  random: () => random2,
+  rotate: () => rotate2,
+  round: () => round2,
+  scale: () => scale4,
+  scaleAndAdd: () => scaleAndAdd2,
+  set: () => set4,
+  sqrDist: () => sqrDist2,
+  sqrLen: () => sqrLen2,
+  squaredDistance: () => squaredDistance2,
+  squaredLength: () => squaredLength4,
+  str: () => str3,
+  sub: () => sub3,
+  subtract: () => subtract3,
+  transformMat2: () => transformMat2,
+  transformMat2d: () => transformMat2d,
+  transformMat3: () => transformMat32,
+  transformMat4: () => transformMat42,
+  zero: () => zero2
+});
+function create5() {
+  var out = new ARRAY_TYPE(2);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+  }
+  return out;
+}
+function clone5(a) {
+  var out = new ARRAY_TYPE(2);
+  out[0] = a[0];
+  out[1] = a[1];
+  return out;
+}
+function fromValues4(x, y) {
+  var out = new ARRAY_TYPE(2);
+  out[0] = x;
+  out[1] = y;
+  return out;
+}
+function copy5(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  return out;
+}
+function set4(out, x, y) {
+  out[0] = x;
+  out[1] = y;
+  return out;
+}
+function add4(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  return out;
+}
+function subtract3(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  return out;
+}
+function multiply3(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  return out;
+}
+function divide2(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  return out;
+}
+function ceil2(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  return out;
+}
+function floor2(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  return out;
+}
+function min2(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  return out;
+}
+function max2(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  return out;
+}
+function round2(out, a) {
+  out[0] = Math.round(a[0]);
+  out[1] = Math.round(a[1]);
+  return out;
+}
+function scale4(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  return out;
+}
+function scaleAndAdd2(out, a, b, scale5) {
+  out[0] = a[0] + b[0] * scale5;
+  out[1] = a[1] + b[1] * scale5;
+  return out;
+}
+function distance2(a, b) {
+  var x = b[0] - a[0], y = b[1] - a[1];
+  return Math.hypot(x, y);
+}
+function squaredDistance2(a, b) {
+  var x = b[0] - a[0], y = b[1] - a[1];
+  return x * x + y * y;
+}
+function length4(a) {
+  var x = a[0], y = a[1];
+  return Math.hypot(x, y);
+}
+function squaredLength4(a) {
+  var x = a[0], y = a[1];
+  return x * x + y * y;
+}
+function negate2(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  return out;
+}
+function inverse2(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  return out;
+}
+function normalize4(out, a) {
+  var x = a[0], y = a[1];
+  var len3 = x * x + y * y;
+  if (len3 > 0) {
+    len3 = 1 / Math.sqrt(len3);
+  }
+  out[0] = a[0] * len3;
+  out[1] = a[1] * len3;
+  return out;
+}
+function dot4(a, b) {
+  return a[0] * b[0] + a[1] * b[1];
+}
+function cross2(out, a, b) {
+  var z = a[0] * b[1] - a[1] * b[0];
+  out[0] = out[1] = 0;
+  out[2] = z;
+  return out;
+}
+function lerp3(out, a, b, t) {
+  var ax = a[0], ay = a[1];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  return out;
+}
+function random2(out, scale5) {
+  scale5 = scale5 || 1;
+  var r = RANDOM() * 2 * Math.PI;
+  out[0] = Math.cos(r) * scale5;
+  out[1] = Math.sin(r) * scale5;
+  return out;
+}
+function transformMat2(out, a, m) {
+  var x = a[0], y = a[1];
+  out[0] = m[0] * x + m[2] * y;
+  out[1] = m[1] * x + m[3] * y;
+  return out;
+}
+function transformMat2d(out, a, m) {
+  var x = a[0], y = a[1];
+  out[0] = m[0] * x + m[2] * y + m[4];
+  out[1] = m[1] * x + m[3] * y + m[5];
+  return out;
+}
+function transformMat32(out, a, m) {
+  var x = a[0], y = a[1];
+  out[0] = m[0] * x + m[3] * y + m[6];
+  out[1] = m[1] * x + m[4] * y + m[7];
+  return out;
+}
+function transformMat42(out, a, m) {
+  var x = a[0];
+  var y = a[1];
+  out[0] = m[0] * x + m[4] * y + m[12];
+  out[1] = m[1] * x + m[5] * y + m[13];
+  return out;
+}
+function rotate2(out, a, b, rad) {
+  var p0 = a[0] - b[0], p1 = a[1] - b[1], sinC = Math.sin(rad), cosC = Math.cos(rad);
+  out[0] = p0 * cosC - p1 * sinC + b[0];
+  out[1] = p0 * sinC + p1 * cosC + b[1];
+  return out;
+}
+function angle2(a, b) {
+  var x1 = a[0], y1 = a[1], x2 = b[0], y2 = b[1], mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2), cosine = mag && (x1 * x2 + y1 * y2) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+function zero2(out) {
+  out[0] = 0;
+  out[1] = 0;
+  return out;
+}
+function str3(a) {
+  return "vec2(" + a[0] + ", " + a[1] + ")";
+}
+function exactEquals4(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function equals4(a, b) {
+  var a0 = a[0], a1 = a[1];
+  var b0 = b[0], b1 = b[1];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1));
+}
+var len2, sub3, mul3, div2, dist2, sqrDist2, sqrLen2, forEach3;
+var init_vec2 = __esm({
+  "node_modules/gl-matrix/esm/vec2.js"() {
+    init_common();
+    len2 = length4;
+    sub3 = subtract3;
+    mul3 = multiply3;
+    div2 = divide2;
+    dist2 = distance2;
+    sqrDist2 = squaredDistance2;
+    sqrLen2 = squaredLength4;
+    forEach3 = function() {
+      var vec = create5();
+      return function(a, stride, offset, count, fn, arg) {
+        var i, l;
+        if (!stride) {
+          stride = 2;
+        }
+        if (!offset) {
+          offset = 0;
+        }
+        if (count) {
+          l = Math.min(count * stride + offset, a.length);
+        } else {
+          l = a.length;
+        }
+        for (i = offset; i < l; i += stride) {
+          vec[0] = a[i];
+          vec[1] = a[i + 1];
+          fn(vec, vec, arg);
+          a[i] = vec[0];
+          a[i + 1] = vec[1];
+        }
+        return a;
+      };
+    }();
+  }
+});
+
+// node_modules/gl-matrix/esm/index.js
+var init_esm2 = __esm({
+  "node_modules/gl-matrix/esm/index.js"() {
+    init_common();
+    init_mat2();
+    init_mat2d();
+    init_mat3();
+    init_mat4();
+    init_quat();
+    init_quat2();
+    init_vec2();
+    init_vec3();
+    init_vec4();
+  }
+});
+
+// node_modules/@antv/matrix-util/esm/ext.js
+var ext_exports = {};
+__export(ext_exports, {
+  angleTo: () => angleTo,
+  direction: () => direction,
+  leftRotate: () => leftRotate,
+  leftScale: () => leftScale,
+  leftTranslate: () => leftTranslate,
+  transform: () => transform,
+  vertical: () => vertical
+});
+function leftTranslate(out, a, v) {
+  var transMat = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  mat3_exports.fromTranslation(transMat, v);
+  return mat3_exports.multiply(out, transMat, a);
+}
+function leftRotate(out, a, rad) {
+  var rotateMat = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  mat3_exports.fromRotation(rotateMat, rad);
+  return mat3_exports.multiply(out, rotateMat, a);
+}
+function leftScale(out, a, v) {
+  var scaleMat = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  mat3_exports.fromScaling(scaleMat, v);
+  return mat3_exports.multiply(out, scaleMat, a);
+}
+function leftMultiply(out, a, a1) {
+  return mat3_exports.multiply(out, a1, a);
+}
+function transform(m, actions) {
+  var matrix = m ? [].concat(m) : [1, 0, 0, 0, 1, 0, 0, 0, 1];
+  for (var i = 0, len3 = actions.length; i < len3; i++) {
+    var action = actions[i];
+    switch (action[0]) {
+      case "t":
+        leftTranslate(matrix, matrix, [action[1], action[2]]);
+        break;
+      case "s":
+        leftScale(matrix, matrix, [action[1], action[2]]);
+        break;
+      case "r":
+        leftRotate(matrix, matrix, action[1]);
+        break;
+      case "m":
+        leftMultiply(matrix, matrix, action[1]);
+        break;
+      default:
+        break;
+    }
+  }
+  return matrix;
+}
+function direction(v1, v2) {
+  return v1[0] * v2[1] - v2[0] * v1[1];
+}
+function angleTo(v1, v2, direct) {
+  var ang = vec2_exports.angle(v1, v2);
+  var angleLargeThanPI = direction(v1, v2) >= 0;
+  if (direct) {
+    if (angleLargeThanPI) {
+      return Math.PI * 2 - ang;
+    }
+    return ang;
+  }
+  if (angleLargeThanPI) {
+    return ang;
+  }
+  return Math.PI * 2 - ang;
+}
+function vertical(out, v, flag) {
+  if (flag) {
+    out[0] = v[1];
+    out[1] = -1 * v[0];
+  } else {
+    out[0] = -1 * v[1];
+    out[1] = v[0];
+  }
+  return out;
+}
+var init_ext = __esm({
+  "node_modules/@antv/matrix-util/esm/ext.js"() {
+    init_esm2();
+  }
+});
+
+// node_modules/@antv/matrix-util/esm/index.js
+var esm_exports2 = {};
+__export(esm_exports2, {
+  ext: () => ext_exports,
+  mat3: () => mat3_exports,
+  vec2: () => vec2_exports,
+  vec3: () => vec3_exports
+});
+var init_esm3 = __esm({
+  "node_modules/@antv/matrix-util/esm/index.js"() {
+    init_esm2();
+    init_ext();
+  }
+});
+
+export {
+  __extends,
+  __assign,
+  __rest,
+  __awaiter,
+  __generator,
+  __values,
+  __read,
+  __spreadArrays,
+  __spreadArray,
+  init_tslib_es6,
+  contains_default,
+  filter_default,
+  difference_default,
+  is_type_default,
+  is_function_default,
+  is_nil_default,
+  is_array_default,
+  is_object_default,
+  each_default,
+  keys_default,
+  is_match_default,
+  is_plain_object_default,
+  find_default,
+  find_index_default,
+  first_value_default,
+  flatten_default,
+  max_default,
+  min_default,
+  get_range_default,
+  reduce_default,
+  remove_default,
+  is_string_default,
+  sort_by_default,
+  uniq,
+  values_of_key_default,
+  head,
+  last,
+  every_default,
+  some_default,
+  group_by_default,
+  groupToMap,
+  group_default,
+  clamp_default,
+  fixed_base_default,
+  is_number_default,
+  isNumberEqual,
+  max_by_default,
+  min_by_default,
+  mod_default,
+  to_radian_default,
+  for_in_default,
+  has_key_default,
+  values_default,
+  to_string_default,
+  lower_case_default,
+  substitute_default,
+  upper_first_default,
+  is_boolean_default,
+  is_date_default,
+  is_null_default,
+  is_undefined_default,
+  is_element_default,
+  requestAnimationFrame,
+  cancelAnimationFrame,
+  mix,
+  clone_default,
+  debounce_default,
+  memoize_default,
+  deep_mix_default,
+  index_of_default,
+  is_empty_default,
+  is_equal_default,
+  map_default,
+  map_values_default,
+  get_default,
+  set_default,
+  pick_default,
+  omit_default,
+  throttle_default,
+  to_array_default,
+  unique_id_default,
+  noop_default,
+  size,
+  get_ellipsis_text_default,
+  cache_default,
+  esm_exports,
+  init_esm,
+  mat3_exports,
+  transformMat3,
+  vec3_exports,
+  init_vec3,
+  normalize4 as normalize,
+  dot4 as dot,
+  exactEquals4 as exactEquals,
+  vec2_exports,
+  init_vec2,
+  init_esm2,
+  ext_exports,
+  esm_exports2,
+  init_esm3
+};
+//# sourceMappingURL=chunk-KRTWMFYD.js.map

node_modules/.vite/deps/chunk-PRI5REV2.js

@@ -0,0 +1,220 @@
+import {
+  __commonJS
+} from "./chunk-AC2VUBZ6.js";
+
+// node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = __commonJS({
+  "node_modules/dayjs/dayjs.min.js"(exports, module) {
+    !function(t, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+    }(exports, function() {
+      "use strict";
+      var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", f = "month", h = "quarter", c = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
+        var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+      } }, m = function(t2, e2, n2) {
+        var r2 = String(t2);
+        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+      }, v = { s: m, z: function(t2) {
+        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+      }, m: function t2(e2, n2) {
+        if (e2.date() < n2.date())
+          return -t2(n2, e2);
+        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, f), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), f);
+        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+      }, a: function(t2) {
+        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+      }, p: function(t2) {
+        return { M: f, y: c, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: h }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+      }, u: function(t2) {
+        return void 0 === t2;
+      } }, g = "en", D = {};
+      D[g] = M;
+      var p = function(t2) {
+        return t2 instanceof _;
+      }, S = function t2(e2, n2, r2) {
+        var i2;
+        if (!e2)
+          return g;
+        if ("string" == typeof e2) {
+          var s2 = e2.toLowerCase();
+          D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+          var u2 = e2.split("-");
+          if (!i2 && u2.length > 1)
+            return t2(u2[0]);
+        } else {
+          var a2 = e2.name;
+          D[a2] = e2, i2 = a2;
+        }
+        return !r2 && i2 && (g = i2), i2 || !r2 && g;
+      }, w = function(t2, e2) {
+        if (p(t2))
+          return t2.clone();
+        var n2 = "object" == typeof e2 ? e2 : {};
+        return n2.date = t2, n2.args = arguments, new _(n2);
+      }, O = v;
+      O.l = S, O.i = p, O.w = function(t2, e2) {
+        return w(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+      };
+      var _ = function() {
+        function M2(t2) {
+          this.$L = S(t2.locale, null, true), this.parse(t2);
+        }
+        var m2 = M2.prototype;
+        return m2.parse = function(t2) {
+          this.$d = function(t3) {
+            var e2 = t3.date, n2 = t3.utc;
+            if (null === e2)
+              return new Date(NaN);
+            if (O.u(e2))
+              return new Date();
+            if (e2 instanceof Date)
+              return new Date(e2);
+            if ("string" == typeof e2 && !/Z$/i.test(e2)) {
+              var r2 = e2.match($);
+              if (r2) {
+                var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+                return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+              }
+            }
+            return new Date(e2);
+          }(t2), this.$x = t2.x || {}, this.init();
+        }, m2.init = function() {
+          var t2 = this.$d;
+          this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+        }, m2.$utils = function() {
+          return O;
+        }, m2.isValid = function() {
+          return !(this.$d.toString() === l);
+        }, m2.isSame = function(t2, e2) {
+          var n2 = w(t2);
+          return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+        }, m2.isAfter = function(t2, e2) {
+          return w(t2) < this.startOf(e2);
+        }, m2.isBefore = function(t2, e2) {
+          return this.endOf(e2) < w(t2);
+        }, m2.$g = function(t2, e2, n2) {
+          return O.u(t2) ? this[e2] : this.set(n2, t2);
+        }, m2.unix = function() {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m2.valueOf = function() {
+          return this.$d.getTime();
+        }, m2.startOf = function(t2, e2) {
+          var n2 = this, r2 = !!O.u(e2) || e2, h2 = O.p(t2), l2 = function(t3, e3) {
+            var i2 = O.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+            return r2 ? i2 : i2.endOf(a);
+          }, $2 = function(t3, e3) {
+            return O.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+          }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+          switch (h2) {
+            case c:
+              return r2 ? l2(1, 0) : l2(31, 11);
+            case f:
+              return r2 ? l2(1, M3) : l2(0, M3 + 1);
+            case o:
+              var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+              return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+            case a:
+            case d:
+              return $2(v2 + "Hours", 0);
+            case u:
+              return $2(v2 + "Minutes", 1);
+            case s:
+              return $2(v2 + "Seconds", 2);
+            case i:
+              return $2(v2 + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, m2.endOf = function(t2) {
+          return this.startOf(t2, false);
+        }, m2.$set = function(t2, e2) {
+          var n2, o2 = O.p(t2), h2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = h2 + "Date", n2[d] = h2 + "Date", n2[f] = h2 + "Month", n2[c] = h2 + "FullYear", n2[u] = h2 + "Hours", n2[s] = h2 + "Minutes", n2[i] = h2 + "Seconds", n2[r] = h2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+          if (o2 === f || o2 === c) {
+            var y2 = this.clone().set(d, 1);
+            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+          } else
+            l2 && this.$d[l2]($2);
+          return this.init(), this;
+        }, m2.set = function(t2, e2) {
+          return this.clone().$set(t2, e2);
+        }, m2.get = function(t2) {
+          return this[O.p(t2)]();
+        }, m2.add = function(r2, h2) {
+          var d2, l2 = this;
+          r2 = Number(r2);
+          var $2 = O.p(h2), y2 = function(t2) {
+            var e2 = w(l2);
+            return O.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+          };
+          if ($2 === f)
+            return this.set(f, this.$M + r2);
+          if ($2 === c)
+            return this.set(c, this.$y + r2);
+          if ($2 === a)
+            return y2(1);
+          if ($2 === o)
+            return y2(7);
+          var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+          return O.w(m3, this);
+        }, m2.subtract = function(t2, e2) {
+          return this.add(-1 * t2, e2);
+        }, m2.format = function(t2) {
+          var e2 = this, n2 = this.$locale();
+          if (!this.isValid())
+            return n2.invalidDate || l;
+          var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = O.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, f2 = n2.months, h2 = function(t3, n3, i3, s3) {
+            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+          }, c2 = function(t3) {
+            return O.s(s2 % 12 || 12, t3, "0");
+          }, d2 = n2.meridiem || function(t3, e3, n3) {
+            var r3 = t3 < 12 ? "AM" : "PM";
+            return n3 ? r3.toLowerCase() : r3;
+          }, $2 = { YY: String(this.$y).slice(-2), YYYY: this.$y, M: a2 + 1, MM: O.s(a2 + 1, 2, "0"), MMM: h2(n2.monthsShort, a2, f2, 3), MMMM: h2(f2, a2), D: this.$D, DD: O.s(this.$D, 2, "0"), d: String(this.$W), dd: h2(n2.weekdaysMin, this.$W, o2, 2), ddd: h2(n2.weekdaysShort, this.$W, o2, 3), dddd: o2[this.$W], H: String(s2), HH: O.s(s2, 2, "0"), h: c2(1), hh: c2(2), a: d2(s2, u2, true), A: d2(s2, u2, false), m: String(u2), mm: O.s(u2, 2, "0"), s: String(this.$s), ss: O.s(this.$s, 2, "0"), SSS: O.s(this.$ms, 3, "0"), Z: i2 };
+          return r2.replace(y, function(t3, e3) {
+            return e3 || $2[t3] || i2.replace(":", "");
+          });
+        }, m2.utcOffset = function() {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m2.diff = function(r2, d2, l2) {
+          var $2, y2 = O.p(d2), M3 = w(r2), m3 = (M3.utcOffset() - this.utcOffset()) * e, v2 = this - M3, g2 = O.m(this, M3);
+          return g2 = ($2 = {}, $2[c] = g2 / 12, $2[f] = g2, $2[h] = g2 / 3, $2[o] = (v2 - m3) / 6048e5, $2[a] = (v2 - m3) / 864e5, $2[u] = v2 / n, $2[s] = v2 / e, $2[i] = v2 / t, $2)[y2] || v2, l2 ? g2 : O.a(g2);
+        }, m2.daysInMonth = function() {
+          return this.endOf(f).$D;
+        }, m2.$locale = function() {
+          return D[this.$L];
+        }, m2.locale = function(t2, e2) {
+          if (!t2)
+            return this.$L;
+          var n2 = this.clone(), r2 = S(t2, e2, true);
+          return r2 && (n2.$L = r2), n2;
+        }, m2.clone = function() {
+          return O.w(this.$d, this);
+        }, m2.toDate = function() {
+          return new Date(this.valueOf());
+        }, m2.toJSON = function() {
+          return this.isValid() ? this.toISOString() : null;
+        }, m2.toISOString = function() {
+          return this.$d.toISOString();
+        }, m2.toString = function() {
+          return this.$d.toUTCString();
+        }, M2;
+      }(), T = _.prototype;
+      return w.prototype = T, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function(t2) {
+        T[t2[1]] = function(e2) {
+          return this.$g(e2, t2[0], t2[1]);
+        };
+      }), w.extend = function(t2, e2) {
+        return t2.$i || (t2(e2, _, w), t2.$i = true), w;
+      }, w.locale = S, w.isDayjs = p, w.unix = function(t2) {
+        return w(1e3 * t2);
+      }, w.en = D[g], w.Ls = D, w.p = {}, w;
+    });
+  }
+});
+
+export {
+  require_dayjs_min
+};
+//# sourceMappingURL=chunk-PRI5REV2.js.map