@vope/utils 1.6.0-bate.2 → 1.6.0-bate.3

package/dist/index.js

@@ -0,0 +1,1361 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlexTable: () => FlexTable,
+  MemoryBasic: () => MemoryBasic,
+  MemoryList: () => MemoryList,
+  MemoryPower: () => MemoryPower,
+  MemorySimple: () => MemorySimple,
+  Neo4j: () => Neo4j,
+  Neo4jAhchors: () => Neo4jAhchors,
+  Subscriber: () => Subscriber,
+  Union: () => Union,
+  clamp: () => clamp,
+  classnames: () => classnames,
+  compareVersion: () => compareVersion,
+  connectURLParams: () => connectURLParams,
+  css: () => css,
+  cubeURLParams: () => cubeURLParams,
+  deconPowersSum: () => deconPowersSum,
+  deepWeakEqual: () => deepWeakEqual,
+  desensDecrypt: () => desensDecrypt,
+  desensEncrypt: () => desensEncrypt,
+  desensReplace: () => desensReplace,
+  flatURLParams: () => flatURLParams,
+  getEncoding: () => getEncoding,
+  hash8json: () => hash8json,
+  hash8object: () => hash8object,
+  hash8strings: () => hash8strings,
+  inputRegex: () => inputRegex,
+  isClass: () => isClass,
+  isEmpty: () => isEmpty,
+  isKey: () => isKey,
+  isNull: () => isNull,
+  joinPaths: () => joinPaths,
+  loadImage: () => loadImage,
+  once: () => once,
+  parseNum: () => parseNum,
+  rotateAngle: () => rotateAngle,
+  rotateRad: () => rotateRad,
+  wait: () => wait
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/clamp.ts
+var clamp = (value, min, max) => {
+  if (min > max) {
+    const swap = max;
+    max = min;
+    min = swap;
+  }
+  return Math.min(max, Math.max(min, value));
+};
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isString.js
+var stringTag = "[object String]";
+function isString(value) {
+  return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && baseGetTag_default(value) == stringTag;
+}
+var isString_default = isString;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isBoolean.js
+var boolTag = "[object Boolean]";
+function isBoolean(value) {
+  return value === true || value === false || isObjectLike_default(value) && baseGetTag_default(value) == boolTag;
+}
+var isBoolean_default = isBoolean;
+
+// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isNumber.js
+var numberTag = "[object Number]";
+function isNumber(value) {
+  return typeof value == "number" || isObjectLike_default(value) && baseGetTag_default(value) == numberTag;
+}
+var isNumber_default = isNumber;
+
+// src/classnames.ts
+var add = (a, b) => a ? a + " " + b : b;
+var classnames = (...list) => list.reduce((caches, data) => {
+  if (isString_default(data)) {
+    data && (caches = add(caches, data));
+  } else if (Array.isArray(data)) {
+    data.forEach((value) => value && isString_default(value) && (caches = add(caches, value)));
+  } else if (!isBoolean_default(data)) {
+    for (const key in data) {
+      key && data[key] && (caches = add(caches, key));
+    }
+  }
+  return caches;
+}, "");
+
+// src/compare/version.ts
+var CHAR = ".";
+var compareVersion = (from, to) => {
+  const froms = from.split(CHAR);
+  const tos = to.split(CHAR);
+  for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
+    const fromV = +froms[i] || 0;
+    const toV = +tos[i] || 0;
+    if (fromV > toV) return -1;
+    if (fromV < toV) return 1;
+  }
+  return 0;
+};
+
+// src/convert/strings.ts
+var hash8strings = (list) => list.reduce((caches, data, index) => {
+  caches[data] = index;
+  return caches;
+}, {});
+
+// src/compare/weak-equal.ts
+var deepWeakEqual = (from, to, exclude) => {
+  if (typeof from !== "object" || from === null || typeof to !== "object" || to === null) return from === to;
+  if (Array.isArray(from) && Array.isArray(to)) {
+    if (from.length !== to.length) return false;
+    return !from.some((t1, index) => {
+      if (!deepWeakEqual(t1, to[index])) {
+        return true;
+      }
+    });
+  } else {
+    const caches = {};
+    const excludeCaches = exclude && hash8strings(exclude);
+    for (const key in from) {
+      if (excludeCaches && key in excludeCaches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      } else {
+        caches[key] = key;
+      }
+    }
+    for (const key in to) {
+      if (excludeCaches && key in excludeCaches || key in caches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+// src/convert/json.ts
+var hash8json = (list, key) => list.reduce((caches, data) => {
+  caches[data[key]] = data;
+  return caches;
+}, {});
+
+// src/convert/object.ts
+var hash8object = (list, key) => list.reduce((caches, data) => {
+  caches.set(data[key], data);
+  return caches;
+}, /* @__PURE__ */ new Map());
+
+// src/desens.ts
+var desensEncrypt = (plaintext, encrypt) => {
+  const rules = [];
+  let point = -1;
+  let ciphertext = encrypt(plaintext).reduce((cache, { range, ciphertext: ciphertext2 }) => {
+    cache += plaintext.slice(point + 1, range[0]) + ciphertext2;
+    point = range[1];
+    rules.push({
+      range,
+      modify: ciphertext2.length
+    });
+    return cache;
+  }, "");
+  if (point !== -1) {
+    ciphertext += plaintext.slice(point + 1);
+  }
+  return {
+    ciphertext,
+    rules
+  };
+};
+var desensDecrypt = (ciphertext, rules, decrypt) => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    cache += ciphertext.slice(from, start + offset) + decrypt(ciphertext.slice(start + offset, start + offset + modify));
+    from = start + offset + modify;
+    offset += modify - (stop + 1 - start);
+    return cache;
+  }, "") + ciphertext.slice(from);
+};
+var desensReplace = (ciphertext, rules, replacer = "*") => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    const part = ciphertext.slice(start + offset, start + offset + modify);
+    const size = stop + 1 - start;
+    const replaceValue = isString_default(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    cache += ciphertext.slice(from, start + offset) + replaceValue;
+    from = start + offset + modify;
+    offset += modify - size;
+    return cache;
+  }, "") + ciphertext.slice(from);
+};
+
+// src/encoding.ts
+var utf8_first_prefix = /^1{2,}/g;
+var utf8_other_prefix = /^10/;
+var Encodes = {
+  UTF_8: "utf-8",
+  UTF_16LE: "utf-16le",
+  UTF_16BE: "utf-16be",
+  GBK: "gbk"
+};
+var BOM = {
+  UTF_8: [239, 187, 191],
+  UTF_16LE: [255, 254],
+  UTF_16BE: [254, 255]
+};
+var equal = (uint, list) => {
+  return uint.length === list.length ? !uint.some((value, index) => value !== list[index]) : false;
+};
+var getEncoding = (uint, limit = 1024) => {
+  let encoding;
+  let offset = 0;
+  for (const key in BOM) {
+    const head = BOM[key];
+    if (equal(uint.slice(0, head.length), head)) {
+      offset = head.length;
+      encoding = Encodes[key];
+      break;
+    }
+  }
+  if (!encoding) {
+    let isBreak = false;
+    top:
+      for (let i = 0, max = Math.min(uint.length, limit); i < max; i++) {
+        const data = uint[i];
+        if (data < 128) continue;
+        const match = data.toString(2).match(utf8_first_prefix);
+        if (match) {
+          for (let m = 0; m < match[0].length - 1; m++) {
+            const target = uint[++i];
+            if (target == void 0 || !utf8_other_prefix.test(target.toString(2))) {
+              encoding = Encodes.GBK;
+              isBreak = true;
+              break top;
+            }
+          }
+        } else {
+          encoding = Encodes.GBK;
+          isBreak = true;
+          break;
+        }
+      }
+    isBreak || (encoding = Encodes.UTF_8);
+  }
+  return { encoding, offset };
+};
+
+// src/input-regex.ts
+var RE_REGEX = /[$()*+.[?\\^{|]/g;
+var RE_STRING = /[$()*+.[?\\^{|-]/g;
+function inputRegex(text, flags) {
+  return flags === false ? text.replace(RE_STRING, ($0) => "\\" + $0) : new RegExp(text.replace(RE_REGEX, ($0) => "\\" + $0), flags);
+}
+
+// src/is/class.ts
+var re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
+var re_function = /^function\s+[A-Z]/;
+var re_this = /\b\(this\b|\bthis[\.\[]\b/;
+var re_check = /classCallCheck\(this/;
+var re_default = /^function\sdefault_\d+\s*\(/;
+var isClass = (value, strict = true) => {
+  if (typeof value !== "function") return false;
+  const proto = value.prototype;
+  if (!proto || proto.constructor !== value) return false;
+  const str = value.toString();
+  if (str.slice(0, 5) === "class" || Object.getOwnPropertyNames(proto).length >= 2) return true;
+  if (re_anonymous.test(str)) return false;
+  if (strict && re_function.test(str)) return true;
+  if (re_this.test(str)) {
+    if (!strict || re_check.test(str)) return true;
+    return re_default.test(str);
+  }
+  return false;
+};
+
+// src/is/null.ts
+var isNull = (value) => value === void 0 || value === null;
+
+// src/is/empty.ts
+var isEmpty = (value) => isNull(value) || value === "";
+
+// src/is/key.ts
+var isKey = (key, data) => key in data;
+
+// src/load/image.ts
+var loadImage = (src) => {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = src;
+  });
+};
+
+// src/memory/basic.ts
+var MemoryBasic = class {
+  /**
+   * @param key 用于对数据进行分类的key
+   * @param config 
+   */
+  constructor(key, config) {
+    this.key = key;
+    this.#mount = config.mount;
+    this.#reflex = config.reflex;
+  }
+  #mount;
+  #reflex;
+  list = [];
+  memorys = /* @__PURE__ */ new Map();
+  /**
+   * 返回存储长度
+   */
+  get size() {
+    return this.list.length;
+  }
+  getType(data) {
+    const { key } = this;
+    return typeof key === "function" ? key(data) : data[key];
+  }
+  push(...list) {
+    const { memorys } = this;
+    list.forEach((data) => {
+      const type = this.getType(data);
+      const memory = memorys.get(type);
+      const index = this.list.push(data) - 1;
+      const result = this.#mount(index, memory);
+      memory === result || memorys.set(type, result);
+    });
+    return this;
+  }
+  /**
+   * 返回位于指定索引处的项
+   */
+  at(index) {
+    const { list } = this;
+    if (index < 0) {
+      index += list.length;
+    }
+    return this.list.at(index);
+  }
+  /**
+   * 遍历所有存储数据(按入栈顺序)
+   */
+  forEach(callback) {
+    this.list.forEach(callback);
+    return this;
+  }
+  /**
+   * 遍历所有存储类型
+   */
+  forType(callback) {
+    const { memorys, list } = this;
+    for (const [type, memory] of memorys) {
+      const caches = this.#reflex(memory).map((index) => list[index]);
+      callback(caches, type);
+    }
+    return this;
+  }
+  /**
+   * some(按入栈顺序)
+   */
+  some(callback) {
+    return this.list.some(callback);
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    return this.list.map(callback);
+  }
+  /**
+   * reduce(按入栈顺序)
+   */
+  reduce(callback, initialValue) {
+    return this.list.reduce(callback, initialValue);
+  }
+  /**
+   * 判断存储是否包含指定类型
+   */
+  includes(type) {
+    return this.memorys.has(type);
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  get(type) {
+    const memory = this.memorys.get(type);
+    return memory === void 0 ? null : this.#reflex(memory).map((count) => this.list[count]);
+  }
+  /**
+   * 删除指定存储数据
+   */
+  delete(data) {
+    const { memorys, list } = this;
+    let index = -1;
+    if (!list.some((value, i) => {
+      if (data === value) {
+        index = i;
+        list.splice(index, 1);
+        const type = this.getType(value);
+        const memory = this.#reflex(memorys.get(type));
+        if (memory.length === 1) {
+          memorys.delete(type);
+        } else {
+          memory.some((count, j) => {
+            if (count === i) {
+              memory.splice(j, 1);
+              return true;
+            }
+          });
+        }
+        return true;
+      }
+    })) return this;
+    for (const [type, target] of memorys) {
+      const memory = this.#reflex(target);
+      memory.forEach((value, i) => {
+        if (value >= index) {
+          memory[i] = value - 1;
+        }
+      });
+      if (memory !== target) {
+        let reactor;
+        memory.forEach((count) => {
+          reactor = this.#mount(count, reactor);
+        });
+        memorys.set(type, reactor);
+      }
+    }
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    const { memorys, list } = this;
+    if (!memorys.has(type)) return this;
+    const local = hash8strings(this.#reflex(memorys.get(type)));
+    const Memory = this.constructor;
+    const imitator = new Memory(this.key, {
+      mount: this.#mount,
+      reflex: this.#reflex
+    });
+    list.forEach((data, index) => {
+      index in local || imitator.push(data);
+    });
+    this.list = imitator.list;
+    this.memorys = imitator.memorys;
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.list = [];
+    this.memorys.clear();
+  }
+};
+
+// src/memory/list.ts
+var MemoryList = class extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
+      reflex: (reactor) => reactor
+    });
+  }
+};
+
+// src/power/decon.ts
+var ERROR_MESSAGE = {
+  INT: "\u53C2\u6570\u5FC5\u987B\u662F\u6574\u6570",
+  MIN: "\u591A\u4E2A2\u7684\u6B63\u6574\u6570\u5E42(\u4E24\u4E24\u4E0D\u76F8\u7B49)\u4E4B\u548C\u5FC5\u5B9A\u5927\u4E8E\u7B49\u4E8E1"
+};
+var deconPowersSum = (sum, sort) => {
+  if (sum < 1) {
+    throw new Error(ERROR_MESSAGE.MIN);
+  } else if (sum !== Math.floor(sum)) {
+    throw new Error(ERROR_MESSAGE.INT);
+  }
+  const list = [];
+  let cache = sum;
+  while (cache) {
+    const power = Math.log2(cache) ^ 0;
+    list.push(power);
+    cache -= Math.pow(2, power);
+  }
+  return sort === "asc" ? list.reverse() : list;
+};
+
+// src/memory/power.ts
+var MemoryPower = class extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => (reactor || 0) + 2 ** index,
+      reflex: (reactor) => deconPowersSum(reactor, "asc")
+    });
+  }
+};
+
+// src/memory/simple.ts
+var MemorySimple = class {
+  #memory;
+  #key;
+  get size() {
+    return this.#memory.size;
+  }
+  constructor(key) {
+    this.#key = key;
+    this.#memory = new MemoryBasic(key, {
+      mount: (index) => index,
+      reflex: (reactor) => [reactor]
+    });
+  }
+  #getType(data) {
+    const key = this.#key;
+    return typeof key === "function" ? key(data) : data[key];
+  }
+  /**
+   * 返回位于指定索引处的项
+   */
+  at(index) {
+    return this.#memory.at(index);
+  }
+  push(...list) {
+    const memory = this.#memory;
+    list.forEach((data) => {
+      memory.includes(this.#getType(data)) || memory.push(data);
+    });
+    return this;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  get(type) {
+    const value = this.#memory.get(type);
+    if (value === null) return value;
+    return value.length ? value[0] : null;
+  }
+  /**
+   * 遍历所有存储数据(按入栈顺序)
+   */
+  forEach(callback) {
+    this.#memory.forEach(callback);
+    return this;
+  }
+  /**
+   * some(按入栈顺序)
+   */
+  some(callback) {
+    return this.#memory.some(callback);
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    return this.#memory.map(callback);
+  }
+  /**
+   * reduce(按入栈顺序)
+   */
+  reduce(callback, initialValue) {
+    return this.#memory.reduce(callback, initialValue);
+  }
+  /**
+   * 判断是否包含指定类型
+   */
+  includes(type) {
+    return this.#memory.includes(type);
+  }
+  /**
+   * 删除指定存储数据
+   */
+  delete(data) {
+    this.#memory.delete(data);
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    this.#memory.deleteType(type);
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.#memory.clear();
+  }
+};
+
+// src/rotate/rad.ts
+var rotateRad = (from, rad, visit = [0, 0]) => {
+  const x = from[0] - visit[0];
+  const y = from[1] - visit[1];
+  return [
+    x * Math.cos(rad) + y * Math.sin(rad) + visit[0],
+    y * Math.cos(rad) - x * Math.sin(rad) + visit[1]
+  ];
+};
+
+// src/neo4j-anchors.ts
+var Neo4jAhchors = class {
+  constructor(neo4j, config) {
+    this.neo4j = neo4j;
+    this.config = Object.assign({}, config);
+  }
+  config;
+  #anchors = {};
+  getDir(start, end) {
+    const { neo4j } = this;
+    return neo4j.dirKey({
+      [neo4j.sourceField]: start,
+      [neo4j.targetField]: end
+    });
+  }
+  /**
+   * 设置多边间隔弧长
+   */
+  setRaidx(value) {
+    this.config.radOffsetRaidx = value;
+  }
+  /**
+   * 当图数据准备好后调用
+   */
+  read() {
+    const { neo4j } = this;
+    const { nodeField, edgeField, sourceField, targetField } = neo4j;
+    const anchors = {};
+    neo4j.nodes.forEach((node) => {
+      const nodeId = node[nodeField];
+      let count = 0;
+      [
+        neo4j.sources.get(nodeId),
+        neo4j.targets.get(nodeId)
+      ].forEach((list, i) => {
+        if (!list) return;
+        let diffCount = 0;
+        let sameCount = 0;
+        list.forEach((edge) => {
+          const edgeId = edge[edgeField];
+          if (edge[sourceField] !== edge[targetField]) {
+            const anchor = anchors[edgeId] || (anchors[edgeId] = {});
+            anchor[i ? "target" : "source"] = count + diffCount++;
+          } else if (edgeId in anchors === false) {
+            anchors[edgeId] = {
+              source: sameCount,
+              target: sameCount++
+            };
+          }
+        });
+        count += diffCount;
+      });
+    });
+    this.#anchors = anchors;
+  }
+  calcPoints(edge, index, total, type) {
+    const { neo4j, config: { getBox, radOffsetRaidx = 0.3125 } } = this;
+    const source = getBox(edge[neo4j.sourceField]);
+    const target = getBox(edge[neo4j.targetField]);
+    const rad = Math.atan2(
+      (source.centerY - target.centerY) * type,
+      (source.centerX - target.centerX) * type
+    );
+    let point = rotateRad([0.5, 0], rad);
+    if (total !== 1) {
+      point = rotateRad(point, radOffsetRaidx * (total / 2 - 0.5 - index));
+    }
+    const [x, y] = point;
+    return [x + 0.5, 0.5 - y];
+  }
+  /**
+   * 获取指定节点上出入边连接点的坐标
+   */
+  getPoints(id) {
+    const { neo4j } = this;
+    const { dirs, edgeField, sourceField, targetField } = neo4j;
+    const anchors = this.#anchors;
+    const points = [];
+    const caches = {};
+    neo4j.sources.get(id)?.forEach((edge) => {
+      const source = edge[sourceField];
+      const target = edge[targetField];
+      const direct = this.getDir(source, target);
+      const invert = this.getDir(target, source);
+      if (direct in caches) return;
+      const directs = dirs.get(direct) || [];
+      const inverts = dirs.get(invert) || [];
+      const directsLength = directs.length;
+      const invertsLength = inverts.length;
+      const total = directsLength + invertsLength;
+      directs.forEach((data, index) => {
+        points[anchors[data[edgeField]].source] = this.calcPoints(data, directsLength - 1 - index, total, -1);
+      });
+      caches[direct] = direct;
+    });
+    neo4j.targets.get(id)?.forEach((edge) => {
+      const source = edge[sourceField];
+      const target = edge[targetField];
+      const direct = this.getDir(source, target);
+      const invert = this.getDir(target, source);
+      if (direct in caches) return;
+      const directs = neo4j.dirs.get(direct) || [];
+      const inverts = neo4j.dirs.get(invert) || [];
+      const directsLength = directs.length;
+      const invertsLength = inverts.length;
+      const total = directsLength + invertsLength;
+      directs.forEach((data, index) => {
+        points[anchors[data[edgeField]].target] = this.calcPoints(data, invertsLength + index, total, 1);
+      });
+      caches[direct] = direct;
+    });
+    return points;
+  }
+  /**
+   * 查找边连接点的位置
+   */
+  findAnchor(id) {
+    const anchor = this.#anchors[id];
+    if (!anchor) return null;
+    return {
+      source: anchor.source || 0,
+      target: anchor.target || 0
+    };
+  }
+  /**
+   * 获取指定边控制点距离两端点连线的距离(可理解为控制边的弯曲程度)
+   * @description 返回值是一个相对值，需要乘以一个基数值(基数值应为负值，如-30)
+   */
+  getOffset(id) {
+    const { neo4j } = this;
+    const edge = neo4j.edges.get(id);
+    if (!edge) return -1;
+    const { dirs, edgeField, sourceField, targetField } = neo4j;
+    const source = edge[sourceField];
+    const target = edge[targetField];
+    const directs = dirs.get(this.getDir(source, target)) || [];
+    const inverts = dirs.get(this.getDir(target, source)) || [];
+    let count = 0;
+    let index = 0;
+    [directs, inverts].some((list) => {
+      const result = list.some((data, i) => {
+        if (data[edgeField] === id) {
+          index = i + count;
+          return true;
+        }
+      });
+      count += list.length;
+      return result;
+    });
+    const directsSize = directs.length;
+    const invertsSize = inverts.length;
+    const total = directsSize + invertsSize;
+    if (total === 1) return -1;
+    if (directsSize === 0 || invertsSize === 0) {
+      return total / 2 - index - 0.5;
+    } else {
+      return Math.abs(directsSize - invertsSize) * (directsSize >= invertsSize ? 1 : -1) / 2 - index - 0.5;
+    }
+  }
+  /**
+   * 清理数据
+   */
+  clear() {
+    this.#anchors = {};
+  }
+};
+
+// src/neo4j.ts
+var Neo4j = class {
+  #nPrimaryKey;
+  #ePrimaryKey;
+  #sourceKey;
+  #targetKey;
+  #dirKey;
+  #nodes;
+  #edges;
+  #sources;
+  #targets;
+  #dirs;
+  get nodeField() {
+    return this.#nPrimaryKey;
+  }
+  get edgeField() {
+    return this.#ePrimaryKey;
+  }
+  get sourceField() {
+    return this.#sourceKey;
+  }
+  get targetField() {
+    return this.#targetKey;
+  }
+  get dirKey() {
+    return this.#dirKey;
+  }
+  /**
+   * 点视图
+   */
+  nodes;
+  /**
+   * 边视图
+   */
+  edges;
+  /**
+   * (边)出点视图
+   */
+  sources;
+  /**
+   * (边)入点视图
+   */
+  targets;
+  /**
+   * (边)方向视图
+   */
+  dirs;
+  constructor(nodeList, edgeList, {
+    nid,
+    eid,
+    sourceKey,
+    targetKey,
+    dir = (edge) => edge[sourceKey] + "|" + edge[targetKey]
+  }) {
+    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nPrimaryKey = nid));
+    shield(this, "edges", this.#edges = new MemorySimple(this.#ePrimaryKey = eid));
+    shield(this, "sources", this.#sources = new MemoryList(this.#sourceKey = sourceKey));
+    shield(this, "targets", this.#targets = new MemoryList(this.#targetKey = targetKey));
+    shield(this, "dirs", this.#dirs = new MemoryList(this.#dirKey = dir));
+    nodeList.forEach((node) => this.node("add", node));
+    edgeList.forEach((edge) => this.edge("add", edge));
+  }
+  node(type, value) {
+    const nodes = this.#nodes;
+    if (type === "add") {
+      nodes.push(value);
+    } else if (type === "delete") {
+      const node = nodes.get(value);
+      if (!node) return [];
+      nodes.delete(node);
+      const id = node[this.#nPrimaryKey];
+      const sourceKey = this.#sourceKey;
+      const targetKey = this.#targetKey;
+      const edges = this.#edges;
+      const sources = this.#sources;
+      const targets = this.#targets;
+      const dirs = this.#dirs;
+      const list = [];
+      sources.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        targets.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && sources.deleteType(id);
+      targets.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        sources.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && targets.deleteType(id);
+      return list;
+    }
+  }
+  edge(type, value) {
+    const sourceKey = this.#sourceKey;
+    const targetKey = this.#targetKey;
+    const edges = this.#edges;
+    const sources = this.#sources;
+    const targets = this.#targets;
+    const dirs = this.#dirs;
+    if (type === "add") {
+      const edge = value;
+      edges.push(edge);
+      sources.push(edge);
+      targets.push(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.push(edge);
+    } else if (type === "delete") {
+      const edge = edges.get(value);
+      if (!edge) return false;
+      edges.delete(edge);
+      sources.delete(edge);
+      targets.delete(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+      return true;
+    }
+  }
+  /**
+   * 清理图管理数据
+   */
+  clear() {
+    this.#nodes.clear();
+    this.#edges.clear();
+    this.#sources.clear();
+    this.#targets.clear();
+    this.#dirs.clear();
+  }
+};
+var shield_keys = hash8strings([
+  "push",
+  "delete",
+  "deleteType",
+  "clear"
+]);
+var shield = (obj, key, origin) => {
+  const proxy = new Proxy({}, {
+    get(target, p) {
+      if (p in shield_keys) return;
+      const value = origin[p];
+      if (typeof value === "function") {
+        return function(...args) {
+          const result = origin[p](...args);
+          return result === origin ? proxy : result;
+        };
+      } else {
+        return value;
+      }
+    }
+  });
+  Object.defineProperty(obj, key, {
+    get() {
+      return proxy;
+    }
+  });
+};
+
+// src/once.ts
+var once = (func, thisArg) => {
+  let local;
+  let inited = false;
+  return (...list) => inited ? local : (inited = true, local = func.apply(thisArg, list));
+};
+
+// src/parse/num.ts
+var pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
+var re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
+var parseNum = (num) => {
+  if (isNumber_default(num) || typeof num === "bigint") return num;
+  const match = num.match(re_num);
+  if (!match) return Number.NaN;
+  const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
+  if (bigint === "n") return BigInt(valueSymbol + integer);
+  const powSize = integer.length - 1 + (powValue ? powSymbol === "-" ? -powValue : +powValue : 0);
+  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < Number.MAX_SAFE_INTEGER / 10) return +num;
+  try {
+    const bigValue = BigInt(integer.slice(0, powSize + 1).padEnd(powSize + 1, "0"));
+    let smallValue;
+    if (decimal && powValue && powSymbol !== "-") {
+      const powNum = +powValue;
+      const effectDecimal = decimal.slice(0, Math.min(pow, powNum));
+      const tinyValue = decimal.length > pow && powNum > pow ? BigInt(+decimal.slice(pow, powNum)) * BigInt(10 ** Math.max(powNum - decimal.length, 0)) : BigInt(0);
+      smallValue = BigInt(effectDecimal) * BigInt(10 ** (powNum - effectDecimal.length)) + tinyValue;
+    } else {
+      smallValue = BigInt(0);
+    }
+    const value = bigValue + smallValue;
+    return valueSymbol === "-" ? value * BigInt(-1) : value;
+  } catch {
+    return Number.NaN;
+  }
+};
+
+// src/rotate/angle.ts
+var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
+
+// src/serialize/url-params.ts
+var cubes = {
+  string: (text) => text,
+  boolean: (text) => text === "true",
+  number: (text) => Number(text),
+  bigint: (text) => BigInt(text),
+  date: (text) => new Date(text),
+  regexp: (text) => new RegExp(text),
+  null: () => null
+};
+var flats = {
+  string: (data) => flatEncode(data),
+  boolean: (data) => `${data}`,
+  number: (data) => `${data}`,
+  bigint: (data) => `${data}`,
+  date: (data) => data.toJSON(),
+  regexp: (data) => flatEncode(data.source),
+  null: () => "null"
+};
+var cubeURLParams = (text, serializes) => {
+  const params = new URLSearchParams(text);
+  const result = {};
+  for (const [key, value] of params) {
+    const serialize = serializes[key];
+    if (!serialize) continue;
+    if (isString_default(serialize) && isKey(serialize, cubes)) {
+      result[key] = cubes[serialize](value);
+    } else {
+      result[key] = serialize.cube(value);
+    }
+  }
+  return result;
+};
+var re_flat = /\+/g;
+var flatEncode = (text) => text.replace(re_flat, () => "%2B");
+var flatURLParams = (data, serializes) => {
+  const params = new URLSearchParams();
+  for (const key in data) {
+    const value = data[key];
+    const serialize = serializes[key];
+    if (!serialize) continue;
+    params.append(
+      key,
+      isString_default(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+    );
+  }
+  return params.toString();
+};
+
+// src/style/css.ts
+var hump = /[A-Z]/g;
+var css = (...args) => {
+  const list = [];
+  for (let i = 0; i < args.length; i++) {
+    const data = args[i];
+    if (!data) continue;
+    if (isString_default(data)) {
+      list.push(data);
+    } else if (Array.isArray(data)) {
+      const result = css(...data);
+      result && list.push(result);
+    } else {
+      for (const key in data) {
+        const value = data[key];
+        isNull(value) || list.push(`${key.replace(hump, ($0) => "-" + $0.toLocaleLowerCase())}: ${value}`);
+      }
+    }
+  }
+  return list.join(";");
+};
+
+// src/subscriber.ts
+var Subscriber = class {
+  #listeners = {};
+  #once = {};
+  $on(name, listener) {
+    const listeners = this.#listeners;
+    if (name in listeners) {
+      listeners[name].push(listener);
+    } else {
+      listeners[name] = [listener];
+    }
+    return this;
+  }
+  $once(name, listener) {
+    this.$on(name, listener);
+    const index = this.#listeners[name].length - 1;
+    const once2 = this.#once;
+    if (name in once2) {
+      once2[name].push(index);
+    } else {
+      once2[name] = [index];
+    }
+    return this;
+  }
+  $emit(name, ...args) {
+    const listeners = this.#listeners[name];
+    if (!listeners) return this;
+    const once2 = hash8strings(this.#once[name] || []);
+    this.#listeners[name] = listeners.reduce((list, listener, index) => {
+      listener(...args);
+      index in once2 || list.push(listener);
+      return list;
+    }, []);
+    delete this.#once[name];
+    return this;
+  }
+  $off(name, listener) {
+    const listeners = this.#listeners;
+    const once2 = this.#once;
+    if (name in listeners === false) return this;
+    if (listener) {
+      let count;
+      listeners[name].some((value, index) => {
+        if (value === listener) {
+          count = index;
+          listeners[name].splice(index, 1);
+          return true;
+        }
+      }) && once2[name].some((value, index) => {
+        if (value === count) {
+          listeners[name].splice(index, 1);
+          return true;
+        }
+      });
+    } else {
+      delete listeners[name];
+      delete this.#once[name];
+    }
+    return this;
+  }
+};
+
+// src/table/flex.ts
+var FlexTable = class {
+  #data = [];
+  /**
+   * 行数
+   */
+  get rowspan() {
+    return this.#data.length;
+  }
+  /**
+   * 总数据长度
+   */
+  get length() {
+    return this.#data.reduce((length, list) => length + list.length, 0);
+  }
+  constructor() {
+    this.newline();
+  }
+  /**
+   * 创建新行
+   */
+  newline() {
+    this.#data.push([]);
+    return this;
+  }
+  push(value) {
+    const rowspan = this.#data.length;
+    rowspan || this.newline();
+    this.#data[rowspan - 1].push(value);
+    return this;
+  }
+  /**
+   * 替换指定位置的数据
+   * @description 指定位置必需为有效位置
+   */
+  replace(rowspan, colspan, value) {
+    const list = this.#data[rowspan];
+    list && colspan in list && (list[colspan] = value);
+    return this;
+  }
+  /**
+   * 从指定位置开始移除或者替换/添加元素
+   * @description 指定位置必需为有效位置
+   */
+  splice(rowspan, colspan, deleteCount, ...values) {
+    const list = this.#data[rowspan];
+    list && colspan in list && list.splice(colspan, deleteCount, ...values);
+    return this;
+  }
+  pop() {
+    const data = this.#data;
+    const rowspan = data.length;
+    if (!rowspan) return null;
+    const list = data[rowspan - 1];
+    if (list.length) {
+      return list.pop();
+    } else {
+      data.pop();
+      return this.pop();
+    }
+  }
+  /**
+   * 遍历数据
+   */
+  each(callback) {
+    const data = this.#data;
+    outloop: for (let i = 0; i < data.length; i++) {
+      const list = data[i];
+      for (let j = 0; j < list.length; j++) {
+        if (callback(list[j], i, j) === false) break outloop;
+      }
+    }
+  }
+  /**
+   * 反序遍历数据
+   */
+  reverseEach(callback) {
+    const data = this.#data;
+    outloop: for (let i = data.length; i; ) {
+      const list = data[--i];
+      for (let j = list.length; j; ) {
+        if (callback(list[--j], i, j) === false) break outloop;
+      }
+    }
+  }
+  /**
+   * 清空数据
+   */
+  clear() {
+    if (this.#data.length) {
+      this.#data = [];
+    }
+  }
+};
+
+// src/union.ts
+var Union = class {
+  constructor(key, formatter) {
+    this.key = key;
+    this.formatter = formatter;
+  }
+  #data = {};
+  #options = {};
+  #raws = {};
+  get data() {
+    return this.#data;
+  }
+  get options() {
+    return this.#options;
+  }
+  add(data) {
+    const key = data[this.key];
+    const result = this.formatter(data);
+    this.#raws[key] = data;
+    this.#data[key] = result.data;
+    this.#options[key] = result.option;
+    return this;
+  }
+  /**
+   * 获取原始数据
+   */
+  getRaw(key) {
+    return this.#raws[key];
+  }
+  /**
+   * 从已有的联合中拷贝数据
+   */
+  clone(target, key) {
+    const { data, options } = target;
+    const keys = Array.isArray(key) ? key : [key];
+    keys.forEach((key2) => {
+      if (key2 in data) {
+        this.#raws[key2] = target.getRaw(key2);
+        this.#data[key2] = data[key2];
+        this.#options[key2] = options[key2];
+      }
+    });
+    return this;
+  }
+};
+
+// src/url/join.ts
+var re = /([^:])\/{2,}/g;
+var joinPaths = (...list) => {
+  const { length } = list;
+  if (length === 0) return "";
+  return length === 1 ? list[0] : list.join("/").replace(re, ($0, $1) => `${$1}/`);
+};
+
+// src/url/params.ts
+var connectURLParams = (url, params, serializes) => {
+  const query = flatURLParams(params, serializes);
+  return query ? url.includes("?") ? url + "&" + query : url + "?" + query : url;
+};
+
+// src/wait.ts
+var wait = (delay = 0) => new Promise((resolve) => setTimeout(resolve, delay));
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/