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

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