import {
  camelCase_default,
  clamp_default,
  cloneDeep_default,
  clone_default,
  debounce_default,
  defaultsDeep_default,
  defaults_default,
  difference_default,
  groupBy_default,
  has_default,
  init_lodash,
  isEmpty_default,
  isEqual_default,
  isNumber_default,
  isObject_default,
  isPlainObject_default,
  lowerCase_default,
  lowerFirst_default,
  max_default,
  merge_default,
  pick_default,
  sortBy_default,
  sortedIndexBy_default,
  sortedIndex_default,
  startCase_default,
  throttle_default,
  union_default,
  uniq_default,
  uniqueId_default,
  upperCase_default,
  upperFirst_default
} from "./chunk-EYP3PCDD.js";
import {
  __esm,
  __export
} from "./chunk-LK32TJAX.js";

// node_modules/@antv/x6-common/es/common/disposable.js
var Disposable, DisposableDelegate, DisposableSet;
var init_disposable = __esm({
  "node_modules/@antv/x6-common/es/common/disposable.js"() {
    Disposable = class {
      get disposed() {
        return this._disposed === true;
      }
      dispose() {
        this._disposed = true;
      }
    };
    (function(Disposable2) {
      function dispose() {
        return (target, methodName, descriptor) => {
          const raw = descriptor.value;
          const proto = target.__proto__;
          descriptor.value = function(...args) {
            if (this.disposed) {
              return;
            }
            raw.call(this, ...args);
            proto.dispose.call(this);
          };
        };
      }
      Disposable2.dispose = dispose;
    })(Disposable || (Disposable = {}));
    DisposableDelegate = class {
      /**
       * Construct a new disposable delegate.
       *
       * @param callback - The callback function to invoke on dispose.
       */
      constructor(callback) {
        this.callback = callback;
      }
      /**
       * Test whether the delegate has been disposed.
       */
      get disposed() {
        return !this.callback;
      }
      /**
       * Dispose of the delegate and invoke the callback function.
       */
      dispose() {
        if (!this.callback) {
          return;
        }
        const callback = this.callback;
        this.callback = null;
        callback();
      }
    };
    DisposableSet = class {
      constructor() {
        this.isDisposed = false;
        this.items = /* @__PURE__ */ new Set();
      }
      /**
       * Test whether the set has been disposed.
       */
      get disposed() {
        return this.isDisposed;
      }
      /**
       * Dispose of the set and the items it contains.
       *
       * #### Notes
       * Items are disposed in the order they are added to the set.
       */
      dispose() {
        if (this.isDisposed) {
          return;
        }
        this.isDisposed = true;
        this.items.forEach((item) => {
          item.dispose();
        });
        this.items.clear();
      }
      /**
       * Test whether the set contains a specific item.
       *
       * @param item - The item of interest.
       *
       * @returns `true` if the set contains the item, `false` otherwise.
       */
      contains(item) {
        return this.items.has(item);
      }
      /**
       * Add a disposable item to the set.
       *
       * @param item - The item to add to the set.
       *
       * #### Notes
       * If the item is already contained in the set, this is a no-op.
       */
      add(item) {
        this.items.add(item);
      }
      /**
       * Remove a disposable item from the set.
       *
       * @param item - The item to remove from the set.
       *
       * #### Notes
       * If the item is not contained in the set, this is a no-op.
       */
      remove(item) {
        this.items.delete(item);
      }
      /**
       * Remove all items from the set.
       */
      clear() {
        this.items.clear();
      }
    };
    (function(DisposableSet2) {
      function from(items) {
        const set = new DisposableSet2();
        items.forEach((item) => {
          set.add(item);
        });
        return set;
      }
      DisposableSet2.from = from;
    })(DisposableSet || (DisposableSet = {}));
  }
});

// node_modules/@antv/x6-common/es/function/function.js
function apply(fn, ctx, args) {
  if (args) {
    switch (args.length) {
      case 0:
        return fn.call(ctx);
      case 1:
        return fn.call(ctx, args[0]);
      case 2:
        return fn.call(ctx, args[0], args[1]);
      case 3:
        return fn.call(ctx, args[0], args[1], args[2]);
      case 4:
        return fn.call(ctx, args[0], args[1], args[2], args[3]);
      case 5:
        return fn.call(ctx, args[0], args[1], args[2], args[3], args[4]);
      case 6:
        return fn.call(ctx, args[0], args[1], args[2], args[3], args[4], args[5]);
      default:
        return fn.apply(ctx, args);
    }
  }
  return fn.call(ctx);
}
function call(fn, ctx, ...args) {
  return apply(fn, ctx, args);
}
var init_function = __esm({
  "node_modules/@antv/x6-common/es/function/function.js"() {
    init_lodash();
  }
});

// node_modules/@antv/x6-common/es/function/async.js
function isAsyncLike(obj) {
  return typeof obj === "object" && obj.then && typeof obj.then === "function";
}
function isAsync(obj) {
  return obj != null && (obj instanceof Promise || isAsyncLike(obj));
}
function toAsyncBoolean(...inputs) {
  const results = [];
  inputs.forEach((arg) => {
    if (Array.isArray(arg)) {
      results.push(...arg);
    } else {
      results.push(arg);
    }
  });
  const hasAsync = results.some((res) => isAsync(res));
  if (hasAsync) {
    const deferres = results.map((res) => isAsync(res) ? res : Promise.resolve(res !== false));
    return Promise.all(deferres).then((arr) => arr.reduce((memo, item) => item !== false && memo, true));
  }
  return results.every((res) => res !== false);
}
function toDeferredBoolean(...inputs) {
  const ret = toAsyncBoolean(inputs);
  return typeof ret === "boolean" ? Promise.resolve(ret) : ret;
}
var init_async = __esm({
  "node_modules/@antv/x6-common/es/function/async.js"() {
  }
});

// node_modules/@antv/x6-common/es/function/main.js
var main_exports = {};
__export(main_exports, {
  apply: () => apply,
  call: () => call,
  debounce: () => debounce_default,
  isAsync: () => isAsync,
  isAsyncLike: () => isAsyncLike,
  throttle: () => throttle_default,
  toAsyncBoolean: () => toAsyncBoolean,
  toDeferredBoolean: () => toDeferredBoolean
});
var init_main = __esm({
  "node_modules/@antv/x6-common/es/function/main.js"() {
    init_function();
    init_async();
  }
});

// node_modules/@antv/x6-common/es/function/index.js
var init_function2 = __esm({
  "node_modules/@antv/x6-common/es/function/index.js"() {
    init_main();
  }
});

// node_modules/@antv/x6-common/es/event/util.js
function call2(list, args) {
  const results = [];
  for (let i = 0; i < list.length; i += 2) {
    const handler = list[i];
    const context = list[i + 1];
    const params = Array.isArray(args) ? args : [args];
    const ret = main_exports.apply(handler, context, params);
    results.push(ret);
  }
  return main_exports.toAsyncBoolean(results);
}
var init_util = __esm({
  "node_modules/@antv/x6-common/es/event/util.js"() {
    init_function2();
  }
});

// node_modules/@antv/x6-common/es/event/events.js
var Events;
var init_events = __esm({
  "node_modules/@antv/x6-common/es/event/events.js"() {
    init_util();
    init_function2();
    Events = class {
      constructor() {
        this.listeners = {};
      }
      on(name, handler, context) {
        if (handler == null) {
          return this;
        }
        if (!this.listeners[name]) {
          this.listeners[name] = [];
        }
        const cache = this.listeners[name];
        cache.push(handler, context);
        return this;
      }
      once(name, handler, context) {
        const cb = (...args) => {
          this.off(name, cb);
          return call2([handler, context], args);
        };
        return this.on(name, cb, this);
      }
      off(name, handler, context) {
        if (!(name || handler || context)) {
          this.listeners = {};
          return this;
        }
        const listeners = this.listeners;
        const names = name ? [name] : Object.keys(listeners);
        names.forEach((n) => {
          const cache = listeners[n];
          if (!cache) {
            return;
          }
          if (!(handler || context)) {
            delete listeners[n];
            return;
          }
          for (let i = cache.length - 2; i >= 0; i -= 2) {
            if (!(handler && cache[i] !== handler || context && cache[i + 1] !== context)) {
              cache.splice(i, 2);
            }
          }
        });
        return this;
      }
      trigger(name, ...args) {
        let returned = true;
        if (name !== "*") {
          const list2 = this.listeners[name];
          if (list2 != null) {
            returned = call2([...list2], args);
          }
        }
        const list = this.listeners["*"];
        if (list != null) {
          return main_exports.toAsyncBoolean([
            returned,
            call2([...list], [name, ...args])
          ]);
        }
        return returned;
      }
      emit(name, ...args) {
        return this.trigger(name, ...args);
      }
    };
  }
});

// node_modules/@antv/x6-common/es/object/mixins.js
function applyMixins(derivedCtor, ...baseCtors) {
  baseCtors.forEach((baseCtor) => {
    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
      if (name !== "constructor") {
        Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
      }
    });
  });
}
var init_mixins = __esm({
  "node_modules/@antv/x6-common/es/object/mixins.js"() {
  }
});

// node_modules/@antv/x6-common/es/object/inherit.js
function inherit(cls, base) {
  extendStatics(cls, base);
  function tmp() {
    this.constructor = cls;
  }
  cls.prototype = base === null ? Object.create(base) : (tmp.prototype = base.prototype, new tmp());
}
function createClass(className, base) {
  let cls;
  if (isNativeClass) {
    cls = class extends base {
    };
  } else {
    cls = function() {
      return base.apply(this, arguments);
    };
    inherit(cls, base);
  }
  Object.defineProperty(cls, "name", { value: className });
  return cls;
}
var extendStatics, A, isNativeClass;
var init_inherit = __esm({
  "node_modules/@antv/x6-common/es/object/inherit.js"() {
    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
      d.__proto__ = b;
    } || function(d, b) {
      for (const p in b) {
        if (Object.prototype.hasOwnProperty.call(b, p)) {
          d[p] = b[p];
        }
      }
    };
    A = class {
    };
    isNativeClass = /^\s*class\s+/.test(`${A}`) || /^\s*class\s*\{/.test(`${class {
    }}`);
  }
});

// node_modules/@antv/x6-common/es/object/object.js
var object_exports = {};
__export(object_exports, {
  applyMixins: () => applyMixins,
  clone: () => clone_default,
  cloneDeep: () => cloneDeep_default,
  createClass: () => createClass,
  defaults: () => defaults_default,
  defaultsDeep: () => defaultsDeep_default,
  ensure: () => ensure,
  flatten: () => flatten,
  getBoolean: () => getBoolean,
  getByPath: () => getByPath,
  getNumber: () => getNumber,
  getValue: () => getValue,
  has: () => has_default,
  inherit: () => inherit,
  isEmpty: () => isEmpty_default,
  isEqual: () => isEqual_default,
  isMaliciousProp: () => isMaliciousProp,
  isObject: () => isObject_default,
  isPlainObject: () => isPlainObject_default,
  merge: () => merge_default,
  pick: () => pick_default,
  setByPath: () => setByPath,
  unsetByPath: () => unsetByPath
});
function ensure(value, defaultValue) {
  return value != null ? value : defaultValue;
}
function getValue(obj, key, defaultValue) {
  const value = obj != null ? obj[key] : null;
  return defaultValue !== void 0 ? ensure(value, defaultValue) : value;
}
function getNumber(obj, key, defaultValue) {
  let value = obj != null ? obj[key] : null;
  if (value == null) {
    return defaultValue;
  }
  value = +value;
  if (Number.isNaN(value) || !Number.isFinite(value)) {
    return defaultValue;
  }
  return value;
}
function getBoolean(obj, key, defaultValue) {
  const value = obj != null ? obj[key] : null;
  if (value == null) {
    return defaultValue;
  }
  return !!value;
}
function isMaliciousProp(prop2) {
  return prop2 === "__proto__";
}
function getByPath(obj, path, delimiter = "/") {
  let ret;
  const keys = Array.isArray(path) ? path : path.split(delimiter);
  if (keys.length) {
    ret = obj;
    while (keys.length) {
      const key = keys.shift();
      if (Object(ret) === ret && key && key in ret) {
        ret = ret[key];
      } else {
        return void 0;
      }
    }
  }
  return ret;
}
function setByPath(obj, path, value, delimiter = "/") {
  const keys = Array.isArray(path) ? path : path.split(delimiter);
  const lastKey = keys.pop();
  if (lastKey && !isMaliciousProp(lastKey)) {
    let diver = obj;
    keys.forEach((key) => {
      if (!isMaliciousProp(key)) {
        if (diver[key] == null) {
          diver[key] = {};
        }
        diver = diver[key];
      }
    });
    diver[lastKey] = value;
  }
  return obj;
}
function unsetByPath(obj, path, delimiter = "/") {
  const keys = Array.isArray(path) ? path.slice() : path.split(delimiter);
  const propertyToRemove = keys.pop();
  if (propertyToRemove) {
    if (keys.length > 0) {
      const parent = getByPath(obj, keys);
      if (parent) {
        delete parent[propertyToRemove];
      }
    } else {
      delete obj[propertyToRemove];
    }
  }
  return obj;
}
function flatten(obj, delim = "/", stop) {
  const ret = {};
  Object.keys(obj).forEach((key) => {
    const val = obj[key];
    let deep = typeof val === "object" || Array.isArray(val);
    if (deep && stop && stop(val)) {
      deep = false;
    }
    if (deep) {
      const flatObject = flatten(val, delim, stop);
      Object.keys(flatObject).forEach((flatKey) => {
        ret[key + delim + flatKey] = flatObject[flatKey];
      });
    } else {
      ret[key] = val;
    }
  });
  for (const key in obj) {
    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
      continue;
    }
  }
  return ret;
}
var init_object = __esm({
  "node_modules/@antv/x6-common/es/object/object.js"() {
    init_lodash();
    init_mixins();
    init_inherit();
  }
});

// node_modules/@antv/x6-common/es/object/index.js
var init_object2 = __esm({
  "node_modules/@antv/x6-common/es/object/index.js"() {
    init_object();
  }
});

// node_modules/@antv/x6-common/es/event/index.js
var init_event = __esm({
  "node_modules/@antv/x6-common/es/event/index.js"() {
    init_events();
  }
});

// node_modules/@antv/x6-common/es/common/basecoat.js
var __decorate, Basecoat;
var init_basecoat = __esm({
  "node_modules/@antv/x6-common/es/common/basecoat.js"() {
    init_event();
    init_object2();
    init_disposable();
    __decorate = function(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
    };
    Basecoat = class extends Events {
      dispose() {
        this.off();
      }
    };
    __decorate([
      Disposable.dispose()
    ], Basecoat.prototype, "dispose", null);
    (function(Basecoat2) {
      Basecoat2.dispose = Disposable.dispose;
    })(Basecoat || (Basecoat = {}));
    object_exports.applyMixins(Basecoat, Disposable);
  }
});

// node_modules/@antv/x6-common/es/common/disablable.js
var Disablable;
var init_disablable = __esm({
  "node_modules/@antv/x6-common/es/common/disablable.js"() {
    init_basecoat();
    Disablable = class extends Basecoat {
      get disabled() {
        return this._disabled === true;
      }
      enable() {
        delete this._disabled;
      }
      disable() {
        this._disabled = true;
      }
    };
  }
});

// node_modules/@antv/x6-common/es/array/array.js
var array_exports = {};
__export(array_exports, {
  difference: () => difference_default,
  groupBy: () => groupBy_default,
  max: () => max_default,
  sortBy: () => sortBy_default,
  sortedIndex: () => sortedIndex_default,
  sortedIndexBy: () => sortedIndexBy_default,
  union: () => union_default,
  uniq: () => uniq_default
});
var init_array = __esm({
  "node_modules/@antv/x6-common/es/array/array.js"() {
    init_lodash();
  }
});

// node_modules/@antv/x6-common/es/array/index.js
var init_array2 = __esm({
  "node_modules/@antv/x6-common/es/array/index.js"() {
    init_array();
  }
});

// node_modules/@antv/x6-common/es/string/format.js
var cacheStringFunction, kebabCase, pascalCase, constantCase, dotCase, pathCase, sentenceCase, titleCase;
var init_format = __esm({
  "node_modules/@antv/x6-common/es/string/format.js"() {
    init_lodash();
    init_lodash();
    cacheStringFunction = (fn) => {
      const cache = /* @__PURE__ */ Object.create(null);
      return ((str) => {
        const hit = cache[str];
        return hit || (cache[str] = fn(str));
      });
    };
    kebabCase = cacheStringFunction((s) => s.replace(/\B([A-Z])/g, "-$1").toLowerCase());
    pascalCase = cacheStringFunction((s) => startCase_default(camelCase_default(s)).replace(/ /g, ""));
    constantCase = cacheStringFunction((s) => upperCase_default(s).replace(/ /g, "_"));
    dotCase = cacheStringFunction((s) => lowerCase_default(s).replace(/ /g, "."));
    pathCase = cacheStringFunction((s) => lowerCase_default(s).replace(/ /g, "/"));
    sentenceCase = cacheStringFunction((s) => upperFirst_default(lowerCase_default(s)));
    titleCase = cacheStringFunction((s) => startCase_default(camelCase_default(s)));
  }
});

// node_modules/@antv/x6-common/es/string/hashcode.js
function hashcode(str) {
  let hash = 2166136261;
  let isUnicoded = false;
  let string = str;
  for (let i = 0, ii = string.length; i < ii; i += 1) {
    let characterCode = string.charCodeAt(i);
    if (characterCode > 127 && !isUnicoded) {
      string = unescape(encodeURIComponent(string));
      characterCode = string.charCodeAt(i);
      isUnicoded = true;
    }
    hash ^= characterCode;
    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
  }
  return hash >>> 0;
}
var init_hashcode = __esm({
  "node_modules/@antv/x6-common/es/string/hashcode.js"() {
  }
});

// node_modules/@antv/x6-common/es/string/uuid.js
function uuid() {
  let res = "";
  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
  for (let i = 0, len = template.length; i < len; i += 1) {
    const s = template[i];
    const r = Math.random() * 16 | 0;
    const v = s === "x" ? r : s === "y" ? r & 3 | 8 : s;
    res += v.toString(16);
  }
  return res;
}
var init_uuid = __esm({
  "node_modules/@antv/x6-common/es/string/uuid.js"() {
  }
});

// node_modules/@antv/x6-common/es/string/suggestion.js
function getSpellingSuggestion(name, candidates, getName) {
  const maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
  let bestDistance = Math.floor(name.length * 0.4) + 1;
  let bestCandidate;
  let justCheckExactMatches = false;
  const nameLowerCase = name.toLowerCase();
  for (const candidate of candidates) {
    const candidateName = getName(candidate);
    if (candidateName !== void 0 && Math.abs(candidateName.length - nameLowerCase.length) <= maximumLengthDifference) {
      const candidateNameLowerCase = candidateName.toLowerCase();
      if (candidateNameLowerCase === nameLowerCase) {
        if (candidateName === name) {
          continue;
        }
        return candidate;
      }
      if (justCheckExactMatches) {
        continue;
      }
      if (candidateName.length < 3) {
        continue;
      }
      const distance = levenshteinWithMax(nameLowerCase, candidateNameLowerCase, bestDistance - 1);
      if (distance === void 0) {
        continue;
      }
      if (distance < 3) {
        justCheckExactMatches = true;
        bestCandidate = candidate;
      } else {
        bestDistance = distance;
        bestCandidate = candidate;
      }
    }
  }
  return bestCandidate;
}
function levenshteinWithMax(s1, s2, max) {
  let previous = new Array(s2.length + 1);
  let current = new Array(s2.length + 1);
  const big = max + 1;
  for (let i = 0; i <= s2.length; i += 1) {
    previous[i] = i;
  }
  for (let i = 1; i <= s1.length; i += 1) {
    const c1 = s1.charCodeAt(i - 1);
    const minJ = i > max ? i - max : 1;
    const maxJ = s2.length > max + i ? max + i : s2.length;
    current[0] = i;
    let colMin = i;
    for (let j = 1; j < minJ; j += 1) {
      current[j] = big;
    }
    for (let j = minJ; j <= maxJ; j += 1) {
      const dist = c1 === s2.charCodeAt(j - 1) ? previous[j - 1] : Math.min(
        /* delete */
        previous[j] + 1,
        /* insert */
        current[j - 1] + 1,
        /* substitute */
        previous[j - 1] + 2
      );
      current[j] = dist;
      colMin = Math.min(colMin, dist);
    }
    for (let j = maxJ + 1; j <= s2.length; j += 1) {
      current[j] = big;
    }
    if (colMin > max) {
      return void 0;
    }
    const temp = previous;
    previous = current;
    current = temp;
  }
  const res = previous[s2.length];
  return res > max ? void 0 : res;
}
var init_suggestion = __esm({
  "node_modules/@antv/x6-common/es/string/suggestion.js"() {
  }
});

// node_modules/@antv/x6-common/es/string/string.js
var string_exports = {};
__export(string_exports, {
  camelCase: () => camelCase_default,
  constantCase: () => constantCase,
  dotCase: () => dotCase,
  getSpellingSuggestion: () => getSpellingSuggestion,
  hashcode: () => hashcode,
  kebabCase: () => kebabCase,
  lowerFirst: () => lowerFirst_default,
  pascalCase: () => pascalCase,
  pathCase: () => pathCase,
  sentenceCase: () => sentenceCase,
  titleCase: () => titleCase,
  uniqueId: () => uniqueId_default,
  upperFirst: () => upperFirst_default,
  uuid: () => uuid
});
var init_string = __esm({
  "node_modules/@antv/x6-common/es/string/string.js"() {
    init_lodash();
    init_format();
    init_hashcode();
    init_uuid();
    init_suggestion();
  }
});

// node_modules/@antv/x6-common/es/string/index.js
var init_string2 = __esm({
  "node_modules/@antv/x6-common/es/string/index.js"() {
    init_string();
  }
});

// node_modules/@antv/x6-common/es/number/number.js
var number_exports = {};
__export(number_exports, {
  clamp: () => clamp_default,
  isNumber: () => isNumber_default,
  isPercentage: () => isPercentage,
  mod: () => mod,
  normalizePercentage: () => normalizePercentage,
  normalizeSides: () => normalizeSides,
  parseCssNumeric: () => parseCssNumeric,
  random: () => random
});
function mod(n, m) {
  return (n % m + m) % m;
}
function random(lower, upper) {
  if (upper == null) {
    upper = lower == null ? 1 : lower;
    lower = 0;
  } else if (upper < lower) {
    const tmp = lower;
    lower = upper;
    upper = tmp;
  }
  return Math.floor(Math.random() * (upper - lower + 1) + lower);
}
function isPercentage(val) {
  return typeof val === "string" && val.slice(-1) === "%";
}
function normalizePercentage(num, ref) {
  if (num == null) {
    return 0;
  }
  let raw;
  if (typeof num === "string") {
    raw = parseFloat(num);
    if (isPercentage(num)) {
      raw /= 100;
      if (Number.isFinite(raw)) {
        return raw * ref;
      }
    }
  } else {
    raw = num;
  }
  if (!Number.isFinite(raw)) {
    return 0;
  }
  if (raw > 0 && raw < 1) {
    return raw * ref;
  }
  return raw;
}
function parseCssNumeric(val, units) {
  function getUnit(regexp2) {
    const matches = new RegExp(`(?:\\d+(?:\\.\\d+)*)(${regexp2})$`).exec(val);
    if (!matches) {
      return null;
    }
    return matches[1];
  }
  const number = parseFloat(val);
  if (Number.isNaN(number)) {
    return null;
  }
  let regexp;
  if (units == null) {
    regexp = "[A-Za-z]*";
  } else if (Array.isArray(units)) {
    if (units.length === 0) {
      return null;
    }
    regexp = units.join("|");
  } else if (typeof units === "string") {
    regexp = units;
  }
  const unit = getUnit(regexp);
  if (unit === null) {
    return null;
  }
  return {
    unit,
    value: number
  };
}
function normalizeSides(box) {
  if (typeof box === "object") {
    let left = 0;
    let top = 0;
    let right = 0;
    let bottom = 0;
    if (box.vertical != null && Number.isFinite(box.vertical)) {
      top = bottom = box.vertical;
    }
    if (box.horizontal != null && Number.isFinite(box.horizontal)) {
      right = left = box.horizontal;
    }
    if (box.left != null && Number.isFinite(box.left))
      left = box.left;
    if (box.top != null && Number.isFinite(box.top))
      top = box.top;
    if (box.right != null && Number.isFinite(box.right))
      right = box.right;
    if (box.bottom != null && Number.isFinite(box.bottom))
      bottom = box.bottom;
    return { top, right, bottom, left };
  }
  let val = 0;
  if (box != null && Number.isFinite(box)) {
    val = box;
  }
  return { top: val, right: val, bottom: val, left: val };
}
var init_number = __esm({
  "node_modules/@antv/x6-common/es/number/number.js"() {
    init_lodash();
  }
});

// node_modules/@antv/x6-common/es/number/index.js
var init_number2 = __esm({
  "node_modules/@antv/x6-common/es/number/index.js"() {
    init_number();
  }
});

// node_modules/@antv/x6-common/es/platform/index.js
var _IS_MAC, _IS_IOS, _IS_WINDOWS, _IS_IE, _IS_IE11, _IS_EDGE, _IS_NETSCAPE, _IS_CHROME_APP, _IS_CHROME, _IS_OPERA, _IS_FIREFOX, _IS_SAFARI, _SUPPORT_TOUCH, _SUPPORT_POINTER, _SUPPORT_PASSIVE, _NO_FOREIGNOBJECT, Platform;
var init_platform = __esm({
  "node_modules/@antv/x6-common/es/platform/index.js"() {
    _IS_MAC = false;
    _IS_IOS = false;
    _IS_WINDOWS = false;
    _IS_IE = false;
    _IS_IE11 = false;
    _IS_EDGE = false;
    _IS_NETSCAPE = false;
    _IS_CHROME_APP = false;
    _IS_CHROME = false;
    _IS_OPERA = false;
    _IS_FIREFOX = false;
    _IS_SAFARI = false;
    _SUPPORT_TOUCH = false;
    _SUPPORT_POINTER = false;
    _SUPPORT_PASSIVE = false;
    _NO_FOREIGNOBJECT = false;
    if (typeof navigator === "object") {
      const ua = navigator.userAgent;
      _IS_MAC = ua.indexOf("Macintosh") >= 0;
      _IS_IOS = !!ua.match(/(iPad|iPhone|iPod)/g);
      _IS_WINDOWS = ua.indexOf("Windows") >= 0;
      _IS_IE = ua.indexOf("MSIE") >= 0;
      _IS_IE11 = !!ua.match(/Trident\/7\./);
      _IS_EDGE = !!ua.match(/Edge\//);
      _IS_NETSCAPE = ua.indexOf("Mozilla/") >= 0 && ua.indexOf("MSIE") < 0 && ua.indexOf("Edge/") < 0;
      _IS_CHROME = ua.indexOf("Chrome/") >= 0 && ua.indexOf("Edge/") < 0;
      _IS_OPERA = ua.indexOf("Opera/") >= 0 || ua.indexOf("OPR/") >= 0;
      _IS_FIREFOX = ua.indexOf("Firefox/") >= 0;
      _IS_SAFARI = ua.indexOf("AppleWebKit/") >= 0 && ua.indexOf("Chrome/") < 0 && ua.indexOf("Edge/") < 0;
      if (typeof document === "object") {
        _NO_FOREIGNOBJECT = !document.createElementNS || `${document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")}` !== "[object SVGForeignObjectElement]" || ua.indexOf("Opera/") >= 0;
      }
    }
    if (typeof window === "object") {
      _IS_CHROME_APP = window.chrome != null && window.chrome.app != null && window.chrome.app.runtime != null;
      _SUPPORT_POINTER = window.PointerEvent != null && !_IS_MAC;
    }
    if (typeof document === "object") {
      _SUPPORT_TOUCH = "ontouchstart" in document.documentElement;
      try {
        const options = Object.defineProperty({}, "passive", {
          get() {
            _SUPPORT_PASSIVE = true;
          }
        });
        const div = document.createElement("div");
        if (div.addEventListener) {
          div.addEventListener("click", () => {
          }, options);
        }
      } catch (err) {
      }
    }
    (function(Platform2) {
      Platform2.IS_MAC = _IS_MAC;
      Platform2.IS_IOS = _IS_IOS;
      Platform2.IS_WINDOWS = _IS_WINDOWS;
      Platform2.IS_IE = _IS_IE;
      Platform2.IS_IE11 = _IS_IE11;
      Platform2.IS_EDGE = _IS_EDGE;
      Platform2.IS_NETSCAPE = _IS_NETSCAPE;
      Platform2.IS_CHROME_APP = _IS_CHROME_APP;
      Platform2.IS_CHROME = _IS_CHROME;
      Platform2.IS_OPERA = _IS_OPERA;
      Platform2.IS_FIREFOX = _IS_FIREFOX;
      Platform2.IS_SAFARI = _IS_SAFARI;
      Platform2.SUPPORT_TOUCH = _SUPPORT_TOUCH;
      Platform2.SUPPORT_POINTER = _SUPPORT_POINTER;
      Platform2.SUPPORT_PASSIVE = _SUPPORT_PASSIVE;
      Platform2.NO_FOREIGNOBJECT = _NO_FOREIGNOBJECT;
      Platform2.SUPPORT_FOREIGNOBJECT = !Platform2.NO_FOREIGNOBJECT;
    })(Platform || (Platform = {}));
    (function(Platform2) {
      function getHMRStatus() {
        const mod3 = window.module;
        if (mod3 != null && mod3.hot != null && mod3.hot.status != null) {
          return mod3.hot.status();
        }
        return "unkonwn";
      }
      Platform2.getHMRStatus = getHMRStatus;
      function isApplyingHMR() {
        return getHMRStatus() === "apply";
      }
      Platform2.isApplyingHMR = isApplyingHMR;
      const TAGNAMES = {
        select: "input",
        change: "input",
        submit: "form",
        reset: "form",
        error: "img",
        load: "img",
        abort: "img"
      };
      function isEventSupported(event) {
        const elem = document.createElement(TAGNAMES[event] || "div");
        const eventName = `on${event}`;
        let isSupported = eventName in elem;
        if (!isSupported) {
          elem.setAttribute(eventName, "return;");
          isSupported = typeof elem[eventName] === "function";
        }
        return isSupported;
      }
      Platform2.isEventSupported = isEventSupported;
    })(Platform || (Platform = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/class.js
function getClass(elem) {
  return elem && elem.getAttribute && elem.getAttribute("class") || "";
}
function hasClass(elem, selector) {
  if (elem == null || selector == null) {
    return false;
  }
  const classNames = fillSpaces(getClass(elem));
  const className = fillSpaces(selector);
  return elem.nodeType === 1 ? classNames.replace(rclass, " ").includes(className) : false;
}
function addClass(elem, selector) {
  if (elem == null || selector == null) {
    return;
  }
  if (typeof selector === "function") {
    return addClass(elem, selector(getClass(elem)));
  }
  if (typeof selector === "string" && elem.nodeType === 1) {
    const classes = selector.match(rnotwhite) || [];
    const oldValue = fillSpaces(getClass(elem)).replace(rclass, " ");
    let newValue = classes.reduce((memo, cls) => {
      if (memo.indexOf(fillSpaces(cls)) < 0) {
        return `${memo}${cls} `;
      }
      return memo;
    }, oldValue);
    newValue = newValue.trim();
    if (oldValue !== newValue) {
      elem.setAttribute("class", newValue);
    }
  }
}
function removeClass(elem, selector) {
  if (elem == null) {
    return;
  }
  if (typeof selector === "function") {
    return removeClass(elem, selector(getClass(elem)));
  }
  if ((!selector || typeof selector === "string") && elem.nodeType === 1) {
    const classes = (selector || "").match(rnotwhite) || [];
    const oldValue = fillSpaces(getClass(elem)).replace(rclass, " ");
    let newValue = classes.reduce((memo, cls) => {
      const className = fillSpaces(cls);
      if (memo.indexOf(className) > -1) {
        return memo.replace(className, " ");
      }
      return memo;
    }, oldValue);
    newValue = selector ? newValue.trim() : "";
    if (oldValue !== newValue) {
      elem.setAttribute("class", newValue);
    }
  }
}
function toggleClass(elem, selector, stateVal) {
  if (elem == null || selector == null) {
    return;
  }
  if (stateVal != null && typeof selector === "string") {
    stateVal ? addClass(elem, selector) : removeClass(elem, selector);
    return;
  }
  if (typeof selector === "function") {
    return toggleClass(elem, selector(getClass(elem), stateVal), stateVal);
  }
  if (typeof selector === "string") {
    const metches = selector.match(rnotwhite) || [];
    metches.forEach((cls) => {
      hasClass(elem, cls) ? removeClass(elem, cls) : addClass(elem, cls);
    });
  }
}
var rclass, rnotwhite, fillSpaces;
var init_class = __esm({
  "node_modules/@antv/x6-common/es/dom/class.js"() {
    rclass = /[\t\r\n\f]/g;
    rnotwhite = /\S+/g;
    fillSpaces = (str) => ` ${str} `;
  }
});

// node_modules/@antv/x6-common/es/dom/elem.js
function uniqueId() {
  idCounter += 1;
  return `v${idCounter}`;
}
function ensureId(elem) {
  if (elem.id == null || elem.id === "") {
    elem.id = uniqueId();
  }
  return elem.id;
}
function isSVGGraphicsElement(elem) {
  if (elem == null) {
    return false;
  }
  return typeof elem.getScreenCTM === "function" && elem instanceof SVGElement;
}
function createElement(tagName2, doc = document) {
  return doc.createElement(tagName2);
}
function createElementNS(tagName2, namespaceURI = ns.xhtml, doc = document) {
  return doc.createElementNS(namespaceURI, tagName2);
}
function createSvgElement(tagName2, doc = document) {
  return createElementNS(tagName2, ns.svg, doc);
}
function createSvgDocument(content) {
  if (content) {
    const xml = `<svg xmlns="${ns.svg}" xmlns:xlink="${ns.xlink}" version="${svgVersion}">${content}</svg>`;
    const { documentElement } = parseXML(xml, { async: false });
    return documentElement;
  }
  const svg = document.createElementNS(ns.svg, "svg");
  svg.setAttributeNS(ns.xmlns, "xmlns:xlink", ns.xlink);
  svg.setAttribute("version", svgVersion);
  return svg;
}
function parseXML(data2, options = {}) {
  let xml;
  try {
    const parser = new DOMParser();
    if (options.async != null) {
      const instance = parser;
      instance.async = options.async;
    }
    xml = parser.parseFromString(data2, options.mimeType || "text/xml");
  } catch (error) {
    xml = void 0;
  }
  if (!xml || xml.getElementsByTagName("parsererror").length) {
    throw new Error(`Invalid XML: ${data2}`);
  }
  return xml;
}
function tagName(node, lowercase = true) {
  const nodeName = node.nodeName;
  return lowercase ? nodeName.toLowerCase() : nodeName.toUpperCase();
}
function index(elem) {
  let index2 = 0;
  let node = elem.previousSibling;
  while (node) {
    if (node.nodeType === 1) {
      index2 += 1;
    }
    node = node.previousSibling;
  }
  return index2;
}
function find(elem, selector) {
  return elem.querySelectorAll(selector);
}
function findOne(elem, selector) {
  return elem.querySelector(selector);
}
function findParentByClass(elem, className, terminator) {
  const ownerSVGElement = elem.ownerSVGElement;
  let node = elem.parentNode;
  while (node && node !== terminator && node !== ownerSVGElement) {
    if (hasClass(node, className)) {
      return node;
    }
    node = node.parentNode;
  }
  return null;
}
function contains(parent, child) {
  const bup = child && child.parentNode;
  return parent === bup || !!(bup && bup.nodeType === 1 && parent.compareDocumentPosition(bup) & 16);
}
function remove(elem) {
  if (elem) {
    const elems = Array.isArray(elem) ? elem : [elem];
    elems.forEach((item) => {
      if (item.parentNode) {
        item.parentNode.removeChild(item);
      }
    });
  }
}
function empty(elem) {
  while (elem.firstChild) {
    elem.removeChild(elem.firstChild);
  }
}
function append(elem, elems) {
  const arr = Array.isArray(elems) ? elems : [elems];
  arr.forEach((child) => {
    if (child != null) {
      elem.appendChild(child);
    }
  });
}
function prepend(elem, elems) {
  const child = elem.firstChild;
  return child ? before(child, elems) : append(elem, elems);
}
function before(elem, elems) {
  const parent = elem.parentNode;
  if (parent) {
    const arr = Array.isArray(elems) ? elems : [elems];
    arr.forEach((child) => {
      if (child != null) {
        parent.insertBefore(child, elem);
      }
    });
  }
}
function after(elem, elems) {
  const parent = elem.parentNode;
  if (parent) {
    const arr = Array.isArray(elems) ? elems : [elems];
    arr.forEach((child) => {
      if (child != null) {
        parent.insertBefore(child, elem.nextSibling);
      }
    });
  }
}
function appendTo(elem, target) {
  if (target != null) {
    target.appendChild(elem);
  }
}
function isElement(x) {
  return !!x && x.nodeType === 1;
}
function isHTMLElement(elem) {
  try {
    return elem instanceof HTMLElement;
  } catch (e) {
    return typeof elem === "object" && elem.nodeType === 1 && typeof elem.style === "object" && typeof elem.ownerDocument === "object";
  }
}
function children(parent, className) {
  const matched = [];
  let elem = parent.firstChild;
  for (; elem; elem = elem.nextSibling) {
    if (elem.nodeType === 1) {
      if (!className || hasClass(elem, className)) {
        matched.push(elem);
      }
    }
  }
  return matched;
}
var idCounter, ns, svgVersion;
var init_elem = __esm({
  "node_modules/@antv/x6-common/es/dom/elem.js"() {
    init_class();
    idCounter = 0;
    ns = {
      svg: "http://www.w3.org/2000/svg",
      xmlns: "http://www.w3.org/2000/xmlns/",
      xml: "http://www.w3.org/XML/1998/namespace",
      xlink: "http://www.w3.org/1999/xlink",
      xhtml: "http://www.w3.org/1999/xhtml"
    };
    svgVersion = "1.1";
  }
});

// node_modules/@antv/x6-common/es/dom/attr.js
function getAttribute(elem, name) {
  return elem.getAttribute(name);
}
function removeAttribute(elem, name) {
  const qualified = qualifyAttr(name);
  if (qualified.ns) {
    if (elem.hasAttributeNS(qualified.ns, qualified.local)) {
      elem.removeAttributeNS(qualified.ns, qualified.local);
    }
  } else if (elem.hasAttribute(name)) {
    elem.removeAttribute(name);
  }
}
function setAttribute(elem, name, value) {
  if (value == null) {
    return removeAttribute(elem, name);
  }
  const qualified = qualifyAttr(name);
  if (qualified.ns && typeof value === "string") {
    elem.setAttributeNS(qualified.ns, name, value);
  } else if (name === "id") {
    elem.id = `${value}`;
  } else {
    elem.setAttribute(name, `${value}`);
  }
}
function setAttributes(elem, attrs) {
  Object.keys(attrs).forEach((name) => {
    setAttribute(elem, name, attrs[name]);
  });
}
function attr(elem, name, value) {
  if (name == null) {
    const attrs = elem.attributes;
    const ret = {};
    for (let i = 0; i < attrs.length; i += 1) {
      ret[attrs[i].name] = attrs[i].value;
    }
    return ret;
  }
  if (typeof name === "string" && value === void 0) {
    return elem.getAttribute(name);
  }
  if (typeof name === "object") {
    setAttributes(elem, name);
  } else {
    setAttribute(elem, name, value);
  }
}
function qualifyAttr(name) {
  if (name.indexOf(":") !== -1) {
    const combinedKey = name.split(":");
    return {
      ns: ns[combinedKey[0]],
      local: combinedKey[1]
    };
  }
  return {
    ns: null,
    local: name
  };
}
function kebablizeAttrs(attrs) {
  const result = {};
  Object.keys(attrs).forEach((key) => {
    const name = CASE_SENSITIVE_ATTR.includes(key) ? key : kebabCase(key);
    result[name] = attrs[key];
  });
  return result;
}
function styleToObject(styleString) {
  const ret = {};
  const styles = styleString.split(";");
  styles.forEach((item) => {
    const section = item.trim();
    if (section) {
      const pair = section.split("=");
      if (pair.length) {
        ret[pair[0].trim()] = pair[1] ? pair[1].trim() : "";
      }
    }
  });
  return ret;
}
function mergeAttrs(target, source) {
  Object.keys(source).forEach((attr2) => {
    if (attr2 === "class") {
      target[attr2] = target[attr2] ? `${target[attr2]} ${source[attr2]}` : source[attr2];
    } else if (attr2 === "style") {
      const to = typeof target[attr2] === "object";
      const so = typeof source[attr2] === "object";
      let tt;
      let ss;
      if (to && so) {
        tt = target[attr2];
        ss = source[attr2];
      } else if (to) {
        tt = target[attr2];
        ss = styleToObject(source[attr2]);
      } else if (so) {
        tt = styleToObject(target[attr2]);
        ss = source[attr2];
      } else {
        tt = styleToObject(target[attr2]);
        ss = styleToObject(source[attr2]);
      }
      target[attr2] = mergeAttrs(tt, ss);
    } else {
      target[attr2] = source[attr2];
    }
  });
  return target;
}
var CASE_SENSITIVE_ATTR;
var init_attr = __esm({
  "node_modules/@antv/x6-common/es/dom/attr.js"() {
    init_elem();
    init_format();
    CASE_SENSITIVE_ATTR = [
      "viewBox",
      "attributeName",
      "attributeType",
      "repeatCount",
      "textLength",
      "lengthAdjust",
      "gradientUnits"
    ];
  }
});

// node_modules/@antv/x6-common/es/text/annotate.js
function annotate(t, annotations, opt = {}) {
  const offset2 = opt.offset || 0;
  const compacted = [];
  const ret = [];
  let curr;
  let prev;
  let batch = null;
  for (let i = 0; i < t.length; i += 1) {
    curr = ret[i] = t[i];
    for (let j = 0, jj = annotations.length; j < jj; j += 1) {
      const annotation = annotations[j];
      const start = annotation.start + offset2;
      const end = annotation.end + offset2;
      if (i >= start && i < end) {
        if (typeof curr === "string") {
          curr = ret[i] = {
            t: t[i],
            attrs: annotation.attrs
          };
        } else {
          curr.attrs = mergeAttrs(mergeAttrs({}, curr.attrs), annotation.attrs);
        }
        if (opt.includeAnnotationIndices) {
          if (curr.annotations == null) {
            curr.annotations = [];
          }
          curr.annotations.push(j);
        }
      }
    }
    prev = ret[i - 1];
    if (!prev) {
      batch = curr;
    } else if (object_exports.isObject(curr) && object_exports.isObject(prev)) {
      batch = batch;
      if (JSON.stringify(curr.attrs) === JSON.stringify(prev.attrs)) {
        batch.t += curr.t;
      } else {
        compacted.push(batch);
        batch = curr;
      }
    } else if (object_exports.isObject(curr)) {
      batch = batch;
      compacted.push(batch);
      batch = curr;
    } else if (object_exports.isObject(prev)) {
      batch = batch;
      compacted.push(batch);
      batch = curr;
    } else {
      batch = (batch || "") + curr;
    }
  }
  if (batch != null) {
    compacted.push(batch);
  }
  return compacted;
}
function findAnnotationsAtIndex(annotations, index2) {
  return annotations ? annotations.filter((a) => a.start < index2 && index2 <= a.end) : [];
}
function findAnnotationsBetweenIndexes(annotations, start, end) {
  return annotations ? annotations.filter((a) => start >= a.start && start < a.end || end > a.start && end <= a.end || a.start >= start && a.end < end) : [];
}
function shiftAnnotations(annotations, index2, offset2) {
  if (annotations) {
    annotations.forEach((a) => {
      if (a.start < index2 && a.end >= index2) {
        a.end += offset2;
      } else if (a.start >= index2) {
        a.start += offset2;
        a.end += offset2;
      }
    });
  }
  return annotations;
}
var init_annotate = __esm({
  "node_modules/@antv/x6-common/es/text/annotate.js"() {
    init_object2();
    init_attr();
  }
});

// node_modules/@antv/x6-common/es/text/sanitize.js
function sanitize(text2) {
  return text2.replace(/ /g, " ");
}
var init_sanitize = __esm({
  "node_modules/@antv/x6-common/es/text/sanitize.js"() {
  }
});

// node_modules/@antv/x6-common/es/text/main.js
var main_exports2 = {};
__export(main_exports2, {
  annotate: () => annotate,
  findAnnotationsAtIndex: () => findAnnotationsAtIndex,
  findAnnotationsBetweenIndexes: () => findAnnotationsBetweenIndexes,
  sanitize: () => sanitize,
  shiftAnnotations: () => shiftAnnotations
});
var init_main2 = __esm({
  "node_modules/@antv/x6-common/es/text/main.js"() {
    init_annotate();
    init_sanitize();
  }
});

// node_modules/@antv/x6-common/es/text/index.js
var init_text = __esm({
  "node_modules/@antv/x6-common/es/text/index.js"() {
    init_main2();
  }
});

// node_modules/@antv/x6-common/es/datauri/index.js
var DataUri;
var init_datauri = __esm({
  "node_modules/@antv/x6-common/es/datauri/index.js"() {
    (function(DataUri2) {
      function isDataUrl(url) {
        const prefix = "data:";
        return url.substr(0, prefix.length) === prefix;
      }
      DataUri2.isDataUrl = isDataUrl;
      function imageToDataUri(url, callback) {
        if (!url || isDataUrl(url)) {
          setTimeout(() => callback(null, url));
          return;
        }
        const onError = () => {
          callback(new Error(`Failed to load image: ${url}`));
        };
        const onLoad = window.FileReader ? (
          // chrome, IE10+
          (xhr2) => {
            if (xhr2.status === 200) {
              const reader = new FileReader();
              reader.onload = (evt) => {
                const dataUri = evt.target.result;
                callback(null, dataUri);
              };
              reader.onerror = onError;
              reader.readAsDataURL(xhr2.response);
            } else {
              onError();
            }
          }
        ) : (xhr2) => {
          const toString = (u8a) => {
            const CHUNK_SZ = 32768;
            const c = [];
            for (let i = 0; i < u8a.length; i += CHUNK_SZ) {
              c.push(String.fromCharCode.apply(null, u8a.subarray(i, i + CHUNK_SZ)));
            }
            return c.join("");
          };
          if (xhr2.status === 200) {
            let suffix = url.split(".").pop() || "png";
            if (suffix === "svg") {
              suffix = "svg+xml";
            }
            const meta = `data:image/${suffix};base64,`;
            const bytes = new Uint8Array(xhr2.response);
            const base64 = meta + btoa(toString(bytes));
            callback(null, base64);
          } else {
            onError();
          }
        };
        const xhr = new XMLHttpRequest();
        xhr.responseType = window.FileReader ? "blob" : "arraybuffer";
        xhr.open("GET", url, true);
        xhr.addEventListener("error", onError);
        xhr.addEventListener("load", () => onLoad(xhr));
        xhr.send();
      }
      DataUri2.imageToDataUri = imageToDataUri;
      function dataUriToBlob(dataUrl) {
        let uri = dataUrl.replace(/\s/g, "");
        uri = decodeURIComponent(uri);
        const index2 = uri.indexOf(",");
        const dataType = uri.slice(0, index2);
        const mime = dataType.split(":")[1].split(";")[0];
        const data2 = uri.slice(index2 + 1);
        let decodedString;
        if (dataType.indexOf("base64") >= 0) {
          decodedString = atob(data2);
        } else {
          decodedString = unescape(encodeURIComponent(data2));
        }
        const ia = new Uint8Array(decodedString.length);
        for (let i = 0; i < decodedString.length; i += 1) {
          ia[i] = decodedString.charCodeAt(i);
        }
        return new Blob([ia], { type: mime });
      }
      DataUri2.dataUriToBlob = dataUriToBlob;
      function downloadBlob(blob, fileName) {
        const msSaveBlob = window.navigator.msSaveBlob;
        if (msSaveBlob) {
          msSaveBlob(blob, fileName);
        } else {
          const url = window.URL.createObjectURL(blob);
          const link = document.createElement("a");
          link.href = url;
          link.download = fileName;
          document.body.appendChild(link);
          link.click();
          document.body.removeChild(link);
          window.URL.revokeObjectURL(url);
        }
      }
      DataUri2.downloadBlob = downloadBlob;
      function downloadDataUri(dataUrl, fileName) {
        const blob = dataUriToBlob(dataUrl);
        downloadBlob(blob, fileName);
      }
      DataUri2.downloadDataUri = downloadDataUri;
      function parseViewBox(svg) {
        const matches = svg.match(/<svg[^>]*viewBox\s*=\s*(["']?)(.+?)\1[^>]*>/i);
        if (matches && matches[2]) {
          return matches[2].replace(/\s+/, " ").split(" ");
        }
        return null;
      }
      function getNumber2(str) {
        const ret = parseFloat(str);
        return Number.isNaN(ret) ? null : ret;
      }
      function svgToDataUrl(svg, options = {}) {
        let viewBox = null;
        const getNumberFromViewBox = (index2) => {
          if (viewBox == null) {
            viewBox = parseViewBox(svg);
          }
          if (viewBox != null) {
            return getNumber2(viewBox[index2]);
          }
          return null;
        };
        const getNumberFromMatches = (reg) => {
          const matches = svg.match(reg);
          if (matches && matches[2]) {
            return getNumber2(matches[2]);
          }
          return null;
        };
        let w = options.width;
        if (w == null) {
          w = getNumberFromMatches(/<svg[^>]*width\s*=\s*(["']?)(.+?)\1[^>]*>/i);
        }
        if (w == null) {
          w = getNumberFromViewBox(2);
        }
        if (w == null) {
          throw new Error("Can not parse width from svg string");
        }
        let h = options.height;
        if (h == null) {
          h = getNumberFromMatches(/<svg[^>]*height\s*=\s*(["']?)(.+?)\1[^>]*>/i);
        }
        if (h == null) {
          h = getNumberFromViewBox(3);
        }
        if (h == null) {
          throw new Error("Can not parse height from svg string");
        }
        const decoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
        const header = "data:image/svg+xml";
        const dataUrl = `${header},${decoded}`;
        return dataUrl;
      }
      DataUri2.svgToDataUrl = svgToDataUrl;
    })(DataUri || (DataUri = {}));
  }
});

// node_modules/@antv/x6-common/es/unit/index.js
var millimeterSize, supportedUnits, Unit;
var init_unit = __esm({
  "node_modules/@antv/x6-common/es/unit/index.js"() {
    supportedUnits = {
      px(val) {
        return val;
      },
      mm(val) {
        return millimeterSize * val;
      },
      cm(val) {
        return millimeterSize * val * 10;
      },
      in(val) {
        return millimeterSize * val * 25.4;
      },
      pt(val) {
        return millimeterSize * (25.4 * val / 72);
      },
      pc(val) {
        return millimeterSize * (25.4 * val / 6);
      }
    };
    (function(Unit2) {
      function measure(cssWidth, cssHeight, unit) {
        const div = document.createElement("div");
        const style = div.style;
        style.display = "inline-block";
        style.position = "absolute";
        style.left = "-15000px";
        style.top = "-15000px";
        style.width = cssWidth + (unit || "px");
        style.height = cssHeight + (unit || "px");
        document.body.appendChild(div);
        const rect = div.getBoundingClientRect();
        const size = {
          width: rect.width || 0,
          height: rect.height || 0
        };
        document.body.removeChild(div);
        return size;
      }
      Unit2.measure = measure;
      function toPx(val, unit) {
        if (millimeterSize == null) {
          millimeterSize = measure("1", "1", "mm").width;
        }
        const convert = unit ? supportedUnits[unit] : null;
        if (convert) {
          return convert(val);
        }
        return val;
      }
      Unit2.toPx = toPx;
    })(Unit || (Unit = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/prefix.js
function camelize(str) {
  return str.replace(hyphenPattern, (_, char) => char.toUpperCase());
}
function getWithPrefix(name) {
  for (let i = 0; i < prefixes.length; i += 1) {
    const prefixedName = prefixes[i] + name;
    if (prefixedName in testStyle) {
      return prefixedName;
    }
  }
  return null;
}
function getVendorPrefixedName(property) {
  const name = camelize(property);
  if (memoized[name] == null) {
    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
    memoized[name] = name in testStyle ? name : getWithPrefix(capitalizedName);
  }
  return memoized[name];
}
var hyphenPattern, memoized, prefixes, testStyle;
var init_prefix = __esm({
  "node_modules/@antv/x6-common/es/dom/prefix.js"() {
    hyphenPattern = /-(.)/g;
    memoized = {};
    prefixes = ["webkit", "ms", "moz", "o"];
    testStyle = typeof document !== "undefined" ? document.createElement("div").style : {};
  }
});

// node_modules/@antv/x6-common/es/dom/style.js
function setPrefixedStyle(style, name, value) {
  const vendor = getVendorPrefixedName(name);
  if (vendor != null) {
    style[vendor] = value;
  }
  style[name] = value;
}
function getComputedStyle2(elem, name) {
  const computed = elem.ownerDocument && elem.ownerDocument.defaultView && elem.ownerDocument.defaultView.opener ? elem.ownerDocument.defaultView.getComputedStyle(elem, null) : window.getComputedStyle(elem, null);
  if (computed && name) {
    return computed.getPropertyValue(name) || computed[name];
  }
  return computed;
}
function hasScrollbars(container) {
  const style = getComputedStyle2(container);
  return style != null && (style.overflow === "scroll" || style.overflow === "auto");
}
var init_style = __esm({
  "node_modules/@antv/x6-common/es/dom/style.js"() {
    init_prefix();
  }
});

// node_modules/@antv/x6-common/es/dom/selection.js
var clearSelection;
var init_selection = __esm({
  "node_modules/@antv/x6-common/es/dom/selection.js"() {
    clearSelection = (function() {
      if (typeof document == "undefined")
        return function() {
        };
      const doc = document;
      if (doc.selection) {
        return function() {
          doc.selection.empty();
        };
      }
      if (window.getSelection) {
        return function() {
          const selection = window.getSelection();
          if (selection) {
            if (selection.empty) {
              selection.empty();
            } else if (selection.removeAllRanges) {
              selection.removeAllRanges();
            }
          }
        };
      }
      return function() {
      };
    })();
  }
});

// node_modules/@antv/x6-common/es/dom/css.js
function isCSSVariable(prop2) {
  return /^--/.test(prop2);
}
function computeStyle(elem, prop2, isVariable) {
  const style = window.getComputedStyle(elem, null);
  return isVariable ? style.getPropertyValue(prop2) || void 0 : style[prop2] || elem.style[prop2];
}
function computeStyleInt(elem, prop2) {
  return parseInt(computeStyle(elem, prop2), 10) || 0;
}
function getSuffixedValue(prop2, value) {
  return !numericProps[prop2] && typeof value === "number" ? `${value}px` : value;
}
function css(elem, prop2, value) {
  if (typeof prop2 === "string") {
    const isVariable = isCSSVariable(prop2);
    if (!isVariable) {
      prop2 = getVendorPrefixedName(prop2);
    }
    if (value === void 0) {
      return computeStyle(elem, prop2, isVariable);
    }
    if (!isVariable) {
      value = getSuffixedValue(prop2, value);
    }
    const style = elem.style;
    if (isVariable) {
      style.setProperty(prop2, value);
    } else {
      style[prop2] = value;
    }
    return;
  }
  for (const key in prop2) {
    css(elem, key, prop2[key]);
  }
}
var numericProps;
var init_css = __esm({
  "node_modules/@antv/x6-common/es/dom/css.js"() {
    init_prefix();
    numericProps = {
      animationIterationCount: true,
      columnCount: true,
      flexGrow: true,
      flexShrink: true,
      fontWeight: true,
      gridArea: true,
      gridColumn: true,
      gridColumnEnd: true,
      gridColumnStart: true,
      gridRow: true,
      gridRowEnd: true,
      gridRowStart: true,
      lineHeight: true,
      opacity: true,
      order: true,
      orphans: true,
      widows: true,
      zIndex: true
    };
  }
});

// node_modules/@antv/x6-common/es/dom/data.js
function getData(elem, name) {
  const key = string_exports.camelCase(name);
  const cache = dataset.get(elem);
  if (cache) {
    return cache[key];
  }
}
function setData(elem, name, value) {
  const key = string_exports.camelCase(name);
  const cache = dataset.get(elem);
  if (cache) {
    cache[key] = value;
  } else {
    dataset.set(elem, {
      [key]: value
    });
  }
}
function data(elem, name, value) {
  if (!name) {
    const datas = {};
    Object.keys(dataset).forEach((key) => {
      datas[key] = getData(elem, key);
    });
    return datas;
  }
  if (typeof name === "string") {
    if (value === void 0) {
      return getData(elem, name);
    }
    setData(elem, name, value);
    return;
  }
  for (const key in name) {
    data(elem, key, name[key]);
  }
}
var dataset;
var init_data = __esm({
  "node_modules/@antv/x6-common/es/dom/data.js"() {
    init_string2();
    dataset = /* @__PURE__ */ new WeakMap();
  }
});

// node_modules/@antv/x6-common/es/dom/prop.js
function prop(elem, props, value) {
  if (!props) {
    return;
  }
  if (typeof props === "string") {
    props = propMap[props] || props;
    if (arguments.length < 3) {
      return elem[props];
    }
    ;
    elem[props] = value;
    return;
  }
  for (const key in props) {
    prop(elem, key, props[key]);
  }
}
var propMap;
var init_prop = __esm({
  "node_modules/@antv/x6-common/es/dom/prop.js"() {
    propMap = {
      /* GENERAL */
      class: "className",
      contenteditable: "contentEditable",
      /* LABEL */
      for: "htmlFor",
      /* INPUT */
      readonly: "readOnly",
      maxlength: "maxLength",
      tabindex: "tabIndex",
      /* TABLE */
      colspan: "colSpan",
      rowspan: "rowSpan",
      /* IMAGE */
      usemap: "useMap"
    };
  }
});

// node_modules/@antv/x6-common/es/dom/text.js
function createTextPathNode(attrs, elem) {
  const vel = Vector.create(elem);
  const textPath = Vector.create("textPath");
  const d = attrs.d;
  if (d && attrs["xlink:href"] === void 0) {
    const path = Vector.create("path").attr("d", d).appendTo(vel.defs());
    textPath.attr("xlink:href", `#${path.id}`);
  }
  if (typeof attrs === "object") {
    textPath.attr(attrs);
  }
  return textPath.node;
}
function annotateTextLine(lineNode, lineAnnotations, options) {
  const eol = options.eol;
  const baseSize = options.baseSize;
  const lineHeight = options.lineHeight;
  let maxFontSize = 0;
  let tspanNode;
  const fontMetrics = {};
  const lastJ = lineAnnotations.length - 1;
  for (let j = 0; j <= lastJ; j += 1) {
    let annotation = lineAnnotations[j];
    let fontSize = null;
    if (typeof annotation === "object") {
      const annotationAttrs = annotation.attrs;
      const vTSpan = Vector.create("tspan", annotationAttrs);
      tspanNode = vTSpan.node;
      let t = annotation.t;
      if (eol && j === lastJ) {
        t += eol;
      }
      tspanNode.textContent = t;
      const annotationClass = annotationAttrs.class;
      if (annotationClass) {
        vTSpan.addClass(annotationClass);
      }
      if (options.includeAnnotationIndices) {
        vTSpan.attr("annotations", annotation.annotations.join(","));
      }
      fontSize = parseFloat(annotationAttrs["font-size"]);
      if (fontSize === void 0)
        fontSize = baseSize;
      if (fontSize && fontSize > maxFontSize)
        maxFontSize = fontSize;
    } else {
      if (eol && j === lastJ) {
        annotation += eol;
      }
      tspanNode = document.createTextNode(annotation || " ");
      if (baseSize && baseSize > maxFontSize) {
        maxFontSize = baseSize;
      }
    }
    lineNode.appendChild(tspanNode);
  }
  if (maxFontSize) {
    fontMetrics.maxFontSize = maxFontSize;
  }
  if (lineHeight) {
    fontMetrics.lineHeight = lineHeight;
  } else if (maxFontSize) {
    fontMetrics.lineHeight = maxFontSize * 1.2;
  }
  return fontMetrics;
}
function emToPx(em, fontSize) {
  const numerical = parseFloat(em);
  if (emRegex.test(em)) {
    return numerical * fontSize;
  }
  return numerical;
}
function calculateDY(alignment, linesMetrics, baseSizePx, lineHeight) {
  if (!Array.isArray(linesMetrics)) {
    return 0;
  }
  const n = linesMetrics.length;
  if (!n)
    return 0;
  let lineMetrics = linesMetrics[0];
  const flMaxFont = emToPx(lineMetrics.maxFontSize, baseSizePx) || baseSizePx;
  let rLineHeights = 0;
  const lineHeightPx = emToPx(lineHeight, baseSizePx);
  for (let i = 1; i < n; i += 1) {
    lineMetrics = linesMetrics[i];
    const iLineHeight = emToPx(lineMetrics.lineHeight, baseSizePx) || lineHeightPx;
    rLineHeights += iLineHeight;
  }
  const llMaxFont = emToPx(lineMetrics.maxFontSize, baseSizePx) || baseSizePx;
  let dy;
  switch (alignment) {
    case "middle":
      dy = flMaxFont / 2 - 0.15 * llMaxFont - rLineHeights / 2;
      break;
    case "bottom":
      dy = -(0.25 * llMaxFont) - rLineHeights;
      break;
    case "top":
    default:
      dy = 0.8 * flMaxFont;
      break;
  }
  return dy;
}
function text(elem, content, options = {}) {
  content = main_exports2.sanitize(content);
  const eol = options.eol;
  let textPath = options.textPath;
  const verticalAnchor = options.textVerticalAnchor;
  const namedVerticalAnchor = verticalAnchor === "middle" || verticalAnchor === "bottom" || verticalAnchor === "top";
  let x = options.x;
  if (x === void 0) {
    x = elem.getAttribute("x") || 0;
  }
  const iai = options.includeAnnotationIndices;
  let annotations = options.annotations;
  if (annotations && !Array.isArray(annotations)) {
    annotations = [annotations];
  }
  const defaultLineHeight = options.lineHeight;
  const autoLineHeight = defaultLineHeight === "auto";
  const lineHeight = autoLineHeight ? "1.5em" : defaultLineHeight || "1em";
  let needEmpty = true;
  const childNodes = elem.childNodes;
  if (childNodes.length === 1) {
    const node = childNodes[0];
    if (node && node.tagName.toUpperCase() === "TITLE") {
      needEmpty = false;
    }
  }
  if (needEmpty) {
    empty(elem);
  }
  attr(elem, {
    // Preserve spaces, do not consecutive spaces to get collapsed to one.
    "xml:space": "preserve",
    // An empty text gets rendered into the DOM in webkit-based browsers.
    // In order to unify this behaviour across all browsers
    // we rather hide the text element when it's empty.
    display: content || options.displayEmpty ? null : "none"
  });
  const strFontSize = attr(elem, "font-size");
  let fontSize = parseFloat(strFontSize);
  if (!fontSize) {
    fontSize = 16;
    if ((namedVerticalAnchor || annotations) && !strFontSize) {
      attr(elem, "font-size", `${fontSize}`);
    }
  }
  let containerNode;
  if (textPath) {
    if (typeof textPath === "string") {
      textPath = { d: textPath };
    }
    containerNode = createTextPathNode(textPath, elem);
  } else {
    containerNode = document.createDocumentFragment();
  }
  let dy;
  let offset2 = 0;
  let annotatedY;
  const lines = content.split("\n");
  const linesMetrics = [];
  const lastI = lines.length - 1;
  for (let i = 0; i <= lastI; i += 1) {
    dy = lineHeight;
    let lineClassName = "v-line";
    const lineNode = createSvgElement("tspan");
    let lineMetrics;
    let line = lines[i];
    if (line) {
      if (annotations) {
        const lineAnnotations = main_exports2.annotate(line, annotations, {
          offset: -offset2,
          includeAnnotationIndices: iai
        });
        lineMetrics = annotateTextLine(lineNode, lineAnnotations, {
          eol: i !== lastI && eol,
          baseSize: fontSize,
          lineHeight: autoLineHeight ? null : lineHeight,
          includeAnnotationIndices: iai
        });
        const iLineHeight = lineMetrics.lineHeight;
        if (iLineHeight && autoLineHeight && i !== 0) {
          dy = iLineHeight;
        }
        if (i === 0) {
          annotatedY = lineMetrics.maxFontSize * 0.8;
        }
      } else {
        if (eol && i !== lastI) {
          line += eol;
        }
        lineNode.textContent = line;
      }
    } else {
      lineNode.textContent = "-";
      lineClassName += " v-empty-line";
      const lineNodeStyle = lineNode.style;
      lineNodeStyle.fillOpacity = 0;
      lineNodeStyle.strokeOpacity = 0;
      if (annotations) {
        lineMetrics = {};
      }
    }
    if (lineMetrics) {
      linesMetrics.push(lineMetrics);
    }
    if (i > 0) {
      lineNode.setAttribute("dy", dy);
    }
    if (i > 0 || textPath) {
      lineNode.setAttribute("x", x);
    }
    lineNode.className.baseVal = lineClassName;
    containerNode.appendChild(lineNode);
    offset2 += line.length + 1;
  }
  if (namedVerticalAnchor) {
    if (annotations) {
      dy = calculateDY(verticalAnchor, linesMetrics, fontSize, lineHeight);
    } else if (verticalAnchor === "top") {
      dy = "0.8em";
    } else {
      let rh;
      if (lastI > 0) {
        rh = parseFloat(lineHeight) || 1;
        rh *= lastI;
        if (!emRegex.test(lineHeight))
          rh /= fontSize;
      } else {
        rh = 0;
      }
      switch (verticalAnchor) {
        case "middle":
          dy = `${0.3 - rh / 2}em`;
          break;
        case "bottom":
          dy = `${-rh - 0.3}em`;
          break;
        default:
          break;
      }
    }
  } else if (verticalAnchor === 0) {
    dy = "0em";
  } else if (verticalAnchor) {
    dy = verticalAnchor;
  } else {
    dy = 0;
    if (elem.getAttribute("y") == null) {
      elem.setAttribute("y", `${annotatedY || "0.8em"}`);
    }
  }
  const firstLine = containerNode.firstChild;
  firstLine.setAttribute("dy", dy);
  elem.appendChild(containerNode);
}
function measureText(text2, styles = {}) {
  const canvasContext = document.createElement("canvas").getContext("2d");
  if (!text2) {
    return { width: 0 };
  }
  const font = [];
  const fontSize = styles["font-size"] ? `${parseFloat(styles["font-size"])}px` : "14px";
  font.push(styles["font-style"] || "normal");
  font.push(styles["font-variant"] || "normal");
  font.push(styles["font-weight"] || 400);
  font.push(fontSize);
  font.push(styles["font-family"] || "sans-serif");
  canvasContext.font = font.join(" ");
  return canvasContext.measureText(text2);
}
function splitTextByLength(text2, splitWidth, totalWidth, style = {}) {
  if (splitWidth >= totalWidth) {
    return [text2, ""];
  }
  const length = text2.length;
  const caches = {};
  let index2 = Math.round(splitWidth / totalWidth * length - 1);
  if (index2 < 0) {
    index2 = 0;
  }
  while (index2 >= 0 && index2 < length) {
    const frontText = text2.slice(0, index2);
    const frontWidth = caches[frontText] || measureText(frontText, style).width;
    const behindText = text2.slice(0, index2 + 1);
    const behindWidth = caches[behindText] || measureText(behindText, style).width;
    caches[frontText] = frontWidth;
    caches[behindText] = behindWidth;
    if (frontWidth > splitWidth) {
      index2 -= 1;
    } else if (behindWidth <= splitWidth) {
      index2 += 1;
    } else {
      break;
    }
  }
  return [text2.slice(0, index2), text2.slice(index2)];
}
function breakText(text2, size, styles = {}, options = {}) {
  const width2 = size.width;
  const height2 = size.height;
  const eol = options.eol || "\n";
  const fontSize = styles.fontSize || 14;
  const lineHeight = styles.lineHeight ? parseFloat(styles.lineHeight) : Math.ceil(fontSize * 1.4);
  const maxLines = Math.floor(height2 / lineHeight);
  if (text2.indexOf(eol) > -1) {
    const delimiter = string_exports.uuid();
    const splitText = [];
    text2.split(eol).map((line) => {
      const part = breakText(line, Object.assign(Object.assign({}, size), { height: Number.MAX_SAFE_INTEGER }), styles, Object.assign(Object.assign({}, options), { eol: delimiter }));
      if (part) {
        splitText.push(...part.split(delimiter));
      }
    });
    return splitText.slice(0, maxLines).join(eol);
  }
  const { width: textWidth } = measureText(text2, styles);
  if (textWidth < width2) {
    return text2;
  }
  const lines = [];
  let remainText = text2;
  let remainWidth = textWidth;
  let ellipsis = options.ellipsis;
  let ellipsisWidth = 0;
  if (ellipsis) {
    if (typeof ellipsis !== "string") {
      ellipsis = "…";
    }
    ellipsisWidth = measureText(ellipsis, styles).width;
  }
  for (let i = 0; i < maxLines; i += 1) {
    if (remainWidth > width2) {
      const isLast = i === maxLines - 1;
      if (isLast) {
        const [front] = splitTextByLength(remainText, width2 - ellipsisWidth, remainWidth, styles);
        lines.push(ellipsis ? `${front}${ellipsis}` : front);
      } else {
        const [front, behind] = splitTextByLength(remainText, width2, remainWidth, styles);
        lines.push(front);
        remainText = behind;
        remainWidth = measureText(remainText, styles).width;
      }
    } else {
      lines.push(remainText);
      break;
    }
  }
  return lines.join(eol);
}
var emRegex;
var init_text2 = __esm({
  "node_modules/@antv/x6-common/es/dom/text.js"() {
    init_string2();
    init_text();
    init_attr();
    init_vector();
    init_elem();
    emRegex = /em$/;
  }
});

// node_modules/@antv/x6-common/es/dom/path.js
function getNumbericAttribute(elem, attr2, defaultValue = NaN) {
  const v = elem.getAttribute(attr2);
  if (v == null) {
    return defaultValue;
  }
  const n = parseFloat(v);
  return Number.isNaN(n) ? defaultValue : n;
}
function sample(elem, interval = 1) {
  const length = elem.getTotalLength();
  const samples = [];
  let distance = 0;
  let sample2;
  while (distance < length) {
    sample2 = elem.getPointAtLength(distance);
    samples.push({ distance, x: sample2.x, y: sample2.y });
    distance += interval;
  }
  return samples;
}
function lineToPathData(line) {
  return [
    "M",
    getNumbericAttribute(line, "x1"),
    getNumbericAttribute(line, "y1"),
    "L",
    getNumbericAttribute(line, "x2"),
    getNumbericAttribute(line, "y2")
  ].join(" ");
}
function polygonToPathData(polygon) {
  const points = getPointsFromSvgElement(polygon);
  if (points.length === 0) {
    return null;
  }
  return `${svgPointsToPath(points)} Z`;
}
function polylineToPathData(polyline) {
  const points = getPointsFromSvgElement(polyline);
  if (points.length === 0) {
    return null;
  }
  return svgPointsToPath(points);
}
function svgPointsToPath(points) {
  const arr = points.map((p) => `${p.x} ${p.y}`);
  return `M ${arr.join(" L")}`;
}
function getPointsFromSvgElement(elem) {
  const points = [];
  const nodePoints = elem.points;
  if (nodePoints) {
    for (let i = 0, ii = nodePoints.numberOfItems; i < ii; i += 1) {
      points.push(nodePoints.getItem(i));
    }
  }
  return points;
}
function circleToPathData(circle) {
  const cx = getNumbericAttribute(circle, "cx", 0);
  const cy = getNumbericAttribute(circle, "cy", 0);
  const r = getNumbericAttribute(circle, "r");
  const cd = r * KAPPA;
  return [
    "M",
    cx,
    cy - r,
    "C",
    cx + cd,
    cy - r,
    cx + r,
    cy - cd,
    cx + r,
    cy,
    "C",
    cx + r,
    cy + cd,
    cx + cd,
    cy + r,
    cx,
    cy + r,
    "C",
    cx - cd,
    cy + r,
    cx - r,
    cy + cd,
    cx - r,
    cy,
    "C",
    cx - r,
    cy - cd,
    cx - cd,
    cy - r,
    cx,
    cy - r,
    "Z"
  ].join(" ");
}
function ellipseToPathData(ellipse) {
  const cx = getNumbericAttribute(ellipse, "cx", 0);
  const cy = getNumbericAttribute(ellipse, "cy", 0);
  const rx = getNumbericAttribute(ellipse, "rx");
  const ry = getNumbericAttribute(ellipse, "ry") || rx;
  const cdx = rx * KAPPA;
  const cdy = ry * KAPPA;
  const d = [
    "M",
    cx,
    cy - ry,
    "C",
    cx + cdx,
    cy - ry,
    cx + rx,
    cy - cdy,
    cx + rx,
    cy,
    "C",
    cx + rx,
    cy + cdy,
    cx + cdx,
    cy + ry,
    cx,
    cy + ry,
    "C",
    cx - cdx,
    cy + ry,
    cx - rx,
    cy + cdy,
    cx - rx,
    cy,
    "C",
    cx - rx,
    cy - cdy,
    cx - cdx,
    cy - ry,
    cx,
    cy - ry,
    "Z"
  ].join(" ");
  return d;
}
function rectangleToPathData(rect) {
  return rectToPathData({
    x: getNumbericAttribute(rect, "x", 0),
    y: getNumbericAttribute(rect, "y", 0),
    width: getNumbericAttribute(rect, "width", 0),
    height: getNumbericAttribute(rect, "height", 0),
    rx: getNumbericAttribute(rect, "rx", 0),
    ry: getNumbericAttribute(rect, "ry", 0)
  });
}
function rectToPathData(r) {
  let d;
  const x = r.x;
  const y = r.y;
  const width2 = r.width;
  const height2 = r.height;
  const topRx = Math.min(r.rx || r["top-rx"] || 0, width2 / 2);
  const bottomRx = Math.min(r.rx || r["bottom-rx"] || 0, width2 / 2);
  const topRy = Math.min(r.ry || r["top-ry"] || 0, height2 / 2);
  const bottomRy = Math.min(r.ry || r["bottom-ry"] || 0, height2 / 2);
  if (topRx || bottomRx || topRy || bottomRy) {
    d = [
      "M",
      x,
      y + topRy,
      "v",
      height2 - topRy - bottomRy,
      "a",
      bottomRx,
      bottomRy,
      0,
      0,
      0,
      bottomRx,
      bottomRy,
      "h",
      width2 - 2 * bottomRx,
      "a",
      bottomRx,
      bottomRy,
      0,
      0,
      0,
      bottomRx,
      -bottomRy,
      "v",
      -(height2 - bottomRy - topRy),
      "a",
      topRx,
      topRy,
      0,
      0,
      0,
      -topRx,
      -topRy,
      "h",
      -(width2 - 2 * topRx),
      "a",
      topRx,
      topRy,
      0,
      0,
      0,
      -topRx,
      topRy,
      "Z"
    ];
  } else {
    d = ["M", x, y, "H", x + width2, "V", y + height2, "H", x, "V", y, "Z"];
  }
  return d.join(" ");
}
function toPath(elem) {
  const path = createSvgElement("path");
  attr(path, attr(elem));
  const d = toPathData(elem);
  if (d) {
    path.setAttribute("d", d);
  }
  return path;
}
function toPathData(elem) {
  const tagName2 = elem.tagName.toLowerCase();
  switch (tagName2) {
    case "path":
      return elem.getAttribute("d");
    case "line":
      return lineToPathData(elem);
    case "polygon":
      return polygonToPathData(elem);
    case "polyline":
      return polylineToPathData(elem);
    case "ellipse":
      return ellipseToPathData(elem);
    case "circle":
      return circleToPathData(elem);
    case "rect":
      return rectangleToPathData(elem);
    default:
      break;
  }
  throw new Error(`"${tagName2}" cannot be converted to svg path element.`);
}
function createSlicePathData(innerRadius, outerRadius, startAngle, endAngle) {
  const svgArcMax = 2 * Math.PI - 1e-6;
  const r0 = innerRadius;
  const r1 = outerRadius;
  let a0 = startAngle;
  let a1 = endAngle;
  if (a1 < a0) {
    const tmp = a0;
    a0 = a1;
    a1 = tmp;
  }
  const da = a1 - a0;
  const df = da < Math.PI ? "0" : "1";
  const c0 = Math.cos(a0);
  const s0 = Math.sin(a0);
  const c1 = Math.cos(a1);
  const s1 = Math.sin(a1);
  return da >= svgArcMax ? r0 ? (
    // eslint-disable-next-line
    `M0,${r1}A${r1},${r1} 0 1,1 0,${-r1}A${r1},${r1} 0 1,1 0,${r1}M0,${r0}A${r0},${r0} 0 1,0 0,${-r0}A${r0},${r0} 0 1,0 0,${r0}Z`
  ) : (
    // eslint-disable-next-line
    `M0,${r1}A${r1},${r1} 0 1,1 0,${-r1}A${r1},${r1} 0 1,1 0,${r1}Z`
  ) : r0 ? (
    // eslint-disable-next-line
    `M${r1 * c0},${r1 * s0}A${r1},${r1} 0 ${df},1 ${r1 * c1},${r1 * s1}L${r0 * c1},${r0 * s1}A${r0},${r0} 0 ${df},0 ${r0 * c0},${r0 * s0}Z`
  ) : (
    // eslint-disable-next-line
    `M${r1 * c0},${r1 * s0}A${r1},${r1} 0 ${df},1 ${r1 * c1},${r1 * s1}L0,0Z`
  );
}
var KAPPA;
var init_path = __esm({
  "node_modules/@antv/x6-common/es/dom/path.js"() {
    init_attr();
    init_elem();
    KAPPA = 0.551784;
  }
});

// node_modules/@antv/x6-common/es/dom/matrix.js
function createSVGPoint(x, y) {
  const svgDocument = createSvgElement("svg");
  const p = svgDocument.createSVGPoint();
  p.x = x;
  p.y = y;
  return p;
}
function createSVGMatrix(matrix) {
  const svgDocument = createSvgElement("svg");
  const mat = svgDocument.createSVGMatrix();
  if (matrix != null) {
    const source = matrix;
    const target = mat;
    for (const key in source) {
      target[key] = source[key];
    }
  }
  return mat;
}
function createSVGTransform(matrix) {
  const svgDocument = createSvgElement("svg");
  if (matrix != null) {
    if (!(matrix instanceof DOMMatrix)) {
      matrix = createSVGMatrix(matrix);
    }
    return svgDocument.createSVGTransformFromMatrix(matrix);
  }
  return svgDocument.createSVGTransform();
}
function transformStringToMatrix(transform2) {
  let mat = createSVGMatrix();
  const matches = transform2 != null && transform2.match(transformRegex);
  if (!matches) {
    return mat;
  }
  for (let i = 0, n = matches.length; i < n; i += 1) {
    const transformationString = matches[i];
    const transformationMatch = transformationString.match(transformationListRegex);
    if (transformationMatch) {
      let sx;
      let sy;
      let tx;
      let ty;
      let angle;
      let ctm = createSVGMatrix();
      const args = transformationMatch[2].split(transformSeparatorRegex);
      switch (transformationMatch[1].toLowerCase()) {
        case "scale":
          sx = parseFloat(args[0]);
          sy = args[1] === void 0 ? sx : parseFloat(args[1]);
          ctm = ctm.scaleNonUniform(sx, sy);
          break;
        case "translate":
          tx = parseFloat(args[0]);
          ty = parseFloat(args[1]);
          ctm = ctm.translate(tx, ty);
          break;
        case "rotate":
          angle = parseFloat(args[0]);
          tx = parseFloat(args[1]) || 0;
          ty = parseFloat(args[2]) || 0;
          if (tx !== 0 || ty !== 0) {
            ctm = ctm.translate(tx, ty).rotate(angle).translate(-tx, -ty);
          } else {
            ctm = ctm.rotate(angle);
          }
          break;
        case "skewx":
          angle = parseFloat(args[0]);
          ctm = ctm.skewX(angle);
          break;
        case "skewy":
          angle = parseFloat(args[0]);
          ctm = ctm.skewY(angle);
          break;
        case "matrix":
          ctm.a = parseFloat(args[0]);
          ctm.b = parseFloat(args[1]);
          ctm.c = parseFloat(args[2]);
          ctm.d = parseFloat(args[3]);
          ctm.e = parseFloat(args[4]);
          ctm.f = parseFloat(args[5]);
          break;
        default:
          continue;
      }
      mat = mat.multiply(ctm);
    }
  }
  return mat;
}
function matrixToTransformString(matrix) {
  const m = matrix || {};
  const a = m.a != null ? m.a : 1;
  const b = m.b != null ? m.b : 0;
  const c = m.c != null ? m.c : 0;
  const d = m.d != null ? m.d : 1;
  const e = m.e != null ? m.e : 0;
  const f = m.f != null ? m.f : 0;
  return `matrix(${a},${b},${c},${d},${e},${f})`;
}
function parseTransformString(transform2) {
  let translation;
  let rotation;
  let scale2;
  if (transform2) {
    const separator = transformSeparatorRegex;
    if (transform2.trim().indexOf("matrix") >= 0) {
      const matrix = transformStringToMatrix(transform2);
      const decomposedMatrix = decomposeMatrix(matrix);
      translation = [decomposedMatrix.translateX, decomposedMatrix.translateY];
      rotation = [decomposedMatrix.rotation];
      scale2 = [decomposedMatrix.scaleX, decomposedMatrix.scaleY];
      const transformations = [];
      if (translation[0] !== 0 || translation[1] !== 0) {
        transformations.push(`translate(${translation.join(",")})`);
      }
      if (scale2[0] !== 1 || scale2[1] !== 1) {
        transformations.push(`scale(${scale2.join(",")})`);
      }
      if (rotation[0] !== 0) {
        transformations.push(`rotate(${rotation[0]})`);
      }
      transform2 = transformations.join(" ");
    } else {
      const translateMatch = transform2.match(/translate\((.*?)\)/);
      if (translateMatch) {
        translation = translateMatch[1].split(separator);
      }
      const rotateMatch = transform2.match(/rotate\((.*?)\)/);
      if (rotateMatch) {
        rotation = rotateMatch[1].split(separator);
      }
      const scaleMatch = transform2.match(/scale\((.*?)\)/);
      if (scaleMatch) {
        scale2 = scaleMatch[1].split(separator);
      }
    }
  }
  const sx = scale2 && scale2[0] ? parseFloat(scale2[0]) : 1;
  return {
    raw: transform2 || "",
    translation: {
      tx: translation && translation[0] ? parseInt(translation[0], 10) : 0,
      ty: translation && translation[1] ? parseInt(translation[1], 10) : 0
    },
    rotation: {
      angle: rotation && rotation[0] ? parseInt(rotation[0], 10) : 0,
      cx: rotation && rotation[1] ? parseInt(rotation[1], 10) : void 0,
      cy: rotation && rotation[2] ? parseInt(rotation[2], 10) : void 0
    },
    scale: {
      sx,
      sy: scale2 && scale2[1] ? parseFloat(scale2[1]) : sx
    }
  };
}
function deltaTransformPoint(matrix, point) {
  const dx = point.x * matrix.a + point.y * matrix.c + 0;
  const dy = point.x * matrix.b + point.y * matrix.d + 0;
  return { x: dx, y: dy };
}
function decomposeMatrix(matrix) {
  const px = deltaTransformPoint(matrix, { x: 0, y: 1 });
  const py = deltaTransformPoint(matrix, { x: 1, y: 0 });
  const skewX = 180 / Math.PI * Math.atan2(px.y, px.x) - 90;
  const skewY = 180 / Math.PI * Math.atan2(py.y, py.x);
  return {
    skewX,
    skewY,
    translateX: matrix.e,
    translateY: matrix.f,
    scaleX: Math.sqrt(matrix.a * matrix.a + matrix.b * matrix.b),
    scaleY: Math.sqrt(matrix.c * matrix.c + matrix.d * matrix.d),
    rotation: skewX
  };
}
function matrixToScale(matrix) {
  let a;
  let b;
  let c;
  let d;
  if (matrix) {
    a = matrix.a == null ? 1 : matrix.a;
    d = matrix.d == null ? 1 : matrix.d;
    b = matrix.b;
    c = matrix.c;
  } else {
    a = d = 1;
  }
  return {
    sx: b ? Math.sqrt(a * a + b * b) : a,
    sy: c ? Math.sqrt(c * c + d * d) : d
  };
}
function matrixToRotation(matrix) {
  let p = { x: 0, y: 1 };
  if (matrix) {
    p = deltaTransformPoint(matrix, p);
  }
  const deg = 180 * Math.atan2(p.y, p.x) / Math.PI % 360 - 90;
  const angle = deg % 360 + (deg < 0 ? 360 : 0);
  return {
    angle
  };
}
function matrixToTranslation(matrix) {
  return {
    tx: matrix && matrix.e || 0,
    ty: matrix && matrix.f || 0
  };
}
var transformRegex, transformSeparatorRegex, transformationListRegex;
var init_matrix = __esm({
  "node_modules/@antv/x6-common/es/dom/matrix.js"() {
    init_elem();
    transformRegex = /(\w+)\(([^,)]+),?([^)]+)?\)/gi;
    transformSeparatorRegex = /[ ,]+/;
    transformationListRegex = /^(\w+)\((.*)\)/;
  }
});

// node_modules/@antv/x6-common/es/dom/transform.js
function transform(elem, matrix, options = {}) {
  if (matrix == null) {
    return transformStringToMatrix(attr(elem, "transform"));
  }
  if (options.absolute) {
    elem.setAttribute("transform", matrixToTransformString(matrix));
    return;
  }
  const transformList = elem.transform;
  const svgTransform = createSVGTransform(matrix);
  transformList.baseVal.appendItem(svgTransform);
}
function translate(elem, tx, ty = 0, options = {}) {
  let transformAttr = attr(elem, "transform");
  const transform2 = parseTransformString(transformAttr);
  if (tx == null) {
    return transform2.translation;
  }
  transformAttr = transform2.raw;
  transformAttr = transformAttr.replace(/translate\([^)]*\)/g, "").trim();
  const newTx = options.absolute ? tx : transform2.translation.tx + tx;
  const newTy = options.absolute ? ty : transform2.translation.ty + ty;
  const newTranslate = `translate(${newTx},${newTy})`;
  elem.setAttribute("transform", `${newTranslate} ${transformAttr}`.trim());
}
function rotate(elem, angle, cx, cy, options = {}) {
  let transformAttr = attr(elem, "transform");
  const transform2 = parseTransformString(transformAttr);
  if (angle == null) {
    return transform2.rotation;
  }
  transformAttr = transform2.raw;
  transformAttr = transformAttr.replace(/rotate\([^)]*\)/g, "").trim();
  angle %= 360;
  const newAngle = options.absolute ? angle : transform2.rotation.angle + angle;
  const newOrigin = cx != null && cy != null ? `,${cx},${cy}` : "";
  const newRotate = `rotate(${newAngle}${newOrigin})`;
  elem.setAttribute("transform", `${transformAttr} ${newRotate}`.trim());
}
function scale(elem, sx, sy) {
  let transformAttr = attr(elem, "transform");
  const transform2 = parseTransformString(transformAttr);
  if (sx == null) {
    return transform2.scale;
  }
  sy = sy == null ? sx : sy;
  transformAttr = transform2.raw;
  transformAttr = transformAttr.replace(/scale\([^)]*\)/g, "").trim();
  const newScale = `scale(${sx},${sy})`;
  elem.setAttribute("transform", `${transformAttr} ${newScale}`.trim());
}
function getTransformToElement(elem, target) {
  if (isSVGGraphicsElement(target) && isSVGGraphicsElement(elem)) {
    const targetCTM = target.getScreenCTM();
    const nodeCTM = elem.getScreenCTM();
    if (targetCTM && nodeCTM) {
      return targetCTM.inverse().multiply(nodeCTM);
    }
  }
  return createSVGMatrix();
}
function getTransformToParentElement(elem, target) {
  let matrix = createSVGMatrix();
  if (isSVGGraphicsElement(target) && isSVGGraphicsElement(elem)) {
    let node = elem;
    const matrixList = [];
    while (node && node !== target) {
      const transform2 = node.getAttribute("transform") || null;
      const nodeMatrix = transformStringToMatrix(transform2);
      matrixList.push(nodeMatrix);
      node = node.parentNode;
    }
    matrixList.reverse().forEach((m) => {
      matrix = matrix.multiply(m);
    });
  }
  return matrix;
}
function toLocalPoint(elem, x, y) {
  const svg = elem instanceof SVGSVGElement ? elem : elem.ownerSVGElement;
  const p = svg.createSVGPoint();
  p.x = x;
  p.y = y;
  try {
    const ctm = svg.getScreenCTM();
    const globalPoint = p.matrixTransform(ctm.inverse());
    const globalToLocalMatrix = getTransformToElement(elem, svg).inverse();
    return globalPoint.matrixTransform(globalToLocalMatrix);
  } catch (e) {
    return p;
  }
}
var init_transform = __esm({
  "node_modules/@antv/x6-common/es/dom/transform.js"() {
    init_attr();
    init_elem();
    init_matrix();
  }
});

// node_modules/@antv/x6-common/es/dom/event/hook.js
var EventHook;
var init_hook = __esm({
  "node_modules/@antv/x6-common/es/dom/event/hook.js"() {
    (function(EventHook2) {
      const cache = {};
      function get(type) {
        return cache[type] || {};
      }
      EventHook2.get = get;
      function register(type, hook) {
        cache[type] = hook;
      }
      EventHook2.register = register;
      function unregister(type) {
        delete cache[type];
      }
      EventHook2.unregister = unregister;
    })(EventHook || (EventHook = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/store.js
var Store;
var init_store = __esm({
  "node_modules/@antv/x6-common/es/dom/event/store.js"() {
    (function(Store2) {
      const cache = /* @__PURE__ */ new WeakMap();
      function ensure3(target) {
        if (!cache.has(target)) {
          cache.set(target, { events: /* @__PURE__ */ Object.create(null) });
        }
        return cache.get(target);
      }
      Store2.ensure = ensure3;
      function get(target) {
        return cache.get(target);
      }
      Store2.get = get;
      function remove2(target) {
        return cache.delete(target);
      }
      Store2.remove = remove2;
    })(Store || (Store = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/util.js
var Util;
var init_util2 = __esm({
  "node_modules/@antv/x6-common/es/dom/event/util.js"() {
    init_store();
    (function(Util2) {
      Util2.returnTrue = () => true;
      Util2.returnFalse = () => false;
      function stopPropagationCallback(e) {
        e.stopPropagation();
      }
      Util2.stopPropagationCallback = stopPropagationCallback;
      function addEventListener(elem, type, handler) {
        if (elem.addEventListener != null) {
          elem.addEventListener(type, handler);
        }
      }
      Util2.addEventListener = addEventListener;
      function removeEventListener(elem, type, handler) {
        if (elem.removeEventListener != null) {
          elem.removeEventListener(type, handler);
        }
      }
      Util2.removeEventListener = removeEventListener;
    })(Util || (Util = {}));
    (function(Util2) {
      const rNotHTMLWhite = /[^\x20\t\r\n\f]+/g;
      const rNamespace = /^([^.]*)(?:\.(.+)|)/;
      function splitType(types) {
        return (types || "").match(rNotHTMLWhite) || [""];
      }
      Util2.splitType = splitType;
      function normalizeType(type) {
        const parts = rNamespace.exec(type) || [];
        return {
          originType: parts[1] ? parts[1].trim() : parts[1],
          namespaces: parts[2] ? parts[2].split(".").map((ns2) => ns2.trim()).sort() : []
        };
      }
      Util2.normalizeType = normalizeType;
      function isValidTarget(target) {
        return target.nodeType === 1 || target.nodeType === 9 || !+target.nodeType;
      }
      Util2.isValidTarget = isValidTarget;
      function isValidSelector(elem, selector) {
        if (selector) {
          const node = elem;
          return node.querySelector != null && node.querySelector(selector) != null;
        }
        return true;
      }
      Util2.isValidSelector = isValidSelector;
    })(Util || (Util = {}));
    (function(Util2) {
      let seed = 0;
      const cache = /* @__PURE__ */ new WeakMap();
      function ensureHandlerId(handler) {
        if (!cache.has(handler)) {
          cache.set(handler, seed);
          seed += 1;
        }
        return cache.get(handler);
      }
      Util2.ensureHandlerId = ensureHandlerId;
      function getHandlerId(handler) {
        return cache.get(handler);
      }
      Util2.getHandlerId = getHandlerId;
      function removeHandlerId(handler) {
        return cache.delete(handler);
      }
      Util2.removeHandlerId = removeHandlerId;
      function setHandlerId(handler, id) {
        return cache.set(handler, id);
      }
      Util2.setHandlerId = setHandlerId;
    })(Util || (Util = {}));
    (function(Util2) {
      function getHandlerQueue(elem, event) {
        const queue = [];
        const store = Store.get(elem);
        const bag = store && store.events && store.events[event.type];
        const handlers = bag && bag.handlers || [];
        const delegateCount = bag ? bag.delegateCount : 0;
        if (delegateCount > 0 && // Support: Firefox <=42 - 66+
        // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
        // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
        // Support: IE 11+
        // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
        !(event.type === "click" && typeof event.button === "number" && event.button >= 1)) {
          for (let curr = event.target; curr !== elem; curr = curr.parentNode || elem) {
            if (curr.nodeType === 1 && !(event.type === "click" && curr.disabled === true)) {
              const matchedHandlers = [];
              const matchedSelectors = {};
              for (let i = 0; i < delegateCount; i += 1) {
                const handleObj = handlers[i];
                const selector = handleObj.selector;
                if (selector != null && matchedSelectors[selector] == null) {
                  const node = elem;
                  const nodes = [];
                  node.querySelectorAll(selector).forEach((child) => {
                    nodes.push(child);
                  });
                  matchedSelectors[selector] = nodes.includes(curr);
                }
                if (matchedSelectors[selector]) {
                  matchedHandlers.push(handleObj);
                }
              }
              if (matchedHandlers.length) {
                queue.push({ elem: curr, handlers: matchedHandlers });
              }
            }
          }
        }
        if (delegateCount < handlers.length) {
          queue.push({ elem, handlers: handlers.slice(delegateCount) });
        }
        return queue;
      }
      Util2.getHandlerQueue = getHandlerQueue;
    })(Util || (Util = {}));
    (function(Util2) {
      function isWindow(obj) {
        return obj != null && obj === obj.window;
      }
      Util2.isWindow = isWindow;
    })(Util || (Util = {}));
    (function(Util2) {
      function contains2(a, b) {
        const adown = a.nodeType === 9 ? a.documentElement : a;
        const bup = b && b.parentNode;
        return a === bup || !!(bup && bup.nodeType === 1 && // Support: IE 9 - 11+
        // IE doesn't have `contains` on SVG.
        (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
      }
      Util2.contains = contains2;
    })(Util || (Util = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/object.js
var EventObject;
var init_object3 = __esm({
  "node_modules/@antv/x6-common/es/dom/event/object.js"() {
    init_util2();
    EventObject = class {
      constructor(e, props) {
        this.isDefaultPrevented = Util.returnFalse;
        this.isPropagationStopped = Util.returnFalse;
        this.isImmediatePropagationStopped = Util.returnFalse;
        this.isSimulated = false;
        this.preventDefault = () => {
          const e2 = this.originalEvent;
          this.isDefaultPrevented = Util.returnTrue;
          if (e2 && !this.isSimulated) {
            e2.preventDefault();
          }
        };
        this.stopPropagation = () => {
          const e2 = this.originalEvent;
          this.isPropagationStopped = Util.returnTrue;
          if (e2 && !this.isSimulated) {
            e2.stopPropagation();
          }
        };
        this.stopImmediatePropagation = () => {
          const e2 = this.originalEvent;
          this.isImmediatePropagationStopped = Util.returnTrue;
          if (e2 && !this.isSimulated) {
            e2.stopImmediatePropagation();
          }
          this.stopPropagation();
        };
        if (typeof e === "string") {
          this.type = e;
        } else if (e.type) {
          this.originalEvent = e;
          this.type = e.type;
          this.isDefaultPrevented = e.defaultPrevented ? Util.returnTrue : Util.returnFalse;
          this.target = e.target;
          this.currentTarget = e.currentTarget;
          this.relatedTarget = e.relatedTarget;
          this.timeStamp = e.timeStamp;
        }
        if (props) {
          Object.assign(this, props);
        }
        if (!this.timeStamp) {
          this.timeStamp = Date.now();
        }
      }
    };
    (function(EventObject2) {
      function create(originalEvent) {
        return originalEvent instanceof EventObject2 ? originalEvent : new EventObject2(originalEvent);
      }
      EventObject2.create = create;
    })(EventObject || (EventObject = {}));
    (function(EventObject2) {
      function addProperty(name, hook) {
        Object.defineProperty(EventObject2.prototype, name, {
          enumerable: true,
          configurable: true,
          get: typeof hook === "function" ? (
            // eslint-disable-next-line
            function() {
              if (this.originalEvent) {
                return hook(this.originalEvent);
              }
            }
          ) : (
            // eslint-disable-next-line
            function() {
              if (this.originalEvent) {
                return this.originalEvent[name];
              }
            }
          ),
          set(value) {
            Object.defineProperty(this, name, {
              enumerable: true,
              configurable: true,
              writable: true,
              value
            });
          }
        });
      }
      EventObject2.addProperty = addProperty;
    })(EventObject || (EventObject = {}));
    (function(EventObject2) {
      const commonProps = {
        bubbles: true,
        cancelable: true,
        eventPhase: true,
        detail: true,
        view: true,
        button: true,
        buttons: true,
        clientX: true,
        clientY: true,
        offsetX: true,
        offsetY: true,
        pageX: true,
        pageY: true,
        screenX: true,
        screenY: true,
        toElement: true,
        pointerId: true,
        pointerType: true,
        char: true,
        code: true,
        charCode: true,
        key: true,
        keyCode: true,
        touches: true,
        changedTouches: true,
        targetTouches: true,
        which: true,
        altKey: true,
        ctrlKey: true,
        metaKey: true,
        shiftKey: true
      };
      Object.keys(commonProps).forEach((name) => EventObject2.addProperty(name, commonProps[name]));
    })(EventObject || (EventObject = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/special.js
var Special;
var init_special = __esm({
  "node_modules/@antv/x6-common/es/dom/event/special.js"() {
    init_hook();
    init_util2();
    (function(Special2) {
      EventHook.register("load", {
        noBubble: true
      });
    })(Special || (Special = {}));
    (function(Special2) {
      EventHook.register("beforeunload", {
        postDispatch(elem, event) {
          if (event.result !== void 0 && event.originalEvent) {
            event.originalEvent.returnValue = event.result;
          }
        }
      });
    })(Special || (Special = {}));
    (function(Special2) {
      EventHook.register("mouseenter", {
        delegateType: "mouseover",
        bindType: "mouseover",
        handle(target, event) {
          let ret;
          const related = event.relatedTarget;
          const handleObj = event.handleObj;
          if (!related || related !== target && !Util.contains(target, related)) {
            event.type = handleObj.originType;
            ret = handleObj.handler.call(target, event);
            event.type = "mouseover";
          }
          return ret;
        }
      });
      EventHook.register("mouseleave", {
        delegateType: "mouseout",
        bindType: "mouseout",
        handle(target, event) {
          let ret;
          const related = event.relatedTarget;
          const handleObj = event.handleObj;
          if (!related || related !== target && !Util.contains(target, related)) {
            event.type = handleObj.originType;
            ret = handleObj.handler.call(target, event);
            event.type = "mouseout";
          }
          return ret;
        }
      });
    })(Special || (Special = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/core.js
var __rest, Core;
var init_core = __esm({
  "node_modules/@antv/x6-common/es/dom/event/core.js"() {
    init_util2();
    init_hook();
    init_store();
    init_object3();
    init_special();
    __rest = function(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(Core2) {
      let triggered;
      function on(elem, types, handler, data2, selector) {
        if (!Util.isValidTarget(elem)) {
          return;
        }
        let handlerData;
        if (typeof handler !== "function") {
          const { handler: h, selector: s } = handler, others = __rest(handler, ["handler", "selector"]);
          handler = h;
          selector = s;
          handlerData = others;
        }
        const store = Store.ensure(elem);
        let mainHandler = store.handler;
        if (mainHandler == null) {
          mainHandler = store.handler = function(e, ...args) {
            return triggered !== e.type ? dispatch(elem, e, ...args) : void 0;
          };
        }
        const guid = Util.ensureHandlerId(handler);
        Util.splitType(types).forEach((item) => {
          const { originType, namespaces } = Util.normalizeType(item);
          if (!originType) {
            return;
          }
          let type = originType;
          let hook = EventHook.get(type);
          type = (selector ? hook.delegateType : hook.bindType) || type;
          hook = EventHook.get(type);
          const handleObj = Object.assign({
            type,
            originType,
            data: data2,
            selector,
            guid,
            handler,
            namespace: namespaces.join(".")
          }, handlerData);
          const events = store.events;
          let bag = events[type];
          if (!bag) {
            bag = events[type] = { handlers: [], delegateCount: 0 };
            if (!hook.setup || hook.setup(elem, data2, namespaces, mainHandler) === false) {
              Util.addEventListener(elem, type, mainHandler);
            }
          }
          if (hook.add) {
            Util.removeHandlerId(handleObj.handler);
            hook.add(elem, handleObj);
            Util.setHandlerId(handleObj.handler, guid);
          }
          if (selector) {
            bag.handlers.splice(bag.delegateCount, 0, handleObj);
            bag.delegateCount += 1;
          } else {
            bag.handlers.push(handleObj);
          }
        });
      }
      Core2.on = on;
      function off(elem, types, handler, selector, mappedTypes) {
        const store = Store.get(elem);
        if (!store) {
          return;
        }
        const events = store.events;
        if (!events) {
          return;
        }
        Util.splitType(types).forEach((item) => {
          const { originType, namespaces } = Util.normalizeType(item);
          if (!originType) {
            Object.keys(events).forEach((key) => {
              off(elem, key + item, handler, selector, true);
            });
            return;
          }
          let type = originType;
          const hook = EventHook.get(type);
          type = (selector ? hook.delegateType : hook.bindType) || type;
          const bag = events[type];
          if (!bag) {
            return;
          }
          const rns = namespaces.length > 0 ? new RegExp(`(^|\\.)${namespaces.join("\\.(?:.*\\.|)")}(\\.|$)`) : null;
          const originHandlerCount = bag.handlers.length;
          for (let i = bag.handlers.length - 1; i >= 0; i -= 1) {
            const handleObj = bag.handlers[i];
            if ((mappedTypes || originType === handleObj.originType) && (!handler || Util.getHandlerId(handler) === handleObj.guid) && (rns == null || handleObj.namespace && rns.test(handleObj.namespace)) && (selector == null || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
              bag.handlers.splice(i, 1);
              if (handleObj.selector) {
                bag.delegateCount -= 1;
              }
              if (hook.remove) {
                hook.remove(elem, handleObj);
              }
            }
          }
          if (originHandlerCount && bag.handlers.length === 0) {
            if (!hook.teardown || hook.teardown(elem, namespaces, store.handler) === false) {
              Util.removeEventListener(elem, type, store.handler);
            }
            delete events[type];
          }
        });
        if (Object.keys(events).length === 0) {
          Store.remove(elem);
        }
      }
      Core2.off = off;
      function dispatch(elem, evt, ...args) {
        const event = EventObject.create(evt);
        event.delegateTarget = elem;
        const hook = EventHook.get(event.type);
        if (hook.preDispatch && hook.preDispatch(elem, event) === false) {
          return;
        }
        const handlerQueue = Util.getHandlerQueue(elem, event);
        for (let i = 0, l = handlerQueue.length; i < l && !event.isPropagationStopped(); i += 1) {
          const matched = handlerQueue[i];
          event.currentTarget = matched.elem;
          for (let j = 0, k = matched.handlers.length; j < k && !event.isImmediatePropagationStopped(); j += 1) {
            const handleObj = matched.handlers[j];
            if (event.rnamespace == null || handleObj.namespace && event.rnamespace.test(handleObj.namespace)) {
              event.handleObj = handleObj;
              event.data = handleObj.data;
              const hookHandle = EventHook.get(handleObj.originType).handle;
              const result = hookHandle ? hookHandle(matched.elem, event, ...args) : handleObj.handler.call(matched.elem, event, ...args);
              if (result !== void 0) {
                event.result = result;
                if (result === false) {
                  event.preventDefault();
                  event.stopPropagation();
                }
              }
            }
          }
        }
        if (hook.postDispatch) {
          hook.postDispatch(elem, event);
        }
        return event.result;
      }
      Core2.dispatch = dispatch;
      function trigger(event, eventArgs, elem, onlyHandlers) {
        let eventObj = event;
        let type = typeof event === "string" ? event : event.type;
        let namespaces = typeof event === "string" || eventObj.namespace == null ? [] : eventObj.namespace.split(".");
        const node = elem;
        if (node.nodeType === 3 || node.nodeType === 8) {
          return;
        }
        if (type.indexOf(".") > -1) {
          namespaces = type.split(".");
          type = namespaces.shift();
          namespaces.sort();
        }
        const ontype = type.indexOf(":") < 0 && `on${type}`;
        eventObj = event instanceof EventObject ? event : new EventObject(type, typeof event === "object" ? event : null);
        eventObj.namespace = namespaces.join(".");
        eventObj.rnamespace = eventObj.namespace ? new RegExp(`(^|\\.)${namespaces.join("\\.(?:.*\\.|)")}(\\.|$)`) : null;
        eventObj.result = void 0;
        if (!eventObj.target) {
          eventObj.target = node;
        }
        const args = [eventObj];
        if (Array.isArray(eventArgs)) {
          args.push(...eventArgs);
        } else {
          args.push(eventArgs);
        }
        const hook = EventHook.get(type);
        if (!onlyHandlers && hook.trigger && hook.trigger(node, eventObj, eventArgs) === false) {
          return;
        }
        let bubbleType;
        const eventPath = [node];
        if (!onlyHandlers && !hook.noBubble && !Util.isWindow(node)) {
          bubbleType = hook.delegateType || type;
          let last = node;
          let curr = node.parentNode;
          while (curr != null) {
            eventPath.push(curr);
            last = curr;
            curr = curr.parentNode;
          }
          const doc = node.ownerDocument || document;
          if (last === doc) {
            const win = last.defaultView || last.parentWindow || window;
            eventPath.push(win);
          }
        }
        let lastElement = node;
        for (let i = 0, l = eventPath.length; i < l && !eventObj.isPropagationStopped(); i += 1) {
          const currElement = eventPath[i];
          lastElement = currElement;
          eventObj.type = i > 1 ? bubbleType : hook.bindType || type;
          const store = Store.get(currElement);
          if (store) {
            if (store.events[eventObj.type] && store.handler) {
              store.handler.call(currElement, ...args);
            }
          }
          const handle = ontype && currElement[ontype] || null;
          if (handle && Util.isValidTarget(currElement)) {
            eventObj.result = handle.call(currElement, ...args);
            if (eventObj.result === false) {
              eventObj.preventDefault();
            }
          }
        }
        eventObj.type = type;
        if (!onlyHandlers && !eventObj.isDefaultPrevented()) {
          const preventDefault = hook.preventDefault;
          if ((preventDefault == null || preventDefault(eventPath.pop(), eventObj, eventArgs) === false) && Util.isValidTarget(node)) {
            if (ontype && typeof node[type] === "function" && !Util.isWindow(node)) {
              const tmp = node[ontype];
              if (tmp) {
                node[ontype] = null;
              }
              triggered = type;
              if (eventObj.isPropagationStopped()) {
                lastElement.addEventListener(type, Util.stopPropagationCallback);
              }
              node[type]();
              if (eventObj.isPropagationStopped()) {
                lastElement.removeEventListener(type, Util.stopPropagationCallback);
              }
              triggered = void 0;
              if (tmp) {
                node[ontype] = tmp;
              }
            }
          }
        }
        return eventObj.result;
      }
      Core2.trigger = trigger;
    })(Core || (Core = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/main.js
var Event, Private;
var init_main3 = __esm({
  "node_modules/@antv/x6-common/es/dom/event/main.js"() {
    init_core();
    init_util2();
    (function(Event2) {
      function on(elem, events, selector, data2, handler) {
        Private.on(elem, events, selector, data2, handler);
        return elem;
      }
      Event2.on = on;
      function once(elem, events, selector, data2, handler) {
        Private.on(elem, events, selector, data2, handler, true);
        return elem;
      }
      Event2.once = once;
      function off(elem, events, selector, handler) {
        Private.off(elem, events, selector, handler);
        return elem;
      }
      Event2.off = off;
      function trigger(elem, event, args, onlyHandlers) {
        Core.trigger(event, args, elem, onlyHandlers);
        return elem;
      }
      Event2.trigger = trigger;
    })(Event || (Event = {}));
    (function(Private2) {
      function on(elem, types, selector, data2, fn, once) {
        if (typeof types === "object") {
          if (typeof selector !== "string") {
            data2 = data2 || selector;
            selector = void 0;
          }
          Object.keys(types).forEach((type) => on(elem, type, selector, data2, types[type], once));
          return;
        }
        if (data2 == null && fn == null) {
          fn = selector;
          data2 = selector = void 0;
        } else if (fn == null) {
          if (typeof selector === "string") {
            fn = data2;
            data2 = void 0;
          } else {
            fn = data2;
            data2 = selector;
            selector = void 0;
          }
        }
        if (fn === false) {
          fn = Util.returnFalse;
        } else if (!fn) {
          return;
        }
        if (once) {
          const originHandler = fn;
          fn = function(event, ...args) {
            Private2.off(elem, event);
            return originHandler.call(this, event, ...args);
          };
          Util.setHandlerId(fn, Util.ensureHandlerId(originHandler));
        }
        Core.on(elem, types, fn, data2, selector);
      }
      Private2.on = on;
      function off(elem, events, selector, fn) {
        const evt = events;
        if (evt && evt.preventDefault != null && evt.handleObj != null) {
          const obj = evt.handleObj;
          off(evt.delegateTarget, obj.namespace ? `${obj.originType}.${obj.namespace}` : obj.originType, obj.selector, obj.handler);
          return;
        }
        if (typeof events === "object") {
          const types = events;
          Object.keys(types).forEach((type) => off(elem, type, selector, types[type]));
          return;
        }
        if (selector === false || typeof selector === "function") {
          fn = selector;
          selector = void 0;
        }
        if (fn === false) {
          fn = Util.returnFalse;
        }
        Core.off(elem, events, fn, selector);
      }
      Private2.off = off;
    })(Private || (Private = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/event/types.js
var init_types = __esm({
  "node_modules/@antv/x6-common/es/dom/event/types.js"() {
  }
});

// node_modules/@antv/x6-common/es/dom/event/index.js
var init_event2 = __esm({
  "node_modules/@antv/x6-common/es/dom/event/index.js"() {
    init_hook();
    init_main3();
    init_object3();
    init_types();
  }
});

// node_modules/@antv/x6-common/es/dom/mousewheel.js
var MouseWheelHandle;
var init_mousewheel = __esm({
  "node_modules/@antv/x6-common/es/dom/mousewheel.js"() {
    init_platform();
    MouseWheelHandle = class {
      constructor(target, onWheelCallback, onWheelGuard) {
        this.animationFrameId = 0;
        this.deltaX = 0;
        this.deltaY = 0;
        this.eventName = Platform.isEventSupported("wheel") ? "wheel" : "mousewheel";
        this.target = target;
        this.onWheelCallback = onWheelCallback;
        this.onWheelGuard = onWheelGuard;
        this.onWheel = this.onWheel.bind(this);
        this.didWheel = this.didWheel.bind(this);
      }
      enable() {
        this.target.addEventListener(this.eventName, this.onWheel, {
          passive: false
        });
      }
      disable() {
        this.target.removeEventListener(this.eventName, this.onWheel);
      }
      onWheel(e) {
        if (this.onWheelGuard != null && !this.onWheelGuard(e)) {
          return;
        }
        this.deltaX += e.deltaX;
        this.deltaY += e.deltaY;
        e.preventDefault();
        let changed;
        if (this.deltaX !== 0 || this.deltaY !== 0) {
          e.stopPropagation();
          changed = true;
        }
        if (changed === true && this.animationFrameId === 0) {
          this.animationFrameId = requestAnimationFrame(() => {
            this.didWheel(e);
          });
        }
      }
      didWheel(e) {
        this.animationFrameId = 0;
        this.onWheelCallback(e, this.deltaX, this.deltaY);
        this.deltaX = 0;
        this.deltaY = 0;
      }
    };
  }
});

// node_modules/@antv/x6-common/es/dom/position.js
function offset(elem) {
  const rect = elem.getBoundingClientRect();
  const win = elem.ownerDocument.defaultView;
  return {
    top: rect.top + win.pageYOffset,
    left: rect.left + win.pageXOffset
  };
}
function width(elem) {
  const rect = elem.getBoundingClientRect();
  return rect.width;
}
function height(elem) {
  const rect = elem.getBoundingClientRect();
  return rect.height;
}
function position(elem) {
  const isFixed = computeStyle(elem, "position") === "fixed";
  let offsetValue;
  if (isFixed) {
    const rect = elem.getBoundingClientRect();
    offsetValue = { left: rect.left, top: rect.top };
  } else {
    offsetValue = offset(elem);
  }
  if (!isFixed) {
    const doc = elem.ownerDocument;
    let offsetParent = elem.offsetParent || doc.documentElement;
    while ((offsetParent === doc.body || offsetParent === doc.documentElement) && computeStyle(offsetParent, "position") === "static") {
      offsetParent = offsetParent.parentNode;
    }
    if (offsetParent !== elem && isElement(offsetParent)) {
      const parentOffset = offset(offsetParent);
      offsetValue.top -= parentOffset.top + computeStyleInt(offsetParent, "borderTopWidth");
      offsetValue.left -= parentOffset.left + computeStyleInt(offsetParent, "borderLeftWidth");
    }
  }
  return {
    top: offsetValue.top - computeStyleInt(elem, "marginTop"),
    left: offsetValue.left - computeStyleInt(elem, "marginLeft")
  };
}
var init_position = __esm({
  "node_modules/@antv/x6-common/es/dom/position.js"() {
    init_css();
    init_elem();
  }
});

// node_modules/@antv/x6-common/es/dom/main.js
var main_exports3 = {};
__export(main_exports3, {
  CASE_SENSITIVE_ATTR: () => CASE_SENSITIVE_ATTR,
  Event: () => Event,
  EventHook: () => EventHook,
  EventObject: () => EventObject,
  KAPPA: () => KAPPA,
  MouseWheelHandle: () => MouseWheelHandle,
  addClass: () => addClass,
  after: () => after,
  append: () => append,
  appendTo: () => appendTo,
  attr: () => attr,
  before: () => before,
  breakText: () => breakText,
  children: () => children,
  circleToPathData: () => circleToPathData,
  clearSelection: () => clearSelection,
  computeStyle: () => computeStyle,
  computeStyleInt: () => computeStyleInt,
  contains: () => contains,
  createElement: () => createElement,
  createElementNS: () => createElementNS,
  createSVGMatrix: () => createSVGMatrix,
  createSVGPoint: () => createSVGPoint,
  createSVGTransform: () => createSVGTransform,
  createSlicePathData: () => createSlicePathData,
  createSvgDocument: () => createSvgDocument,
  createSvgElement: () => createSvgElement,
  css: () => css,
  data: () => data,
  decomposeMatrix: () => decomposeMatrix,
  ellipseToPathData: () => ellipseToPathData,
  empty: () => empty,
  ensureId: () => ensureId,
  find: () => find,
  findOne: () => findOne,
  findParentByClass: () => findParentByClass,
  getAttribute: () => getAttribute,
  getClass: () => getClass,
  getComputedStyle: () => getComputedStyle2,
  getData: () => getData,
  getPointsFromSvgElement: () => getPointsFromSvgElement,
  getTransformToElement: () => getTransformToElement,
  getTransformToParentElement: () => getTransformToParentElement,
  getVendorPrefixedName: () => getVendorPrefixedName,
  hasClass: () => hasClass,
  hasScrollbars: () => hasScrollbars,
  height: () => height,
  index: () => index,
  isCSSVariable: () => isCSSVariable,
  isElement: () => isElement,
  isHTMLElement: () => isHTMLElement,
  isSVGGraphicsElement: () => isSVGGraphicsElement,
  kebablizeAttrs: () => kebablizeAttrs,
  lineToPathData: () => lineToPathData,
  matrixToRotation: () => matrixToRotation,
  matrixToScale: () => matrixToScale,
  matrixToTransformString: () => matrixToTransformString,
  matrixToTranslation: () => matrixToTranslation,
  measureText: () => measureText,
  mergeAttrs: () => mergeAttrs,
  ns: () => ns,
  offset: () => offset,
  parseTransformString: () => parseTransformString,
  parseXML: () => parseXML,
  polygonToPathData: () => polygonToPathData,
  polylineToPathData: () => polylineToPathData,
  position: () => position,
  prepend: () => prepend,
  prop: () => prop,
  qualifyAttr: () => qualifyAttr,
  rectToPathData: () => rectToPathData,
  rectangleToPathData: () => rectangleToPathData,
  remove: () => remove,
  removeAttribute: () => removeAttribute,
  removeClass: () => removeClass,
  rotate: () => rotate,
  sample: () => sample,
  scale: () => scale,
  setAttribute: () => setAttribute,
  setAttributes: () => setAttributes,
  setData: () => setData,
  setPrefixedStyle: () => setPrefixedStyle,
  splitTextByLength: () => splitTextByLength,
  styleToObject: () => styleToObject,
  svgVersion: () => svgVersion,
  tagName: () => tagName,
  text: () => text,
  toLocalPoint: () => toLocalPoint,
  toPath: () => toPath,
  toPathData: () => toPathData,
  toggleClass: () => toggleClass,
  transform: () => transform,
  transformStringToMatrix: () => transformStringToMatrix,
  translate: () => translate,
  uniqueId: () => uniqueId,
  width: () => width
});
var init_main4 = __esm({
  "node_modules/@antv/x6-common/es/dom/main.js"() {
    init_attr();
    init_elem();
    init_class();
    init_style();
    init_prefix();
    init_selection();
    init_css();
    init_data();
    init_prop();
    init_text2();
    init_path();
    init_matrix();
    init_transform();
    init_event2();
    init_mousewheel();
    init_position();
  }
});

// node_modules/@antv/x6-common/es/vector/index.js
var Vector;
var init_vector = __esm({
  "node_modules/@antv/x6-common/es/vector/index.js"() {
    init_main4();
    Vector = class _Vector {
      get [Symbol.toStringTag]() {
        return _Vector.toStringTag;
      }
      get type() {
        return this.node.nodeName;
      }
      get id() {
        return this.node.id;
      }
      set id(id) {
        this.node.id = id;
      }
      constructor(elem, attrs, children2) {
        if (!elem) {
          throw new TypeError("Invalid element to create vector");
        }
        let node;
        if (_Vector.isVector(elem)) {
          node = elem.node;
        } else if (typeof elem === "string") {
          if (elem.toLowerCase() === "svg") {
            node = createSvgDocument();
          } else if (elem[0] === "<") {
            const doc = createSvgDocument(elem);
            node = document.importNode(doc.firstChild, true);
          } else {
            node = document.createElementNS(ns.svg, elem);
          }
        } else {
          node = elem;
        }
        this.node = node;
        if (attrs) {
          this.setAttributes(attrs);
        }
        if (children2) {
          this.append(children2);
        }
      }
      transform(matrix, options) {
        if (matrix == null) {
          return transform(this.node);
        }
        transform(this.node, matrix, options);
        return this;
      }
      translate(tx, ty = 0, options = {}) {
        if (tx == null) {
          return translate(this.node);
        }
        translate(this.node, tx, ty, options);
        return this;
      }
      rotate(angle, cx, cy, options = {}) {
        if (angle == null) {
          return rotate(this.node);
        }
        rotate(this.node, angle, cx, cy, options);
        return this;
      }
      scale(sx, sy) {
        if (sx == null) {
          return scale(this.node);
        }
        scale(this.node, sx, sy);
        return this;
      }
      /**
       * Returns an SVGMatrix that specifies the transformation necessary
       * to convert this coordinate system into `target` coordinate system.
       */
      getTransformToElement(target) {
        const ref = _Vector.toNode(target);
        return getTransformToElement(this.node, ref);
      }
      removeAttribute(name) {
        removeAttribute(this.node, name);
        return this;
      }
      getAttribute(name) {
        return getAttribute(this.node, name);
      }
      setAttribute(name, value) {
        setAttribute(this.node, name, value);
        return this;
      }
      setAttributes(attrs) {
        setAttributes(this.node, attrs);
        return this;
      }
      attr(name, value) {
        if (name == null) {
          return attr(this.node);
        }
        if (typeof name === "string" && value === void 0) {
          return attr(this.node, name);
        }
        if (typeof name === "object") {
          attr(this.node, name);
        } else {
          attr(this.node, name, value);
        }
        return this;
      }
      svg() {
        return this.node instanceof SVGSVGElement ? this : _Vector.create(this.node.ownerSVGElement);
      }
      defs() {
        const context = this.svg() || this;
        const defsNode = context.node.getElementsByTagName("defs")[0];
        if (defsNode) {
          return _Vector.create(defsNode);
        }
        return _Vector.create("defs").appendTo(context);
      }
      text(content, options = {}) {
        text(this.node, content, options);
        return this;
      }
      tagName() {
        return tagName(this.node);
      }
      clone() {
        return _Vector.create(this.node.cloneNode(true));
      }
      remove() {
        remove(this.node);
        return this;
      }
      empty() {
        empty(this.node);
        return this;
      }
      append(elems) {
        append(this.node, _Vector.toNodes(elems));
        return this;
      }
      appendTo(target) {
        appendTo(this.node, _Vector.isVector(target) ? target.node : target);
        return this;
      }
      prepend(elems) {
        prepend(this.node, _Vector.toNodes(elems));
        return this;
      }
      before(elems) {
        before(this.node, _Vector.toNodes(elems));
        return this;
      }
      replace(elem) {
        if (this.node.parentNode) {
          this.node.parentNode.replaceChild(_Vector.toNode(elem), this.node);
        }
        return _Vector.create(elem);
      }
      first() {
        return this.node.firstChild ? _Vector.create(this.node.firstChild) : null;
      }
      last() {
        return this.node.lastChild ? _Vector.create(this.node.lastChild) : null;
      }
      get(index2) {
        const child = this.node.childNodes[index2];
        return child ? _Vector.create(child) : null;
      }
      indexOf(elem) {
        const children2 = Array.prototype.slice.call(this.node.childNodes);
        return children2.indexOf(_Vector.toNode(elem));
      }
      find(selector) {
        const vels = [];
        const nodes = find(this.node, selector);
        if (nodes) {
          for (let i = 0, ii = nodes.length; i < ii; i += 1) {
            vels.push(_Vector.create(nodes[i]));
          }
        }
        return vels;
      }
      findOne(selector) {
        const found = findOne(this.node, selector);
        return found ? _Vector.create(found) : null;
      }
      findParentByClass(className, terminator) {
        const node = findParentByClass(this.node, className, terminator);
        return node ? _Vector.create(node) : null;
      }
      matches(selector) {
        const node = this.node;
        const matches = this.node.matches;
        const matcher = node.matches || node.matchesSelector || node.msMatchesSelector || node.mozMatchesSelector || node.webkitMatchesSelector || node.oMatchesSelector || null;
        return matcher && matcher.call(node, selector);
      }
      contains(child) {
        return contains(this.node, _Vector.isVector(child) ? child.node : child);
      }
      wrap(node) {
        const vel = _Vector.create(node);
        const parentNode = this.node.parentNode;
        if (parentNode != null) {
          parentNode.insertBefore(vel.node, this.node);
        }
        return vel.append(this);
      }
      parent(type) {
        let parent = this;
        if (parent.node.parentNode == null) {
          return null;
        }
        parent = _Vector.create(parent.node.parentNode);
        if (type == null) {
          return parent;
        }
        do {
          if (typeof type === "string" ? parent.matches(type) : parent instanceof type) {
            return parent;
          }
        } while (parent = _Vector.create(parent.node.parentNode));
        return parent;
      }
      children() {
        const children2 = this.node.childNodes;
        const vels = [];
        for (let i = 0; i < children2.length; i += 1) {
          const currentChild = children2[i];
          if (currentChild.nodeType === 1) {
            vels.push(_Vector.create(children2[i]));
          }
        }
        return vels;
      }
      eachChild(fn, deep) {
        const children2 = this.children();
        for (let i = 0, l = children2.length; i < l; i += 1) {
          fn.call(children2[i], children2[i], i, children2);
          if (deep) {
            children2[i].eachChild(fn, deep);
          }
        }
        return this;
      }
      index() {
        return index(this.node);
      }
      hasClass(className) {
        return hasClass(this.node, className);
      }
      addClass(className) {
        addClass(this.node, className);
        return this;
      }
      removeClass(className) {
        removeClass(this.node, className);
        return this;
      }
      toggleClass(className, stateVal) {
        toggleClass(this.node, className, stateVal);
        return this;
      }
      toLocalPoint(x, y) {
        return toLocalPoint(this.node, x, y);
      }
      /**
       * Samples the underlying SVG element (it currently works only on
       * paths - where it is most useful anyway). Returns an array of objects
       * of the form `{ x: Number, y: Number, distance: Number }`. Each of these
       * objects represent a point on the path. This basically creates a discrete
       * representation of the path (which is possible a curve). The sampling
       * interval defines the accuracy of the sampling. In other words, we travel
       * from the beginning of the path to the end by interval distance (on the
       * path, not between the resulting points) and collect the discrete points
       * on the path. This is very useful in many situations. For example, SVG
       * does not provide a built-in mechanism to find intersections between two
       * paths. Using sampling, we can just generate bunch of points for each of
       * the path and find the closest ones from each set.
       */
      sample(interval = 1) {
        if (this.node instanceof SVGPathElement) {
          return sample(this.node, interval);
        }
        return [];
      }
      toPath() {
        return _Vector.create(toPath(this.node));
      }
      toPathData() {
        return toPathData(this.node);
      }
    };
    (function(Vector2) {
      Vector2.toStringTag = `X6.${Vector2.name}`;
      function isVector(instance) {
        if (instance == null) {
          return false;
        }
        if (instance instanceof Vector2) {
          return true;
        }
        const tag = instance[Symbol.toStringTag];
        const vector = instance;
        if ((tag == null || tag === Vector2.toStringTag) && vector.node instanceof SVGElement && typeof vector.sample === "function" && typeof vector.toPath === "function") {
          return true;
        }
        return false;
      }
      Vector2.isVector = isVector;
      function create(elem, attrs, children2) {
        return new Vector2(elem, attrs, children2);
      }
      Vector2.create = create;
      function createVectors(markup) {
        if (markup[0] === "<") {
          const svgDoc = createSvgDocument(markup);
          const vels = [];
          for (let i = 0, ii = svgDoc.childNodes.length; i < ii; i += 1) {
            const childNode = svgDoc.childNodes[i];
            vels.push(create(document.importNode(childNode, true)));
          }
          return vels;
        }
        return [create(markup)];
      }
      Vector2.createVectors = createVectors;
      function toNode(elem) {
        if (isVector(elem)) {
          return elem.node;
        }
        return elem;
      }
      Vector2.toNode = toNode;
      function toNodes(elems) {
        if (Array.isArray(elems)) {
          return elems.map((elem) => toNode(elem));
        }
        return [toNode(elems)];
      }
      Vector2.toNodes = toNodes;
    })(Vector || (Vector = {}));
  }
});

// node_modules/@antv/x6-common/es/dom/index.js
var init_dom = __esm({
  "node_modules/@antv/x6-common/es/dom/index.js"() {
    init_main4();
  }
});

// node_modules/@antv/x6-common/es/size-sensor/sensors/util.js
function debounce(fn, delay = 60) {
  let timer = null;
  return (...args) => {
    if (timer) {
      clearTimeout(timer);
    }
    timer = window.setTimeout(() => {
      fn.apply(this, args);
    }, delay);
  };
}
var init_util3 = __esm({
  "node_modules/@antv/x6-common/es/size-sensor/sensors/util.js"() {
  }
});

// node_modules/@antv/x6-common/es/size-sensor/sensors/object.js
function createSensor(element) {
  let sensor = null;
  let listeners = [];
  const create = () => {
    if (getComputedStyle(element).position === "static") {
      const style = element.style;
      style.position = "relative";
    }
    const obj = document.createElement("object");
    obj.onload = () => {
      obj.contentDocument.defaultView.addEventListener("resize", trigger);
      trigger();
    };
    obj.style.display = "block";
    obj.style.position = "absolute";
    obj.style.top = "0";
    obj.style.left = "0";
    obj.style.height = "100%";
    obj.style.width = "100%";
    obj.style.overflow = "hidden";
    obj.style.pointerEvents = "none";
    obj.style.zIndex = "-1";
    obj.style.opacity = "0";
    obj.setAttribute("tabindex", "-1");
    obj.type = "text/html";
    element.appendChild(obj);
    obj.data = "about:blank";
    return obj;
  };
  const trigger = debounce(() => {
    listeners.forEach((listener) => listener(element));
  });
  const bind = (listener) => {
    if (!sensor) {
      sensor = create();
    }
    if (listeners.indexOf(listener) === -1) {
      listeners.push(listener);
    }
  };
  const destroy = () => {
    if (sensor && sensor.parentNode) {
      if (sensor.contentDocument) {
        sensor.contentDocument.defaultView.removeEventListener("resize", trigger);
      }
      sensor.parentNode.removeChild(sensor);
      sensor = null;
      listeners = [];
    }
  };
  const unbind = (listener) => {
    const idx = listeners.indexOf(listener);
    if (idx !== -1) {
      listeners.splice(idx, 1);
    }
    if (listeners.length === 0 && sensor) {
      destroy();
    }
  };
  return {
    element,
    bind,
    destroy,
    unbind
  };
}
var init_object4 = __esm({
  "node_modules/@antv/x6-common/es/size-sensor/sensors/object.js"() {
    init_util3();
  }
});

// node_modules/@antv/x6-common/es/size-sensor/sensors/observer.js
function createSensor2(element) {
  let sensor = null;
  let listeners = [];
  const trigger = debounce(() => {
    listeners.forEach((listener) => {
      listener(element);
    });
  });
  const create = () => {
    const s = new ResizeObserver(trigger);
    s.observe(element);
    trigger();
    return s;
  };
  const bind = (listener) => {
    if (!sensor) {
      sensor = create();
    }
    if (listeners.indexOf(listener) === -1) {
      listeners.push(listener);
    }
  };
  const destroy = () => {
    if (sensor) {
      sensor.disconnect();
      listeners = [];
      sensor = null;
    }
  };
  const unbind = (listener) => {
    const idx = listeners.indexOf(listener);
    if (idx !== -1) {
      listeners.splice(idx, 1);
    }
    if (listeners.length === 0 && sensor) {
      destroy();
    }
  };
  return {
    element,
    bind,
    destroy,
    unbind
  };
}
var init_observer = __esm({
  "node_modules/@antv/x6-common/es/size-sensor/sensors/observer.js"() {
    init_util3();
  }
});

// node_modules/@antv/x6-common/es/size-sensor/sensors/index.js
var createSensor3;
var init_sensors = __esm({
  "node_modules/@antv/x6-common/es/size-sensor/sensors/index.js"() {
    init_object4();
    init_observer();
    createSensor3 = typeof ResizeObserver !== "undefined" ? createSensor2 : createSensor;
  }
});

// node_modules/@antv/x6-common/es/size-sensor/index.js
var SizeSensor;
var init_size_sensor = __esm({
  "node_modules/@antv/x6-common/es/size-sensor/index.js"() {
    init_sensors();
    (function(SizeSensor2) {
      const cache = /* @__PURE__ */ new WeakMap();
      function get(element) {
        let sensor = cache.get(element);
        if (sensor) {
          return sensor;
        }
        sensor = createSensor3(element);
        cache.set(element, sensor);
        return sensor;
      }
      function remove2(sensor) {
        sensor.destroy();
        cache.delete(sensor.element);
      }
      SizeSensor2.bind = (element, cb) => {
        const sensor = get(element);
        sensor.bind(cb);
        return () => sensor.unbind(cb);
      };
      SizeSensor2.clear = (element) => {
        const sensor = get(element);
        remove2(sensor);
      };
    })(SizeSensor || (SizeSensor = {}));
  }
});

// node_modules/@antv/x6-common/es/algorithm/priorityqueue.js
var PriorityQueue;
var init_priorityqueue = __esm({
  "node_modules/@antv/x6-common/es/algorithm/priorityqueue.js"() {
    PriorityQueue = class _PriorityQueue {
      constructor(options = {}) {
        this.comparator = options.comparator || _PriorityQueue.defaultComparator;
        this.index = {};
        this.data = options.data || [];
        this.heapify();
      }
      /**
       * Returns `true` if the priority queue is empty, `false` otherwise.
       */
      isEmpty() {
        return this.data.length === 0;
      }
      /**
       * Inserts a value with priority to the queue. Optionally pass a unique
       * id of this item. Passing unique IDs for each item you insert allows
       * you to use the `updatePriority()` operation.
       * @param priority
       * @param value
       * @param id
       */
      insert(priority, value, id) {
        const item = { priority, value };
        const index2 = this.data.length;
        if (id) {
          item.id = id;
          this.index[id] = index2;
        }
        this.data.push(item);
        this.bubbleUp(index2);
        return this;
      }
      /**
       * Returns the value of an item with the highest priority.
       */
      peek() {
        return this.data[0] ? this.data[0].value : null;
      }
      /**
       * Returns the highest priority in the queue.
       */
      peekPriority() {
        return this.data[0] ? this.data[0].priority : null;
      }
      updatePriority(id, priority) {
        const index2 = this.index[id];
        if (typeof index2 === "undefined") {
          throw new Error(`Node with id '${id}' was not found in the heap.`);
        }
        const data2 = this.data;
        const oldPriority = data2[index2].priority;
        const comp = this.comparator(priority, oldPriority);
        if (comp < 0) {
          data2[index2].priority = priority;
          this.bubbleUp(index2);
        } else if (comp > 0) {
          data2[index2].priority = priority;
          this.bubbleDown(index2);
        }
      }
      /**
       * Removes the item with the highest priority from the queue
       *
       * @returns The value of the removed item.
       */
      remove() {
        const data2 = this.data;
        const peek = data2[0];
        const last = data2.pop();
        if (peek.id) {
          delete this.index[peek.id];
        }
        if (data2.length > 0) {
          data2[0] = last;
          if (last.id) {
            this.index[last.id] = 0;
          }
          this.bubbleDown(0);
        }
        return peek ? peek.value : null;
      }
      heapify() {
        for (let i = 0; i < this.data.length; i += 1) {
          this.bubbleUp(i);
        }
      }
      bubbleUp(index2) {
        const data2 = this.data;
        let tmp;
        let parent;
        let current = index2;
        while (current > 0) {
          parent = current - 1 >>> 1;
          if (this.comparator(data2[current].priority, data2[parent].priority) < 0) {
            tmp = data2[parent];
            data2[parent] = data2[current];
            let id = data2[current].id;
            if (id != null) {
              this.index[id] = parent;
            }
            data2[current] = tmp;
            id = data2[current].id;
            if (id != null) {
              this.index[id] = current;
            }
            current = parent;
          } else {
            break;
          }
        }
      }
      bubbleDown(index2) {
        const data2 = this.data;
        const last = data2.length - 1;
        let current = index2;
        while (true) {
          const left = (current << 1) + 1;
          const right = left + 1;
          let minIndex = current;
          if (left <= last && this.comparator(data2[left].priority, data2[minIndex].priority) < 0) {
            minIndex = left;
          }
          if (right <= last && this.comparator(data2[right].priority, data2[minIndex].priority) < 0) {
            minIndex = right;
          }
          if (minIndex !== current) {
            const tmp = data2[minIndex];
            data2[minIndex] = data2[current];
            let id = data2[current].id;
            if (id != null) {
              this.index[id] = minIndex;
            }
            data2[current] = tmp;
            id = data2[current].id;
            if (id != null) {
              this.index[id] = current;
            }
            current = minIndex;
          } else {
            break;
          }
        }
      }
    };
    (function(PriorityQueue2) {
      PriorityQueue2.defaultComparator = (a, b) => a - b;
    })(PriorityQueue || (PriorityQueue = {}));
  }
});

// node_modules/@antv/x6-common/es/algorithm/dijkstra.js
var Dijkstra;
var init_dijkstra = __esm({
  "node_modules/@antv/x6-common/es/algorithm/dijkstra.js"() {
    init_priorityqueue();
    (function(Dijkstra2) {
      function run(adjacencyList, source, weight = (u, v) => 1) {
        const dist = {};
        const previous = {};
        const scanned = {};
        const queue = new PriorityQueue();
        dist[source] = 0;
        Object.keys(adjacencyList).forEach((v) => {
          if (v !== source) {
            dist[v] = Infinity;
          }
          queue.insert(dist[v], v, v);
        });
        while (!queue.isEmpty()) {
          const u = queue.remove();
          scanned[u] = true;
          const neighbours = adjacencyList[u] || [];
          for (let i = 0; i < neighbours.length; i += 1) {
            const v = neighbours[i];
            if (!scanned[v]) {
              const alt = dist[u] + weight(u, v);
              if (alt < dist[v]) {
                dist[v] = alt;
                previous[v] = u;
                queue.updatePriority(v, alt);
              }
            }
          }
        }
        return previous;
      }
      Dijkstra2.run = run;
    })(Dijkstra || (Dijkstra = {}));
  }
});

// node_modules/@antv/x6-common/es/color/index.js
var Color;
var init_color = __esm({
  "node_modules/@antv/x6-common/es/color/index.js"() {
    init_number2();
    Color = class _Color {
      constructor(color, g, b, a) {
        if (color == null) {
          return this.set(255, 255, 255, 1);
        }
        if (typeof color === "number") {
          return this.set(color, g, b, a);
        }
        if (typeof color === "string") {
          return _Color.fromString(color) || this;
        }
        if (Array.isArray(color)) {
          return this.set(color);
        }
        this.set(color.r, color.g, color.b, color.a == null ? 1 : color.a);
      }
      blend(start, end, weight) {
        this.set(start.r + (end.r - start.r) * weight, start.g + (end.g - start.g) * weight, start.b + (end.b - start.b) * weight, start.a + (end.a - start.a) * weight);
      }
      lighten(amount) {
        const rgba = _Color.lighten(this.toArray(), amount);
        this.r = rgba[0];
        this.g = rgba[1];
        this.b = rgba[2];
        this.a = rgba[3];
      }
      darken(amount) {
        this.lighten(-amount);
      }
      set(arg0, arg1, arg2, arg3) {
        const r = Array.isArray(arg0) ? arg0[0] : arg0;
        const g = Array.isArray(arg0) ? arg0[1] : arg1;
        const b = Array.isArray(arg0) ? arg0[2] : arg2;
        const a = Array.isArray(arg0) ? arg0[3] : arg3;
        this.r = Math.round(number_exports.clamp(r, 0, 255));
        this.g = Math.round(number_exports.clamp(g, 0, 255));
        this.b = Math.round(number_exports.clamp(b, 0, 255));
        this.a = a == null ? 1 : number_exports.clamp(a, 0, 1);
        return this;
      }
      toHex() {
        const hex = ["r", "g", "b"].map((key) => {
          const str = this[key].toString(16);
          return str.length < 2 ? `0${str}` : str;
        });
        return `#${hex.join("")}`;
      }
      toRGBA() {
        return this.toArray();
      }
      toHSLA() {
        return _Color.rgba2hsla(this.r, this.g, this.b, this.a);
      }
      toCSS(ignoreAlpha) {
        const rgb = `${this.r},${this.g},${this.b},`;
        return ignoreAlpha ? `rgb(${rgb})` : `rgba(${rgb},${this.a})`;
      }
      toGrey() {
        return _Color.makeGrey(Math.round((this.r + this.g + this.b) / 3), this.a);
      }
      toArray() {
        return [this.r, this.g, this.b, this.a];
      }
      toString() {
        return this.toCSS();
      }
    };
    (function(Color2) {
      function fromArray(arr) {
        return new Color2(arr);
      }
      Color2.fromArray = fromArray;
      function fromHex(color) {
        return new Color2([...hex2rgb(color), 1]);
      }
      Color2.fromHex = fromHex;
      function fromRGBA(color) {
        const matches = color.toLowerCase().match(/^rgba?\(([\s.,0-9]+)\)/);
        if (matches) {
          const arr = matches[1].split(/\s*,\s*/).map((v) => parseInt(v, 10));
          return new Color2(arr);
        }
        return null;
      }
      Color2.fromRGBA = fromRGBA;
      function hue2rgb(m1, m2, h) {
        if (h < 0) {
          ++h;
        }
        if (h > 1) {
          --h;
        }
        const h6 = 6 * h;
        if (h6 < 1) {
          return m1 + (m2 - m1) * h6;
        }
        if (2 * h < 1) {
          return m2;
        }
        if (3 * h < 2) {
          return m1 + (m2 - m1) * (2 / 3 - h) * 6;
        }
        return m1;
      }
      function fromHSLA(color) {
        const matches = color.toLowerCase().match(/^hsla?\(([\s.,0-9]+)\)/);
        if (matches) {
          const arr = matches[2].split(/\s*,\s*/);
          const h = (parseFloat(arr[0]) % 360 + 360) % 360 / 360;
          const s = parseFloat(arr[1]) / 100;
          const l = parseFloat(arr[2]) / 100;
          const a = arr[3] == null ? 1 : parseInt(arr[3], 10);
          return new Color2(hsla2rgba(h, s, l, a));
        }
        return null;
      }
      Color2.fromHSLA = fromHSLA;
      function fromString(color) {
        if (color.startsWith("#")) {
          return fromHex(color);
        }
        if (color.startsWith("rgb")) {
          return fromRGBA(color);
        }
        const preset = Color2.named[color];
        if (preset) {
          return fromHex(preset);
        }
        return fromHSLA(color);
      }
      Color2.fromString = fromString;
      function makeGrey(g, a) {
        return Color2.fromArray([g, g, g, a]);
      }
      Color2.makeGrey = makeGrey;
      function rgba2hsla(arg0, arg1, arg2, arg3) {
        const r = Array.isArray(arg0) ? arg0[0] : arg0;
        const g = Array.isArray(arg0) ? arg0[1] : arg1;
        const b = Array.isArray(arg0) ? arg0[2] : arg2;
        const a = Array.isArray(arg0) ? arg0[3] : arg3;
        const max = Math.max(r, g, b);
        const min = Math.min(r, g, b);
        const l = (max + min) / 2;
        let h = 0;
        let s = 0;
        if (min !== max) {
          const d = max - min;
          s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
          switch (max) {
            case r:
              h = (g - b) / d + (g < b ? 6 : 0);
              break;
            case g:
              h = (b - r) / d + 2;
              break;
            case b:
              h = (r - g) / d + 4;
              break;
            default:
              break;
          }
          h /= 6;
        }
        return [h, s, l, a == null ? 1 : a];
      }
      Color2.rgba2hsla = rgba2hsla;
      function hsla2rgba(arg0, arg1, arg2, arg3) {
        const h = Array.isArray(arg0) ? arg0[0] : arg0;
        const s = Array.isArray(arg0) ? arg0[1] : arg1;
        const l = Array.isArray(arg0) ? arg0[2] : arg2;
        const a = Array.isArray(arg0) ? arg0[3] : arg3;
        const m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
        const m1 = 2 * l - m2;
        return [
          hue2rgb(m1, m2, h + 1 / 3) * 256,
          hue2rgb(m1, m2, h) * 256,
          hue2rgb(m1, m2, h - 1 / 3) * 256,
          a == null ? 1 : a
        ];
      }
      Color2.hsla2rgba = hsla2rgba;
      function random2(ignoreAlpha) {
        return new Color2(Math.round(Math.random() * 256), Math.round(Math.random() * 256), Math.round(Math.random() * 256), ignoreAlpha ? void 0 : parseFloat(Math.random().toFixed(2)));
      }
      Color2.random = random2;
      function randomHex() {
        const letters = "0123456789ABCDEF";
        let color = "#";
        for (let i = 0; i < 6; i += 1) {
          color += letters[Math.floor(Math.random() * 16)];
        }
        return color;
      }
      Color2.randomHex = randomHex;
      function randomRGBA(ignoreAlpha) {
        return random2(ignoreAlpha).toString();
      }
      Color2.randomRGBA = randomRGBA;
      function invert(color, bw) {
        if (typeof color === "string") {
          const pound = color[0] === "#";
          const [r2, g2, b2] = hex2rgb(color);
          if (bw) {
            return r2 * 0.299 + g2 * 0.587 + b2 * 0.114 > 186 ? "#000000" : "#ffffff";
          }
          return `${pound ? "#" : ""}${rgb2hex(255 - r2, 255 - g2, 255 - b2)}`;
        }
        const r = color[0];
        const g = color[1];
        const b = color[2];
        const a = color[3];
        if (bw) {
          return r * 0.299 + g * 0.587 + b * 0.114 > 186 ? [0, 0, 0, a] : [255, 255, 255, a];
        }
        return [255 - r, 255 - g, 255 - b, a];
      }
      Color2.invert = invert;
      function hex2rgb(hex) {
        const color = hex.indexOf("#") === 0 ? hex : `#${hex}`;
        let val = Number(`0x${color.substr(1)}`);
        if (!(color.length === 4 || color.length === 7) || Number.isNaN(val)) {
          throw new Error("Invalid hex color.");
        }
        const bits = color.length === 4 ? 4 : 8;
        const mask = (1 << bits) - 1;
        const bgr = ["b", "g", "r"].map(() => {
          const c = val & mask;
          val >>= bits;
          return bits === 4 ? 17 * c : c;
        });
        return [bgr[2], bgr[1], bgr[0]];
      }
      function rgb2hex(r, g, b) {
        const pad = (hex) => hex.length < 2 ? `0${hex}` : hex;
        return `${pad(r.toString(16))}${pad(g.toString(16))}${pad(b.toString(16))}`;
      }
      function lighten(color, amt) {
        return lum(color, amt);
      }
      Color2.lighten = lighten;
      function darken(color, amt) {
        return lum(color, -amt);
      }
      Color2.darken = darken;
      function lum(color, amt) {
        if (typeof color === "string") {
          const pound = color[0] === "#";
          const num = parseInt(pound ? color.substr(1) : color, 16);
          const r = number_exports.clamp((num >> 16) + amt, 0, 255);
          const g = number_exports.clamp((num >> 8 & 255) + amt, 0, 255);
          const b = number_exports.clamp((num & 255) + amt, 0, 255);
          return `${pound ? "#" : ""}${(b | g << 8 | r << 16).toString(16)}`;
        }
        const hex = rgb2hex(color[0], color[1], color[2]);
        const arr = hex2rgb(lum(hex, amt));
        return [arr[0], arr[1], arr[2], color[3]];
      }
    })(Color || (Color = {}));
    (function(Color2) {
      Color2.named = {
        aliceblue: "#f0f8ff",
        antiquewhite: "#faebd7",
        aqua: "#00ffff",
        aquamarine: "#7fffd4",
        azure: "#f0ffff",
        beige: "#f5f5dc",
        bisque: "#ffe4c4",
        black: "#000000",
        blanchedalmond: "#ffebcd",
        blue: "#0000ff",
        blueviolet: "#8a2be2",
        brown: "#a52a2a",
        burlywood: "#deb887",
        burntsienna: "#ea7e5d",
        cadetblue: "#5f9ea0",
        chartreuse: "#7fff00",
        chocolate: "#d2691e",
        coral: "#ff7f50",
        cornflowerblue: "#6495ed",
        cornsilk: "#fff8dc",
        crimson: "#dc143c",
        cyan: "#00ffff",
        darkblue: "#00008b",
        darkcyan: "#008b8b",
        darkgoldenrod: "#b8860b",
        darkgray: "#a9a9a9",
        darkgreen: "#006400",
        darkgrey: "#a9a9a9",
        darkkhaki: "#bdb76b",
        darkmagenta: "#8b008b",
        darkolivegreen: "#556b2f",
        darkorange: "#ff8c00",
        darkorchid: "#9932cc",
        darkred: "#8b0000",
        darksalmon: "#e9967a",
        darkseagreen: "#8fbc8f",
        darkslateblue: "#483d8b",
        darkslategray: "#2f4f4f",
        darkslategrey: "#2f4f4f",
        darkturquoise: "#00ced1",
        darkviolet: "#9400d3",
        deeppink: "#ff1493",
        deepskyblue: "#00bfff",
        dimgray: "#696969",
        dimgrey: "#696969",
        dodgerblue: "#1e90ff",
        firebrick: "#b22222",
        floralwhite: "#fffaf0",
        forestgreen: "#228b22",
        fuchsia: "#ff00ff",
        gainsboro: "#dcdcdc",
        ghostwhite: "#f8f8ff",
        gold: "#ffd700",
        goldenrod: "#daa520",
        gray: "#808080",
        green: "#008000",
        greenyellow: "#adff2f",
        grey: "#808080",
        honeydew: "#f0fff0",
        hotpink: "#ff69b4",
        indianred: "#cd5c5c",
        indigo: "#4b0082",
        ivory: "#fffff0",
        khaki: "#f0e68c",
        lavender: "#e6e6fa",
        lavenderblush: "#fff0f5",
        lawngreen: "#7cfc00",
        lemonchiffon: "#fffacd",
        lightblue: "#add8e6",
        lightcoral: "#f08080",
        lightcyan: "#e0ffff",
        lightgoldenrodyellow: "#fafad2",
        lightgray: "#d3d3d3",
        lightgreen: "#90ee90",
        lightgrey: "#d3d3d3",
        lightpink: "#ffb6c1",
        lightsalmon: "#ffa07a",
        lightseagreen: "#20b2aa",
        lightskyblue: "#87cefa",
        lightslategray: "#778899",
        lightslategrey: "#778899",
        lightsteelblue: "#b0c4de",
        lightyellow: "#ffffe0",
        lime: "#00ff00",
        limegreen: "#32cd32",
        linen: "#faf0e6",
        magenta: "#ff00ff",
        maroon: "#800000",
        mediumaquamarine: "#66cdaa",
        mediumblue: "#0000cd",
        mediumorchid: "#ba55d3",
        mediumpurple: "#9370db",
        mediumseagreen: "#3cb371",
        mediumslateblue: "#7b68ee",
        mediumspringgreen: "#00fa9a",
        mediumturquoise: "#48d1cc",
        mediumvioletred: "#c71585",
        midnightblue: "#191970",
        mintcream: "#f5fffa",
        mistyrose: "#ffe4e1",
        moccasin: "#ffe4b5",
        navajowhite: "#ffdead",
        navy: "#000080",
        oldlace: "#fdf5e6",
        olive: "#808000",
        olivedrab: "#6b8e23",
        orange: "#ffa500",
        orangered: "#ff4500",
        orchid: "#da70d6",
        palegoldenrod: "#eee8aa",
        palegreen: "#98fb98",
        paleturquoise: "#afeeee",
        palevioletred: "#db7093",
        papayawhip: "#ffefd5",
        peachpuff: "#ffdab9",
        peru: "#cd853f",
        pink: "#ffc0cb",
        plum: "#dda0dd",
        powderblue: "#b0e0e6",
        purple: "#800080",
        rebeccapurple: "#663399",
        red: "#ff0000",
        rosybrown: "#bc8f8f",
        royalblue: "#4169e1",
        saddlebrown: "#8b4513",
        salmon: "#fa8072",
        sandybrown: "#f4a460",
        seagreen: "#2e8b57",
        seashell: "#fff5ee",
        sienna: "#a0522d",
        silver: "#c0c0c0",
        skyblue: "#87ceeb",
        slateblue: "#6a5acd",
        slategray: "#708090",
        slategrey: "#708090",
        snow: "#fffafa",
        springgreen: "#00ff7f",
        steelblue: "#4682b4",
        tan: "#d2b48c",
        teal: "#008080",
        thistle: "#d8bfd8",
        tomato: "#ff6347",
        turquoise: "#40e0d0",
        violet: "#ee82ee",
        wheat: "#f5deb3",
        white: "#ffffff",
        whitesmoke: "#f5f5f5",
        yellow: "#ffff00",
        yellowgreen: "#9acd32"
      };
    })(Color || (Color = {}));
  }
});

// node_modules/@antv/x6-common/es/dictionary/dictionary.js
var Dictionary;
var init_dictionary = __esm({
  "node_modules/@antv/x6-common/es/dictionary/dictionary.js"() {
    Dictionary = class {
      constructor() {
        this.clear();
      }
      clear() {
        this.map = /* @__PURE__ */ new WeakMap();
        this.arr = [];
      }
      has(key) {
        return this.map.has(key);
      }
      get(key) {
        return this.map.get(key);
      }
      set(key, value) {
        this.map.set(key, value);
        this.arr.push(key);
      }
      delete(key) {
        const index2 = this.arr.indexOf(key);
        if (index2 >= 0) {
          this.arr.splice(index2, 1);
        }
        const ret = this.map.get(key);
        this.map.delete(key);
        return ret;
      }
      each(iterator) {
        this.arr.forEach((key) => {
          const value = this.map.get(key);
          iterator(value, key);
        });
      }
      dispose() {
        this.clear();
      }
    };
  }
});

// node_modules/@antv/x6-common/es/modifier/index.js
var ModifierKey;
var init_modifier = __esm({
  "node_modules/@antv/x6-common/es/modifier/index.js"() {
    (function(ModifierKey2) {
      function parse2(modifiers) {
        const or = [];
        const and = [];
        if (Array.isArray(modifiers)) {
          or.push(...modifiers);
        } else {
          modifiers.split("|").forEach((item) => {
            if (item.indexOf("&") === -1) {
              or.push(item);
            } else {
              and.push(...item.split("&"));
            }
          });
        }
        return { or, and };
      }
      ModifierKey2.parse = parse2;
      function equals(modifiers1, modifiers2) {
        if (modifiers1 != null && modifiers2 != null) {
          const m1 = parse2(modifiers1);
          const m2 = parse2(modifiers2);
          const or1 = m1.or.sort();
          const or2 = m2.or.sort();
          const and1 = m1.and.sort();
          const and2 = m2.and.sort();
          const equal = (a1, a2) => {
            return a1.length === a2.length && (a1.length === 0 || a1.every((a, i) => a === a2[i]));
          };
          return equal(or1, or2) && equal(and1, and2);
        }
        if (modifiers1 == null && modifiers2 == null) {
          return true;
        }
        return false;
      }
      ModifierKey2.equals = equals;
      function isMatch(e, modifiers, strict) {
        if (modifiers == null || Array.isArray(modifiers) && modifiers.length === 0) {
          return strict ? e.altKey !== true && e.ctrlKey !== true && e.metaKey !== true && e.shiftKey !== true : true;
        }
        const { or, and } = parse2(modifiers);
        const match = (key) => {
          const name = `${key.toLowerCase()}Key`;
          return e[name] === true;
        };
        return or.some((key) => match(key)) && and.every((key) => match(key));
      }
      ModifierKey2.isMatch = isMatch;
    })(ModifierKey || (ModifierKey = {}));
  }
});

// node_modules/@antv/x6-common/es/animation/timing.js
var Timing;
var init_timing = __esm({
  "node_modules/@antv/x6-common/es/animation/timing.js"() {
    (function(Timing2) {
      Timing2.linear = (t) => t;
      Timing2.quad = (t) => t * t;
      Timing2.cubic = (t) => t * t * t;
      Timing2.inout = (t) => {
        if (t <= 0) {
          return 0;
        }
        if (t >= 1) {
          return 1;
        }
        const t2 = t * t;
        const t3 = t2 * t;
        return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
      };
      Timing2.exponential = (t) => {
        return Math.pow(2, 10 * (t - 1));
      };
      Timing2.bounce = ((t) => {
        for (let a = 0, b = 1; 1; a += b, b /= 2) {
          if (t >= (7 - 4 * a) / 11) {
            const q = (11 - 6 * a - 11 * t) / 4;
            return -q * q + b * b;
          }
        }
      });
    })(Timing || (Timing = {}));
    (function(Timing2) {
      Timing2.decorators = {
        reverse(f) {
          return (t) => 1 - f(1 - t);
        },
        reflect(f) {
          return (t) => 0.5 * (t < 0.5 ? f(2 * t) : 2 - f(2 - 2 * t));
        },
        clamp(f, n = 0, x = 1) {
          return (t) => {
            const r = f(t);
            return r < n ? n : r > x ? x : r;
          };
        },
        back(s = 1.70158) {
          return (t) => t * t * ((s + 1) * t - s);
        },
        elastic(x = 1.5) {
          return (t) => Math.pow(2, 10 * (t - 1)) * Math.cos(20 * Math.PI * x / 3 * t);
        }
      };
    })(Timing || (Timing = {}));
    (function(Timing2) {
      function easeInSine(t) {
        return -1 * Math.cos(t * (Math.PI / 2)) + 1;
      }
      Timing2.easeInSine = easeInSine;
      function easeOutSine(t) {
        return Math.sin(t * (Math.PI / 2));
      }
      Timing2.easeOutSine = easeOutSine;
      function easeInOutSine(t) {
        return -0.5 * (Math.cos(Math.PI * t) - 1);
      }
      Timing2.easeInOutSine = easeInOutSine;
      function easeInQuad(t) {
        return t * t;
      }
      Timing2.easeInQuad = easeInQuad;
      function easeOutQuad(t) {
        return t * (2 - t);
      }
      Timing2.easeOutQuad = easeOutQuad;
      function easeInOutQuad(t) {
        return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
      }
      Timing2.easeInOutQuad = easeInOutQuad;
      function easeInCubic(t) {
        return t * t * t;
      }
      Timing2.easeInCubic = easeInCubic;
      function easeOutCubic(t) {
        const t1 = t - 1;
        return t1 * t1 * t1 + 1;
      }
      Timing2.easeOutCubic = easeOutCubic;
      function easeInOutCubic(t) {
        return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
      }
      Timing2.easeInOutCubic = easeInOutCubic;
      function easeInQuart(t) {
        return t * t * t * t;
      }
      Timing2.easeInQuart = easeInQuart;
      function easeOutQuart(t) {
        const t1 = t - 1;
        return 1 - t1 * t1 * t1 * t1;
      }
      Timing2.easeOutQuart = easeOutQuart;
      function easeInOutQuart(t) {
        const t1 = t - 1;
        return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * t1 * t1 * t1 * t1;
      }
      Timing2.easeInOutQuart = easeInOutQuart;
      function easeInQuint(t) {
        return t * t * t * t * t;
      }
      Timing2.easeInQuint = easeInQuint;
      function easeOutQuint(t) {
        const t1 = t - 1;
        return 1 + t1 * t1 * t1 * t1 * t1;
      }
      Timing2.easeOutQuint = easeOutQuint;
      function easeInOutQuint(t) {
        const t1 = t - 1;
        return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * t1 * t1 * t1 * t1 * t1;
      }
      Timing2.easeInOutQuint = easeInOutQuint;
      function easeInExpo(t) {
        if (t === 0) {
          return 0;
        }
        return Math.pow(2, 10 * (t - 1));
      }
      Timing2.easeInExpo = easeInExpo;
      function easeOutExpo(t) {
        if (t === 1) {
          return 1;
        }
        return -Math.pow(2, -10 * t) + 1;
      }
      Timing2.easeOutExpo = easeOutExpo;
      function easeInOutExpo(t) {
        if (t === 0 || t === 1) {
          return t;
        }
        const scaledTime = t * 2;
        const scaledTime1 = scaledTime - 1;
        if (scaledTime < 1) {
          return 0.5 * Math.pow(2, 10 * scaledTime1);
        }
        return 0.5 * (-Math.pow(2, -10 * scaledTime1) + 2);
      }
      Timing2.easeInOutExpo = easeInOutExpo;
      function easeInCirc(t) {
        const scaledTime = t / 1;
        return -1 * (Math.sqrt(1 - scaledTime * t) - 1);
      }
      Timing2.easeInCirc = easeInCirc;
      function easeOutCirc(t) {
        const t1 = t - 1;
        return Math.sqrt(1 - t1 * t1);
      }
      Timing2.easeOutCirc = easeOutCirc;
      function easeInOutCirc(t) {
        const scaledTime = t * 2;
        const scaledTime1 = scaledTime - 2;
        if (scaledTime < 1) {
          return -0.5 * (Math.sqrt(1 - scaledTime * scaledTime) - 1);
        }
        return 0.5 * (Math.sqrt(1 - scaledTime1 * scaledTime1) + 1);
      }
      Timing2.easeInOutCirc = easeInOutCirc;
      function easeInBack(t, magnitude = 1.70158) {
        return t * t * ((magnitude + 1) * t - magnitude);
      }
      Timing2.easeInBack = easeInBack;
      function easeOutBack(t, magnitude = 1.70158) {
        const scaledTime = t / 1 - 1;
        return scaledTime * scaledTime * ((magnitude + 1) * scaledTime + magnitude) + 1;
      }
      Timing2.easeOutBack = easeOutBack;
      function easeInOutBack(t, magnitude = 1.70158) {
        const scaledTime = t * 2;
        const scaledTime2 = scaledTime - 2;
        const s = magnitude * 1.525;
        if (scaledTime < 1) {
          return 0.5 * scaledTime * scaledTime * ((s + 1) * scaledTime - s);
        }
        return 0.5 * (scaledTime2 * scaledTime2 * ((s + 1) * scaledTime2 + s) + 2);
      }
      Timing2.easeInOutBack = easeInOutBack;
      function easeInElastic(t, magnitude = 0.7) {
        if (t === 0 || t === 1) {
          return t;
        }
        const scaledTime = t / 1;
        const scaledTime1 = scaledTime - 1;
        const p = 1 - magnitude;
        const s = p / (2 * Math.PI) * Math.asin(1);
        return -(Math.pow(2, 10 * scaledTime1) * // eslint-disable-line
        Math.sin((scaledTime1 - s) * (2 * Math.PI) / p));
      }
      Timing2.easeInElastic = easeInElastic;
      function easeOutElastic(t, magnitude = 0.7) {
        const p = 1 - magnitude;
        const scaledTime = t * 2;
        if (t === 0 || t === 1) {
          return t;
        }
        const s = p / (2 * Math.PI) * Math.asin(1);
        return Math.pow(2, -10 * scaledTime) * // eslint-disable-line
        Math.sin((scaledTime - s) * (2 * Math.PI) / p) + 1;
      }
      Timing2.easeOutElastic = easeOutElastic;
      function easeInOutElastic(t, magnitude = 0.65) {
        const p = 1 - magnitude;
        if (t === 0 || t === 1) {
          return t;
        }
        const scaledTime = t * 2;
        const scaledTime1 = scaledTime - 1;
        const s = p / (2 * Math.PI) * Math.asin(1);
        if (scaledTime < 1) {
          return -0.5 * (Math.pow(2, 10 * scaledTime1) * // eslint-disable-line
          Math.sin((scaledTime1 - s) * (2 * Math.PI) / p));
        }
        return Math.pow(2, -10 * scaledTime1) * // eslint-disable-line
        Math.sin((scaledTime1 - s) * (2 * Math.PI) / p) * 0.5 + 1;
      }
      Timing2.easeInOutElastic = easeInOutElastic;
      function easeOutBounce(t) {
        const scaledTime = t / 1;
        if (scaledTime < 1 / 2.75) {
          return 7.5625 * scaledTime * scaledTime;
        }
        if (scaledTime < 2 / 2.75) {
          const scaledTime2 = scaledTime - 1.5 / 2.75;
          return 7.5625 * scaledTime2 * scaledTime2 + 0.75;
        }
        if (scaledTime < 2.5 / 2.75) {
          const scaledTime2 = scaledTime - 2.25 / 2.75;
          return 7.5625 * scaledTime2 * scaledTime2 + 0.9375;
        }
        {
          const scaledTime2 = scaledTime - 2.625 / 2.75;
          return 7.5625 * scaledTime2 * scaledTime2 + 0.984375;
        }
      }
      Timing2.easeOutBounce = easeOutBounce;
      function easeInBounce(t) {
        return 1 - easeOutBounce(1 - t);
      }
      Timing2.easeInBounce = easeInBounce;
      function easeInOutBounce(t) {
        if (t < 0.5) {
          return easeInBounce(t * 2) * 0.5;
        }
        return easeOutBounce(t * 2 - 1) * 0.5 + 0.5;
      }
      Timing2.easeInOutBounce = easeInOutBounce;
    })(Timing || (Timing = {}));
  }
});

// node_modules/@antv/x6-common/es/animation/interp.js
var Interp;
var init_interp = __esm({
  "node_modules/@antv/x6-common/es/animation/interp.js"() {
    (function(Interp2) {
      Interp2.number = (a, b) => {
        const d = b - a;
        return (t) => {
          return a + d * t;
        };
      };
      Interp2.object = (a, b) => {
        const keys = Object.keys(a);
        return (t) => {
          const ret = {};
          for (let i = keys.length - 1; i !== -1; i -= 1) {
            const key = keys[i];
            ret[key] = a[key] + (b[key] - a[key]) * t;
          }
          return ret;
        };
      };
      Interp2.unit = (a, b) => {
        const reg = /(-?[0-9]*.[0-9]*)(px|em|cm|mm|in|pt|pc|%)/;
        const ma = reg.exec(a);
        const mb = reg.exec(b);
        const pb = mb ? mb[1] : "";
        const aa = ma ? +ma[1] : 0;
        const bb = mb ? +mb[1] : 0;
        const index2 = pb.indexOf(".");
        const precision = index2 > 0 ? pb[1].length - index2 - 1 : 0;
        const d = bb - aa;
        const u = ma ? ma[2] : "";
        return (t) => {
          return (aa + d * t).toFixed(precision) + u;
        };
      };
      Interp2.color = (a, b) => {
        const ca = parseInt(a.slice(1), 16);
        const cb = parseInt(b.slice(1), 16);
        const ra = ca & 255;
        const rd = (cb & 255) - ra;
        const ga = ca & 65280;
        const gd = (cb & 65280) - ga;
        const ba = ca & 16711680;
        const bd = (cb & 16711680) - ba;
        return (t) => {
          const r = ra + rd * t & 255;
          const g = ga + gd * t & 65280;
          const b2 = ba + bd * t & 16711680;
          return `#${(1 << 24 | r | g | b2).toString(16).slice(1)}`;
        };
      };
    })(Interp || (Interp = {}));
  }
});

// node_modules/@antv/x6-common/es/css-loader/loader.js
var loader_exports = {};
__export(loader_exports, {
  clean: () => clean,
  ensure: () => ensure2
});
function ensure2(name, content) {
  const cssModule = cssModules.find((m) => m.name === name);
  if (cssModule) {
    cssModule.loadTimes += 1;
    if (cssModule.loadTimes > 1) {
      return;
    }
  }
  if (!Platform.isApplyingHMR()) {
    const styleElement = document.createElement("style");
    styleElement.setAttribute("type", "text/css");
    styleElement.textContent = content;
    const head = document.querySelector("head");
    if (head) {
      head.insertBefore(styleElement, head.firstChild);
    }
    cssModules.push({
      name,
      loadTimes: 1,
      styleElement
    });
  }
}
function clean(name) {
  const index2 = cssModules.findIndex((m) => m.name === name);
  if (index2 > -1) {
    const cssModule = cssModules[index2];
    cssModule.loadTimes -= 1;
    if (cssModule.loadTimes > 0) {
      return;
    }
    let styleElement = cssModule.styleElement;
    if (styleElement && styleElement.parentNode) {
      styleElement.parentNode.removeChild(styleElement);
    }
    styleElement = null;
    cssModules.splice(index2, 1);
  }
}
var cssModules;
var init_loader = __esm({
  "node_modules/@antv/x6-common/es/css-loader/loader.js"() {
    init_platform();
    cssModules = [];
  }
});

// node_modules/@antv/x6-common/es/css-loader/index.js
var init_css_loader = __esm({
  "node_modules/@antv/x6-common/es/css-loader/index.js"() {
    init_loader();
  }
});

// node_modules/@antv/x6-common/es/polyfill/index.js
var init_polyfill = __esm({
  "node_modules/@antv/x6-common/es/polyfill/index.js"() {
    if (typeof window === "object" && window.NodeList && !NodeList.prototype.forEach) {
      NodeList.prototype.forEach = Array.prototype.forEach;
    }
    if (typeof window !== "undefined") {
      ;
      (function(arr) {
        arr.forEach((item) => {
          if (Object.prototype.hasOwnProperty.call(item, "append")) {
            return;
          }
          Object.defineProperty(item, "append", {
            configurable: true,
            enumerable: true,
            writable: true,
            value(...args) {
              const docFrag = document.createDocumentFragment();
              args.forEach((arg) => {
                const isNode = arg instanceof Node;
                docFrag.appendChild(isNode ? arg : document.createTextNode(String(arg)));
              });
              this.appendChild(docFrag);
            }
          });
        });
      })([Element.prototype, Document.prototype, DocumentFragment.prototype]);
    }
  }
});

// node_modules/@antv/x6-common/es/common/index.js
var init_common = __esm({
  "node_modules/@antv/x6-common/es/common/index.js"() {
    init_disposable();
    init_disablable();
    init_basecoat();
  }
});

// node_modules/@antv/x6-common/es/algorithm/index.js
var init_algorithm = __esm({
  "node_modules/@antv/x6-common/es/algorithm/index.js"() {
    init_priorityqueue();
    init_dijkstra();
  }
});

// node_modules/@antv/x6-common/es/dictionary/index.js
var init_dictionary2 = __esm({
  "node_modules/@antv/x6-common/es/dictionary/index.js"() {
    init_dictionary();
  }
});

// node_modules/@antv/x6-common/es/animation/index.js
var init_animation = __esm({
  "node_modules/@antv/x6-common/es/animation/index.js"() {
    init_timing();
    init_interp();
  }
});

// node_modules/@antv/x6-common/es/types.js
var init_types2 = __esm({
  "node_modules/@antv/x6-common/es/types.js"() {
  }
});

// node_modules/@antv/x6-common/es/index.js
var es_exports = {};
__export(es_exports, {
  ArrayExt: () => array_exports,
  Basecoat: () => Basecoat,
  Color: () => Color,
  CssLoader: () => loader_exports,
  DataUri: () => DataUri,
  Dictionary: () => Dictionary,
  Dijkstra: () => Dijkstra,
  Disablable: () => Disablable,
  Disposable: () => Disposable,
  DisposableDelegate: () => DisposableDelegate,
  DisposableSet: () => DisposableSet,
  Dom: () => main_exports3,
  Events: () => Events,
  FunctionExt: () => main_exports,
  Interp: () => Interp,
  ModifierKey: () => ModifierKey,
  NumberExt: () => number_exports,
  ObjectExt: () => object_exports,
  Platform: () => Platform,
  PriorityQueue: () => PriorityQueue,
  SizeSensor: () => SizeSensor,
  StringExt: () => string_exports,
  Text: () => main_exports2,
  Timing: () => Timing,
  Unit: () => Unit,
  Vector: () => Vector
});
var init_es = __esm({
  "node_modules/@antv/x6-common/es/index.js"() {
    init_polyfill();
    init_common();
    init_array2();
    init_object2();
    init_string2();
    init_number2();
    init_function2();
    init_platform();
    init_text();
    init_datauri();
    init_unit();
    init_dom();
    init_vector();
    init_size_sensor();
    init_algorithm();
    init_color();
    init_event();
    init_dictionary2();
    init_modifier();
    init_animation();
    init_css_loader();
    init_types2();
  }
});

// node_modules/@antv/x6-geometry/es/angle.js
var Angle;
var init_angle = __esm({
  "node_modules/@antv/x6-geometry/es/angle.js"() {
    (function(Angle2) {
      function toDeg(rad) {
        return 180 * rad / Math.PI % 360;
      }
      Angle2.toDeg = toDeg;
      Angle2.toRad = function(deg, over360 = false) {
        const d = over360 ? deg : deg % 360;
        return d * Math.PI / 180;
      };
      function normalize2(angle) {
        return angle % 360 + (angle < 0 ? 360 : 0);
      }
      Angle2.normalize = normalize2;
    })(Angle || (Angle = {}));
  }
});

// node_modules/@antv/x6-geometry/es/util.js
var GeometryUtil;
var init_util4 = __esm({
  "node_modules/@antv/x6-geometry/es/util.js"() {
    (function(GeometryUtil2) {
      function round(num, precision = 0) {
        return Number.isInteger(num) ? num : +num.toFixed(precision);
      }
      GeometryUtil2.round = round;
      function random2(min, max) {
        let mmin;
        let mmax;
        if (max == null) {
          mmax = min == null ? 1 : min;
          mmin = 0;
        } else {
          mmax = max;
          mmin = min == null ? 0 : min;
        }
        if (mmax < mmin) {
          const temp = mmin;
          mmin = mmax;
          mmax = temp;
        }
        return Math.floor(Math.random() * (mmax - mmin + 1) + mmin);
      }
      GeometryUtil2.random = random2;
      function clamp(value, min, max) {
        if (Number.isNaN(value)) {
          return NaN;
        }
        if (Number.isNaN(min) || Number.isNaN(max)) {
          return 0;
        }
        return min < max ? value < min ? min : value > max ? max : value : value < max ? max : value > min ? min : value;
      }
      GeometryUtil2.clamp = clamp;
      function snapToGrid(value, gridSize) {
        return gridSize * Math.round(value / gridSize);
      }
      GeometryUtil2.snapToGrid = snapToGrid;
      function containsPoint(rect, point) {
        return point != null && rect != null && point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
      }
      GeometryUtil2.containsPoint = containsPoint;
      function squaredLength(p1, p2) {
        const dx = p1.x - p2.x;
        const dy = p1.y - p2.y;
        return dx * dx + dy * dy;
      }
      GeometryUtil2.squaredLength = squaredLength;
    })(GeometryUtil || (GeometryUtil = {}));
  }
});

// node_modules/@antv/x6-geometry/es/geometry.js
var Geometry;
var init_geometry = __esm({
  "node_modules/@antv/x6-geometry/es/geometry.js"() {
    Geometry = class {
      valueOf() {
        return this.toJSON();
      }
      toString() {
        return JSON.stringify(this.toJSON());
      }
    };
  }
});

// node_modules/@antv/x6-geometry/es/point.js
var Point;
var init_point = __esm({
  "node_modules/@antv/x6-geometry/es/point.js"() {
    init_util4();
    init_angle();
    init_geometry();
    Point = class _Point extends Geometry {
      constructor(x, y) {
        super();
        this.x = x == null ? 0 : x;
        this.y = y == null ? 0 : y;
      }
      /**
       * Rounds the point to the given precision.
       */
      round(precision = 0) {
        this.x = GeometryUtil.round(this.x, precision);
        this.y = GeometryUtil.round(this.y, precision);
        return this;
      }
      add(x, y) {
        const p = _Point.create(x, y);
        this.x += p.x;
        this.y += p.y;
        return this;
      }
      update(x, y) {
        const p = _Point.create(x, y);
        this.x = p.x;
        this.y = p.y;
        return this;
      }
      translate(dx, dy) {
        const t = _Point.create(dx, dy);
        this.x += t.x;
        this.y += t.y;
        return this;
      }
      /**
       * Rotate the point by `degree` around `center`.
       */
      rotate(degree, center) {
        const p = _Point.rotate(this, degree, center);
        this.x = p.x;
        this.y = p.y;
        return this;
      }
      /**
       * Scale point by `sx` and `sy` around the given `origin`. If origin is
       * not specified, the point is scaled around `0, 0`.
       */
      scale(sx, sy, origin = new _Point()) {
        const ref = _Point.create(origin);
        this.x = ref.x + sx * (this.x - ref.x);
        this.y = ref.y + sy * (this.y - ref.y);
        return this;
      }
      /**
       * Chooses the point closest to this point from among `points`. If `points`
       * is an empty array, `null` is returned.
       */
      closest(points) {
        if (points.length === 1) {
          return _Point.create(points[0]);
        }
        let ret = null;
        let min = Infinity;
        points.forEach((p) => {
          const dist = this.squaredDistance(p);
          if (dist < min) {
            ret = p;
            min = dist;
          }
        });
        return ret ? _Point.create(ret) : null;
      }
      /**
       * Returns the distance between the point and another point `p`.
       */
      distance(p) {
        return Math.sqrt(this.squaredDistance(p));
      }
      /**
       * Returns the squared distance between the point and another point `p`.
       *
       * Useful for distance comparisons in which real distance is not necessary
       * (saves one `Math.sqrt()` operation).
       */
      squaredDistance(p) {
        const ref = _Point.create(p);
        const dx = this.x - ref.x;
        const dy = this.y - ref.y;
        return dx * dx + dy * dy;
      }
      manhattanDistance(p) {
        const ref = _Point.create(p);
        return Math.abs(ref.x - this.x) + Math.abs(ref.y - this.y);
      }
      /**
       * Returns the magnitude of the point vector.
       *
       * @see http://en.wikipedia.org/wiki/Magnitude_(mathematics)
       */
      magnitude() {
        return Math.sqrt(this.x * this.x + this.y * this.y) || 0.01;
      }
      /**
       * Returns the angle(in degrees) between vector from this point to `p` and
       * the x-axis.
       */
      theta(p = new _Point()) {
        const ref = _Point.create(p);
        const y = -(ref.y - this.y);
        const x = ref.x - this.x;
        let rad = Math.atan2(y, x);
        if (rad < 0) {
          rad = 2 * Math.PI + rad;
        }
        return 180 * rad / Math.PI;
      }
      /**
       * Returns the angle(in degrees) between vector from this point to `p1` and
       * the vector from this point to `p2`.
       *
       * The ordering of points `p1` and `p2` is important.
       *
       * The function returns a value between `0` and `180` when the angle (in the
       * direction from `p1` to `p2`) is clockwise, and a value between `180` and
       * `360` when the angle is counterclockwise.
       *
       * Returns `NaN` if either of the points `p1` and `p2` is equal with this point.
       */
      angleBetween(p1, p2) {
        if (this.equals(p1) || this.equals(p2)) {
          return NaN;
        }
        let angle = this.theta(p2) - this.theta(p1);
        if (angle < 0) {
          angle += 360;
        }
        return angle;
      }
      /**
       * Returns the angle(in degrees) between the line from `(0,0)` and this point
       * and the line from `(0,0)` to `p`.
       *
       * The function returns a value between `0` and `180` when the angle (in the
       * direction from this point to `p`) is clockwise, and a value between `180`
       * and `360` when the angle is counterclockwise. Returns `NaN` if called from
       * point `(0,0)` or if `p` is `(0,0)`.
       */
      vectorAngle(p) {
        const zero = new _Point(0, 0);
        return zero.angleBetween(this, p);
      }
      /**
       * Converts rectangular to polar coordinates.
       */
      toPolar(origin) {
        this.update(_Point.toPolar(this, origin));
        return this;
      }
      /**
       * Returns the change in angle(in degrees) that is the result of moving the
       * point from its previous position to its current position.
       *
       * More specifically, this function computes the angle between the line from
       * the ref point to the previous position of this point(i.e. current position
       * `-dx`, `-dy`) and the line from the `ref` point to the current position of
       * this point.
       *
       * The function returns a positive value between `0` and `180` when the angle
       * (in the direction from previous position of this point to its current
       * position) is clockwise, and a negative value between `0` and `-180` when
       * the angle is counterclockwise.
       *
       * The function returns `0` if the previous and current positions of this
       * point are the same (i.e. both `dx` and `dy` are `0`).
       */
      changeInAngle(dx, dy, ref = new _Point()) {
        return this.clone().translate(-dx, -dy).theta(ref) - this.theta(ref);
      }
      /**
       * If the point lies outside the rectangle `rect`, adjust the point so that
       * it becomes the nearest point on the boundary of `rect`.
       */
      adhereToRect(rect) {
        if (!GeometryUtil.containsPoint(rect, this)) {
          this.x = Math.min(Math.max(this.x, rect.x), rect.x + rect.width);
          this.y = Math.min(Math.max(this.y, rect.y), rect.y + rect.height);
        }
        return this;
      }
      /**
       * Returns the bearing(cardinal direction) between me and the given point.
       *
       * @see https://en.wikipedia.org/wiki/Cardinal_direction
       */
      bearing(p) {
        const ref = _Point.create(p);
        const lat1 = Angle.toRad(this.y);
        const lat2 = Angle.toRad(ref.y);
        const lon1 = this.x;
        const lon2 = ref.x;
        const dLon = Angle.toRad(lon2 - lon1);
        const y = Math.sin(dLon) * Math.cos(lat2);
        const x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
        const brng = Angle.toDeg(Math.atan2(y, x));
        const bearings = ["NE", "E", "SE", "S", "SW", "W", "NW", "N"];
        let index2 = brng - 22.5;
        if (index2 < 0) {
          index2 += 360;
        }
        index2 = parseInt(index2 / 45, 10);
        return bearings[index2];
      }
      /**
       * Returns the cross product of the vector from me to `p1` and the vector
       * from me to `p2`.
       *
       * The left-hand rule is used because the coordinate system is left-handed.
       */
      cross(p1, p2) {
        if (p1 != null && p2 != null) {
          const a = _Point.create(p1);
          const b = _Point.create(p2);
          return (b.x - this.x) * (a.y - this.y) - (b.y - this.y) * (a.x - this.x);
        }
        return NaN;
      }
      /**
       * Returns the dot product of this point with given other point.
       */
      dot(p) {
        const ref = _Point.create(p);
        return this.x * ref.x + this.y * ref.y;
      }
      diff(dx, dy) {
        if (typeof dx === "number") {
          return new _Point(this.x - dx, this.y - dy);
        }
        const p = _Point.create(dx);
        return new _Point(this.x - p.x, this.y - p.y);
      }
      /**
       * Returns an interpolation between me and point `p` for a parametert in
       * the closed interval `[0, 1]`.
       */
      lerp(p, t) {
        const ref = _Point.create(p);
        return new _Point((1 - t) * this.x + t * ref.x, (1 - t) * this.y + t * ref.y);
      }
      /**
       * Normalize the point vector, scale the line segment between `(0, 0)`
       * and the point in order for it to have the given length. If length is
       * not specified, it is considered to be `1`; in that case, a unit vector
       * is computed.
       */
      normalize(length = 1) {
        const scale2 = length / this.magnitude();
        return this.scale(scale2, scale2);
      }
      /**
       * Moves this point along the line starting from `ref` to this point by a
       * certain `distance`.
       */
      move(ref, distance) {
        const p = _Point.create(ref);
        const rad = Angle.toRad(p.theta(this));
        return this.translate(Math.cos(rad) * distance, -Math.sin(rad) * distance);
      }
      /**
       * Returns a point that is the reflection of me with the center of inversion
       * in `ref` point.
       */
      reflection(ref) {
        return _Point.create(ref).move(this, this.distance(ref));
      }
      snapToGrid(gx, gy) {
        this.x = GeometryUtil.snapToGrid(this.x, gx);
        this.y = GeometryUtil.snapToGrid(this.y, gy == null ? gx : gy);
        return this;
      }
      equals(p) {
        const ref = _Point.create(p);
        return ref != null && ref.x === this.x && ref.y === this.y;
      }
      clone() {
        return _Point.clone(this);
      }
      /**
       * Returns the point as a simple JSON object. For example: `{ x: 0, y: 0 }`.
       */
      toJSON() {
        return _Point.toJSON(this);
      }
      serialize() {
        return `${this.x} ${this.y}`;
      }
    };
    (function(Point2) {
      function isPoint(instance) {
        return instance != null && instance instanceof Point2;
      }
      Point2.isPoint = isPoint;
    })(Point || (Point = {}));
    (function(Point2) {
      function isPointLike(p) {
        return p != null && typeof p === "object" && typeof p.x === "number" && typeof p.y === "number";
      }
      Point2.isPointLike = isPointLike;
      function isPointData(p) {
        return p != null && Array.isArray(p) && p.length === 2 && typeof p[0] === "number" && typeof p[1] === "number";
      }
      Point2.isPointData = isPointData;
    })(Point || (Point = {}));
    (function(Point2) {
      function create(x, y) {
        if (x == null || typeof x === "number") {
          return new Point2(x, y);
        }
        return clone(x);
      }
      Point2.create = create;
      function clone(p) {
        if (Point2.isPoint(p)) {
          return new Point2(p.x, p.y);
        }
        if (Array.isArray(p)) {
          return new Point2(p[0], p[1]);
        }
        return new Point2(p.x, p.y);
      }
      Point2.clone = clone;
      function toJSON(p) {
        if (Point2.isPoint(p)) {
          return { x: p.x, y: p.y };
        }
        if (Array.isArray(p)) {
          return { x: p[0], y: p[1] };
        }
        return { x: p.x, y: p.y };
      }
      Point2.toJSON = toJSON;
      function fromPolar(r, rad, origin = new Point2()) {
        let x = Math.abs(r * Math.cos(rad));
        let y = Math.abs(r * Math.sin(rad));
        const org = clone(origin);
        const deg = Angle.normalize(Angle.toDeg(rad));
        if (deg < 90) {
          y = -y;
        } else if (deg < 180) {
          x = -x;
          y = -y;
        } else if (deg < 270) {
          x = -x;
        }
        return new Point2(org.x + x, org.y + y);
      }
      Point2.fromPolar = fromPolar;
      function toPolar(point, origin = new Point2()) {
        const p = clone(point);
        const o = clone(origin);
        const dx = p.x - o.x;
        const dy = p.y - o.y;
        return new Point2(
          Math.sqrt(dx * dx + dy * dy),
          // r
          Angle.toRad(o.theta(p))
        );
      }
      Point2.toPolar = toPolar;
      function equals(p1, p2) {
        if (p1 === p2) {
          return true;
        }
        if (p1 != null && p2 != null) {
          return p1.x === p2.x && p1.y === p2.y;
        }
        return false;
      }
      Point2.equals = equals;
      function equalPoints(p1, p2) {
        if (p1 == null && p2 != null || p1 != null && p2 == null || p1 != null && p2 != null && p1.length !== p2.length) {
          return false;
        }
        if (p1 != null && p2 != null) {
          for (let i = 0, ii = p1.length; i < ii; i += 1) {
            if (!equals(p1[i], p2[i])) {
              return false;
            }
          }
        }
        return true;
      }
      Point2.equalPoints = equalPoints;
      function random2(x1, x2, y1, y2) {
        return new Point2(GeometryUtil.random(x1, x2), GeometryUtil.random(y1, y2));
      }
      Point2.random = random2;
      function rotate3(point, angle, center) {
        const rad = Angle.toRad(Angle.normalize(-angle));
        const sin = Math.sin(rad);
        const cos = Math.cos(rad);
        return rotateEx(point, cos, sin, center);
      }
      Point2.rotate = rotate3;
      function rotateEx(point, cos, sin, center = new Point2()) {
        const source = clone(point);
        const origin = clone(center);
        const dx = source.x - origin.x;
        const dy = source.y - origin.y;
        const x1 = dx * cos - dy * sin;
        const y1 = dy * cos + dx * sin;
        return new Point2(x1 + origin.x, y1 + origin.y);
      }
      Point2.rotateEx = rotateEx;
    })(Point || (Point = {}));
  }
});

// node_modules/@antv/x6-geometry/es/line.js
var Line;
var init_line = __esm({
  "node_modules/@antv/x6-geometry/es/line.js"() {
    init_point();
    init_geometry();
    init_rectangle();
    Line = class _Line extends Geometry {
      get center() {
        return new Point((this.start.x + this.end.x) / 2, (this.start.y + this.end.y) / 2);
      }
      constructor(x1, y1, x2, y2) {
        super();
        if (typeof x1 === "number" && typeof y1 === "number") {
          this.start = new Point(x1, y1);
          this.end = new Point(x2, y2);
        } else {
          this.start = Point.create(x1);
          this.end = Point.create(y1);
        }
      }
      getCenter() {
        return this.center;
      }
      /**
       * Rounds the line to the given `precision`.
       */
      round(precision = 0) {
        this.start.round(precision);
        this.end.round(precision);
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.start.translate(tx, ty);
          this.end.translate(tx, ty);
        } else {
          this.start.translate(tx);
          this.end.translate(tx);
        }
        return this;
      }
      /**
       * Rotate the line by `angle` around `origin`.
       */
      rotate(angle, origin) {
        this.start.rotate(angle, origin);
        this.end.rotate(angle, origin);
        return this;
      }
      /**
       * Scale the line by `sx` and `sy` about the given `origin`. If origin is not
       * specified, the line is scaled around `0,0`.
       */
      scale(sx, sy, origin) {
        this.start.scale(sx, sy, origin);
        this.end.scale(sx, sy, origin);
        return this;
      }
      /**
       * Returns the length of the line.
       */
      length() {
        return Math.sqrt(this.squaredLength());
      }
      /**
       * Useful for distance comparisons in which real length is not necessary
       * (saves one `Math.sqrt()` operation).
       */
      squaredLength() {
        const dx = this.start.x - this.end.x;
        const dy = this.start.y - this.end.y;
        return dx * dx + dy * dy;
      }
      /**
       * Scale the line so that it has the requested length. The start point of
       * the line is preserved.
       */
      setLength(length) {
        const total = this.length();
        if (!total) {
          return this;
        }
        const scale2 = length / total;
        return this.scale(scale2, scale2, this.start);
      }
      parallel(distance) {
        const line = this.clone();
        if (!line.isDifferentiable()) {
          return line;
        }
        const { start, end } = line;
        const eRef = start.clone().rotate(270, end);
        const sRef = end.clone().rotate(90, start);
        start.move(sRef, distance);
        end.move(eRef, distance);
        return line;
      }
      /**
       * Returns the vector of the line with length equal to length of the line.
       */
      vector() {
        return new Point(this.end.x - this.start.x, this.end.y - this.start.y);
      }
      /**
       * Returns the angle of incline of the line.
       *
       * The function returns `NaN` if the start and end endpoints of the line
       * both lie at the same coordinates(it is impossible to determine the angle
       * of incline of a line that appears to be a point). The
       * `line.isDifferentiable()` function may be used in advance to determine
       * whether the angle of incline can be computed for a given line.
       */
      angle() {
        const ref = new Point(this.start.x + 1, this.start.y);
        return this.start.angleBetween(this.end, ref);
      }
      /**
       * Returns a rectangle that is the bounding box of the line.
       */
      bbox() {
        const left = Math.min(this.start.x, this.end.x);
        const top = Math.min(this.start.y, this.end.y);
        const right = Math.max(this.start.x, this.end.x);
        const bottom = Math.max(this.start.y, this.end.y);
        return new Rectangle(left, top, right - left, bottom - top);
      }
      /**
       * Returns the bearing (cardinal direction) of the line.
       *
       * The return value is one of the following strings:
       * 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW' and 'N'.
       *
       * The function returns 'N' if the two endpoints of the line are coincident.
       */
      bearing() {
        return this.start.bearing(this.end);
      }
      /**
       * Returns the point on the line that lies closest to point `p`.
       */
      closestPoint(p) {
        return this.pointAt(this.closestPointNormalizedLength(p));
      }
      /**
       * Returns the length of the line up to the point that lies closest to point `p`.
       */
      closestPointLength(p) {
        return this.closestPointNormalizedLength(p) * this.length();
      }
      /**
       * Returns a line that is tangent to the line at the point that lies closest
       * to point `p`.
       */
      closestPointTangent(p) {
        return this.tangentAt(this.closestPointNormalizedLength(p));
      }
      /**
       * Returns the normalized length (distance from the start of the line / total
       * line length) of the line up to the point that lies closest to point.
       */
      closestPointNormalizedLength(p) {
        const product = this.vector().dot(new _Line(this.start, p).vector());
        const normalized = Math.min(1, Math.max(0, product / this.squaredLength()));
        if (Number.isNaN(normalized)) {
          return 0;
        }
        return normalized;
      }
      /**
       * Returns a point on the line that lies `rate` (normalized length) away from
       * the beginning of the line.
       */
      pointAt(ratio) {
        const start = this.start;
        const end = this.end;
        if (ratio <= 0) {
          return start.clone();
        }
        if (ratio >= 1) {
          return end.clone();
        }
        return start.lerp(end, ratio);
      }
      /**
       * Returns a point on the line that lies length away from the beginning of
       * the line.
       */
      pointAtLength(length) {
        const start = this.start;
        const end = this.end;
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const total = this.length();
        if (length >= total) {
          return fromStart ? end.clone() : start.clone();
        }
        const rate = (fromStart ? length : total - length) / total;
        return this.pointAt(rate);
      }
      /**
       * Divides the line into two lines at the point that lies `rate` (normalized
       * length) away from the beginning of the line.
       */
      divideAt(ratio) {
        const dividerPoint = this.pointAt(ratio);
        return [
          new _Line(this.start, dividerPoint),
          new _Line(dividerPoint, this.end)
        ];
      }
      /**
       * Divides the line into two lines at the point that lies length away from
       * the beginning of the line.
       */
      divideAtLength(length) {
        const dividerPoint = this.pointAtLength(length);
        return [
          new _Line(this.start, dividerPoint),
          new _Line(dividerPoint, this.end)
        ];
      }
      /**
       * Returns `true` if the point `p` lies on the line. Return `false` otherwise.
       */
      containsPoint(p) {
        const start = this.start;
        const end = this.end;
        if (start.cross(p, end) !== 0) {
          return false;
        }
        const length = this.length();
        if (new _Line(start, p).length() > length) {
          return false;
        }
        if (new _Line(p, end).length() > length) {
          return false;
        }
        return true;
      }
      intersect(shape, options) {
        const ret = shape.intersectsWithLine(this, options);
        if (ret) {
          return Array.isArray(ret) ? ret : [ret];
        }
        return null;
      }
      /**
       * Returns the intersection point of the line with another line. Returns
       * `null` if no intersection exists.
       */
      intersectsWithLine(line) {
        const pt1Dir = new Point(this.end.x - this.start.x, this.end.y - this.start.y);
        const pt2Dir = new Point(line.end.x - line.start.x, line.end.y - line.start.y);
        const det = pt1Dir.x * pt2Dir.y - pt1Dir.y * pt2Dir.x;
        const deltaPt = new Point(line.start.x - this.start.x, line.start.y - this.start.y);
        const alpha = deltaPt.x * pt2Dir.y - deltaPt.y * pt2Dir.x;
        const beta = deltaPt.x * pt1Dir.y - deltaPt.y * pt1Dir.x;
        if (det === 0 || alpha * det < 0 || beta * det < 0) {
          return null;
        }
        if (det > 0) {
          if (alpha > det || beta > det) {
            return null;
          }
        } else if (alpha < det || beta < det) {
          return null;
        }
        return new Point(this.start.x + alpha * pt1Dir.x / det, this.start.y + alpha * pt1Dir.y / det);
      }
      /**
       * Returns `true` if a tangent line can be found for the line.
       *
       * Tangents cannot be found if both of the line endpoints are coincident
       * (the line appears to be a point).
       */
      isDifferentiable() {
        return !this.start.equals(this.end);
      }
      /**
       * Returns the perpendicular distance between the line and point. The
       * distance is positive if the point lies to the right of the line, negative
       * if the point lies to the left of the line, and `0` if the point lies on
       * the line.
       */
      pointOffset(p) {
        const ref = Point.clone(p);
        const start = this.start;
        const end = this.end;
        const determinant = (end.x - start.x) * (ref.y - start.y) - (end.y - start.y) * (ref.x - start.x);
        return determinant / this.length();
      }
      pointSquaredDistance(x, y) {
        const p = Point.create(x, y);
        return this.closestPoint(p).squaredDistance(p);
      }
      pointDistance(x, y) {
        const p = Point.create(x, y);
        return this.closestPoint(p).distance(p);
      }
      /**
       * Returns a line tangent to the line at point that lies `rate` (normalized
       * length) away from the beginning of the line.
       */
      tangentAt(ratio) {
        if (!this.isDifferentiable()) {
          return null;
        }
        const start = this.start;
        const end = this.end;
        const tangentStart = this.pointAt(ratio);
        const tangentLine = new _Line(start, end);
        tangentLine.translate(tangentStart.x - start.x, tangentStart.y - start.y);
        return tangentLine;
      }
      /**
       * Returns a line tangent to the line at point that lies `length` away from
       * the beginning of the line.
       */
      tangentAtLength(length) {
        if (!this.isDifferentiable()) {
          return null;
        }
        const start = this.start;
        const end = this.end;
        const tangentStart = this.pointAtLength(length);
        const tangentLine = new _Line(start, end);
        tangentLine.translate(tangentStart.x - start.x, tangentStart.y - start.y);
        return tangentLine;
      }
      relativeCcw(x, y) {
        const ref = Point.create(x, y);
        let dx1 = ref.x - this.start.x;
        let dy1 = ref.y - this.start.y;
        const dx2 = this.end.x - this.start.x;
        const dy2 = this.end.y - this.start.y;
        let ccw = dx1 * dy2 - dy1 * dx2;
        if (ccw === 0) {
          ccw = dx1 * dx2 + dy1 * dy2;
          if (ccw > 0) {
            dx1 -= dx2;
            dy1 -= dy2;
            ccw = dx1 * dx2 + dy1 * dy2;
            if (ccw < 0) {
              ccw = 0;
            }
          }
        }
        return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
      }
      /**
       * Return `true` if the line equals the other line.
       */
      equals(l) {
        return l != null && this.start.x === l.start.x && this.start.y === l.start.y && this.end.x === l.end.x && this.end.y === l.end.y;
      }
      /**
       * Returns another line which is a clone of the line.
       */
      clone() {
        return new _Line(this.start, this.end);
      }
      toJSON() {
        return { start: this.start.toJSON(), end: this.end.toJSON() };
      }
      serialize() {
        return [this.start.serialize(), this.end.serialize()].join(" ");
      }
    };
    (function(Line2) {
      function isLine(instance) {
        return instance != null && instance instanceof Line2;
      }
      Line2.isLine = isLine;
    })(Line || (Line = {}));
  }
});

// node_modules/@antv/x6-geometry/es/rectangle.js
var Rectangle;
var init_rectangle = __esm({
  "node_modules/@antv/x6-geometry/es/rectangle.js"() {
    init_util4();
    init_angle();
    init_line();
    init_point();
    init_geometry();
    Rectangle = class _Rectangle extends Geometry {
      get left() {
        return this.x;
      }
      get top() {
        return this.y;
      }
      get right() {
        return this.x + this.width;
      }
      get bottom() {
        return this.y + this.height;
      }
      get origin() {
        return new Point(this.x, this.y);
      }
      get topLeft() {
        return new Point(this.x, this.y);
      }
      get topCenter() {
        return new Point(this.x + this.width / 2, this.y);
      }
      get topRight() {
        return new Point(this.x + this.width, this.y);
      }
      get center() {
        return new Point(this.x + this.width / 2, this.y + this.height / 2);
      }
      get bottomLeft() {
        return new Point(this.x, this.y + this.height);
      }
      get bottomCenter() {
        return new Point(this.x + this.width / 2, this.y + this.height);
      }
      get bottomRight() {
        return new Point(this.x + this.width, this.y + this.height);
      }
      get corner() {
        return new Point(this.x + this.width, this.y + this.height);
      }
      get rightMiddle() {
        return new Point(this.x + this.width, this.y + this.height / 2);
      }
      get leftMiddle() {
        return new Point(this.x, this.y + this.height / 2);
      }
      get topLine() {
        return new Line(this.topLeft, this.topRight);
      }
      get rightLine() {
        return new Line(this.topRight, this.bottomRight);
      }
      get bottomLine() {
        return new Line(this.bottomLeft, this.bottomRight);
      }
      get leftLine() {
        return new Line(this.topLeft, this.bottomLeft);
      }
      constructor(x, y, width2, height2) {
        super();
        this.x = x == null ? 0 : x;
        this.y = y == null ? 0 : y;
        this.width = width2 == null ? 0 : width2;
        this.height = height2 == null ? 0 : height2;
      }
      getOrigin() {
        return this.origin;
      }
      getTopLeft() {
        return this.topLeft;
      }
      getTopCenter() {
        return this.topCenter;
      }
      getTopRight() {
        return this.topRight;
      }
      getCenter() {
        return this.center;
      }
      getCenterX() {
        return this.x + this.width / 2;
      }
      getCenterY() {
        return this.y + this.height / 2;
      }
      getBottomLeft() {
        return this.bottomLeft;
      }
      getBottomCenter() {
        return this.bottomCenter;
      }
      getBottomRight() {
        return this.bottomRight;
      }
      getCorner() {
        return this.corner;
      }
      getRightMiddle() {
        return this.rightMiddle;
      }
      getLeftMiddle() {
        return this.leftMiddle;
      }
      getTopLine() {
        return this.topLine;
      }
      getRightLine() {
        return this.rightLine;
      }
      getBottomLine() {
        return this.bottomLine;
      }
      getLeftLine() {
        return this.leftLine;
      }
      /**
       * Returns a rectangle that is the bounding box of the rectangle.
       *
       * If `angle` is specified, the bounding box calculation will take into
       * account the rotation of the rectangle by angle degrees around its center.
       */
      bbox(angle) {
        if (!angle) {
          return this.clone();
        }
        const rad = Angle.toRad(angle);
        const st = Math.abs(Math.sin(rad));
        const ct = Math.abs(Math.cos(rad));
        const w = this.width * ct + this.height * st;
        const h = this.width * st + this.height * ct;
        return new _Rectangle(this.x + (this.width - w) / 2, this.y + (this.height - h) / 2, w, h);
      }
      round(precision = 0) {
        this.x = GeometryUtil.round(this.x, precision);
        this.y = GeometryUtil.round(this.y, precision);
        this.width = GeometryUtil.round(this.width, precision);
        this.height = GeometryUtil.round(this.height, precision);
        return this;
      }
      add(x, y, width2, height2) {
        const rect = _Rectangle.create(x, y, width2, height2);
        const minX = Math.min(this.x, rect.x);
        const minY = Math.min(this.y, rect.y);
        const maxX = Math.max(this.x + this.width, rect.x + rect.width);
        const maxY = Math.max(this.y + this.height, rect.y + rect.height);
        this.x = minX;
        this.y = minY;
        this.width = maxX - minX;
        this.height = maxY - minY;
        return this;
      }
      update(x, y, width2, height2) {
        const rect = _Rectangle.create(x, y, width2, height2);
        this.x = rect.x;
        this.y = rect.y;
        this.width = rect.width;
        this.height = rect.height;
        return this;
      }
      inflate(dx, dy) {
        const w = dx;
        const h = dy != null ? dy : dx;
        this.x -= w;
        this.y -= h;
        this.width += 2 * w;
        this.height += 2 * h;
        return this;
      }
      snapToGrid(gx, gy) {
        const origin = this.origin.snapToGrid(gx, gy);
        const corner = this.corner.snapToGrid(gx, gy);
        this.x = origin.x;
        this.y = origin.y;
        this.width = corner.x - origin.x;
        this.height = corner.y - origin.y;
        return this;
      }
      translate(tx, ty) {
        const p = Point.create(tx, ty);
        this.x += p.x;
        this.y += p.y;
        return this;
      }
      scale(sx, sy, origin = new Point()) {
        const pos = this.origin.scale(sx, sy, origin);
        this.x = pos.x;
        this.y = pos.y;
        this.width *= sx;
        this.height *= sy;
        return this;
      }
      rotate(degree, center = this.getCenter()) {
        if (degree !== 0) {
          const rad = Angle.toRad(degree);
          const cos = Math.cos(rad);
          const sin = Math.sin(rad);
          let p1 = this.getOrigin();
          let p2 = this.getTopRight();
          let p3 = this.getBottomRight();
          let p4 = this.getBottomLeft();
          p1 = Point.rotateEx(p1, cos, sin, center);
          p2 = Point.rotateEx(p2, cos, sin, center);
          p3 = Point.rotateEx(p3, cos, sin, center);
          p4 = Point.rotateEx(p4, cos, sin, center);
          const rect = new _Rectangle(p1.x, p1.y, 0, 0);
          rect.add(p2.x, p2.y, 0, 0);
          rect.add(p3.x, p3.y, 0, 0);
          rect.add(p4.x, p4.y, 0, 0);
          this.update(rect);
        }
        return this;
      }
      rotate90() {
        const t = (this.width - this.height) / 2;
        this.x += t;
        this.y -= t;
        const tmp = this.width;
        this.width = this.height;
        this.height = tmp;
        return this;
      }
      /**
       * Translates the rectangle by `rect.x` and `rect.y` and expand it by
       * `rect.width` and `rect.height`.
       */
      moveAndExpand(rect) {
        const ref = _Rectangle.clone(rect);
        this.x += ref.x || 0;
        this.y += ref.y || 0;
        this.width += ref.width || 0;
        this.height += ref.height || 0;
        return this;
      }
      /**
       * Returns an object where `sx` and `sy` give the maximum scaling that can be
       * applied to the rectangle so that it would still fit into `limit`. If
       * `origin` is specified, the rectangle is scaled around it; otherwise, it is
       * scaled around its center.
       */
      getMaxScaleToFit(limit, origin = this.center) {
        const rect = _Rectangle.clone(limit);
        const ox = origin.x;
        const oy = origin.y;
        let sx1 = Infinity;
        let sx2 = Infinity;
        let sx3 = Infinity;
        let sx4 = Infinity;
        let sy1 = Infinity;
        let sy2 = Infinity;
        let sy3 = Infinity;
        let sy4 = Infinity;
        const p1 = rect.topLeft;
        if (p1.x < ox) {
          sx1 = (this.x - ox) / (p1.x - ox);
        }
        if (p1.y < oy) {
          sy1 = (this.y - oy) / (p1.y - oy);
        }
        const p2 = rect.bottomRight;
        if (p2.x > ox) {
          sx2 = (this.x + this.width - ox) / (p2.x - ox);
        }
        if (p2.y > oy) {
          sy2 = (this.y + this.height - oy) / (p2.y - oy);
        }
        const p3 = rect.topRight;
        if (p3.x > ox) {
          sx3 = (this.x + this.width - ox) / (p3.x - ox);
        }
        if (p3.y < oy) {
          sy3 = (this.y - oy) / (p3.y - oy);
        }
        const p4 = rect.bottomLeft;
        if (p4.x < ox) {
          sx4 = (this.x - ox) / (p4.x - ox);
        }
        if (p4.y > oy) {
          sy4 = (this.y + this.height - oy) / (p4.y - oy);
        }
        return {
          sx: Math.min(sx1, sx2, sx3, sx4),
          sy: Math.min(sy1, sy2, sy3, sy4)
        };
      }
      /**
       * Returns a number that specifies the maximum scaling that can be applied to
       * the rectangle along both axes so that it would still fit into `limit`. If
       * `origin` is specified, the rectangle is scaled around it; otherwise, it is
       * scaled around its center.
       */
      getMaxUniformScaleToFit(limit, origin = this.center) {
        const scale2 = this.getMaxScaleToFit(limit, origin);
        return Math.min(scale2.sx, scale2.sy);
      }
      containsPoint(x, y) {
        return GeometryUtil.containsPoint(this, Point.create(x, y));
      }
      containsRect(x, y, width2, height2) {
        const b = _Rectangle.create(x, y, width2, height2);
        const x1 = this.x;
        const y1 = this.y;
        const w1 = this.width;
        const h1 = this.height;
        const x2 = b.x;
        const y2 = b.y;
        const w2 = b.width;
        const h2 = b.height;
        if (w1 === 0 || h1 === 0 || w2 === 0 || h2 === 0) {
          return false;
        }
        return x2 >= x1 && y2 >= y1 && x2 + w2 <= x1 + w1 && y2 + h2 <= y1 + h1;
      }
      /**
       * Returns an array of the intersection points of the rectangle and the line.
       * Return `null` if no intersection exists.
       */
      intersectsWithLine(line) {
        const rectLines = [
          this.topLine,
          this.rightLine,
          this.bottomLine,
          this.leftLine
        ];
        const points = [];
        const dedupeArr = [];
        rectLines.forEach((l) => {
          const p = line.intersectsWithLine(l);
          if (p !== null && dedupeArr.indexOf(p.toString()) < 0) {
            points.push(p);
            dedupeArr.push(p.toString());
          }
        });
        return points.length > 0 ? points : null;
      }
      /**
       * Returns the point on the boundary of the rectangle that is the intersection
       * of the rectangle with a line starting in the center the rectangle ending in
       * the point `p`.
       *
       * If `angle` is specified, the intersection will take into account the
       * rotation of the rectangle by `angle` degrees around its center.
       */
      intersectsWithLineFromCenterToPoint(p, angle) {
        const ref = Point.clone(p);
        const center = this.center;
        let result = null;
        if (angle != null && angle !== 0) {
          ref.rotate(angle, center);
        }
        const sides = [this.topLine, this.rightLine, this.bottomLine, this.leftLine];
        const connector = new Line(center, ref);
        for (let i = sides.length - 1; i >= 0; i -= 1) {
          const intersection = sides[i].intersectsWithLine(connector);
          if (intersection !== null) {
            result = intersection;
            break;
          }
        }
        if (result && angle != null && angle !== 0) {
          result.rotate(-angle, center);
        }
        return result;
      }
      intersectsWithRect(x, y, width2, height2) {
        const ref = _Rectangle.create(x, y, width2, height2);
        if (!this.isIntersectWithRect(ref)) {
          return null;
        }
        const myOrigin = this.origin;
        const myCorner = this.corner;
        const rOrigin = ref.origin;
        const rCorner = ref.corner;
        const xx = Math.max(myOrigin.x, rOrigin.x);
        const yy = Math.max(myOrigin.y, rOrigin.y);
        return new _Rectangle(xx, yy, Math.min(myCorner.x, rCorner.x) - xx, Math.min(myCorner.y, rCorner.y) - yy);
      }
      isIntersectWithRect(x, y, width2, height2) {
        const ref = _Rectangle.create(x, y, width2, height2);
        const myOrigin = this.origin;
        const myCorner = this.corner;
        const rOrigin = ref.origin;
        const rCorner = ref.corner;
        if (rCorner.x <= myOrigin.x || rCorner.y <= myOrigin.y || rOrigin.x >= myCorner.x || rOrigin.y >= myCorner.y) {
          return false;
        }
        return true;
      }
      /**
       * Normalize the rectangle, i.e. make it so that it has non-negative
       * width and height. If width is less than `0`, the function swaps left and
       * right corners and if height is less than `0`, the top and bottom corners
       * are swapped.
       */
      normalize() {
        let newx = this.x;
        let newy = this.y;
        let newwidth = this.width;
        let newheight = this.height;
        if (this.width < 0) {
          newx = this.x + this.width;
          newwidth = -this.width;
        }
        if (this.height < 0) {
          newy = this.y + this.height;
          newheight = -this.height;
        }
        this.x = newx;
        this.y = newy;
        this.width = newwidth;
        this.height = newheight;
        return this;
      }
      /**
       * Returns a rectangle that is a union of this rectangle and rectangle `rect`.
       */
      union(rect) {
        const ref = _Rectangle.clone(rect);
        const myOrigin = this.origin;
        const myCorner = this.corner;
        const rOrigin = ref.origin;
        const rCorner = ref.corner;
        const originX = Math.min(myOrigin.x, rOrigin.x);
        const originY = Math.min(myOrigin.y, rOrigin.y);
        const cornerX = Math.max(myCorner.x, rCorner.x);
        const cornerY = Math.max(myCorner.y, rCorner.y);
        return new _Rectangle(originX, originY, cornerX - originX, cornerY - originY);
      }
      /**
       * Returns a string ("top", "left", "right" or "bottom") denoting the side of
       * the rectangle which is nearest to the point `p`.
       */
      getNearestSideToPoint(p) {
        const ref = Point.clone(p);
        const distLeft = ref.x - this.x;
        const distRight = this.x + this.width - ref.x;
        const distTop = ref.y - this.y;
        const distBottom = this.y + this.height - ref.y;
        let closest = distLeft;
        let side = "left";
        if (distRight < closest) {
          closest = distRight;
          side = "right";
        }
        if (distTop < closest) {
          closest = distTop;
          side = "top";
        }
        if (distBottom < closest) {
          side = "bottom";
        }
        return side;
      }
      /**
       * Returns a point on the boundary of the rectangle nearest to the point `p`.
       */
      getNearestPointToPoint(p) {
        const ref = Point.clone(p);
        if (this.containsPoint(ref)) {
          const side = this.getNearestSideToPoint(ref);
          if (side === "left") {
            return new Point(this.x, ref.y);
          }
          if (side === "top") {
            return new Point(ref.x, this.y);
          }
          if (side === "right") {
            return new Point(this.x + this.width, ref.y);
          }
          if (side === "bottom") {
            return new Point(ref.x, this.y + this.height);
          }
        }
        return ref.adhereToRect(this);
      }
      equals(rect) {
        return rect != null && rect.x === this.x && rect.y === this.y && rect.width === this.width && rect.height === this.height;
      }
      clone() {
        return new _Rectangle(this.x, this.y, this.width, this.height);
      }
      toJSON() {
        return { x: this.x, y: this.y, width: this.width, height: this.height };
      }
      serialize() {
        return `${this.x} ${this.y} ${this.width} ${this.height}`;
      }
    };
    (function(Rectangle2) {
      function isRectangle(instance) {
        return instance != null && instance instanceof Rectangle2;
      }
      Rectangle2.isRectangle = isRectangle;
    })(Rectangle || (Rectangle = {}));
    (function(Rectangle2) {
      function isRectangleLike(o) {
        return o != null && typeof o === "object" && typeof o.x === "number" && typeof o.y === "number" && typeof o.width === "number" && typeof o.height === "number";
      }
      Rectangle2.isRectangleLike = isRectangleLike;
    })(Rectangle || (Rectangle = {}));
    (function(Rectangle2) {
      function create(x, y, width2, height2) {
        if (x == null || typeof x === "number") {
          return new Rectangle2(x, y, width2, height2);
        }
        return clone(x);
      }
      Rectangle2.create = create;
      function clone(rect) {
        if (Rectangle2.isRectangle(rect)) {
          return rect.clone();
        }
        if (Array.isArray(rect)) {
          return new Rectangle2(rect[0], rect[1], rect[2], rect[3]);
        }
        return new Rectangle2(rect.x, rect.y, rect.width, rect.height);
      }
      Rectangle2.clone = clone;
      function fromEllipse(ellipse) {
        return new Rectangle2(ellipse.x - ellipse.a, ellipse.y - ellipse.b, 2 * ellipse.a, 2 * ellipse.b);
      }
      Rectangle2.fromEllipse = fromEllipse;
      function fromSize(size) {
        return new Rectangle2(0, 0, size.width, size.height);
      }
      Rectangle2.fromSize = fromSize;
      function fromPositionAndSize(pos, size) {
        return new Rectangle2(pos.x, pos.y, size.width, size.height);
      }
      Rectangle2.fromPositionAndSize = fromPositionAndSize;
    })(Rectangle || (Rectangle = {}));
  }
});

// node_modules/@antv/x6-geometry/es/ellipse.js
var Ellipse;
var init_ellipse = __esm({
  "node_modules/@antv/x6-geometry/es/ellipse.js"() {
    init_point();
    init_rectangle();
    init_geometry();
    Ellipse = class _Ellipse extends Geometry {
      get center() {
        return new Point(this.x, this.y);
      }
      constructor(x, y, a, b) {
        super();
        this.x = x == null ? 0 : x;
        this.y = y == null ? 0 : y;
        this.a = a == null ? 0 : a;
        this.b = b == null ? 0 : b;
      }
      /**
       * Returns a rectangle that is the bounding box of the ellipse.
       */
      bbox() {
        return Rectangle.fromEllipse(this);
      }
      /**
       * Returns a point that is the center of the ellipse.
       */
      getCenter() {
        return this.center;
      }
      inflate(dx, dy) {
        const w = dx;
        const h = dy != null ? dy : dx;
        this.a += 2 * w;
        this.b += 2 * h;
        return this;
      }
      normalizedDistance(x, y) {
        const ref = Point.create(x, y);
        const dx = ref.x - this.x;
        const dy = ref.y - this.y;
        const a = this.a;
        const b = this.b;
        return dx * dx / (a * a) + dy * dy / (b * b);
      }
      containsPoint(x, y) {
        return this.normalizedDistance(x, y) <= 1;
      }
      /**
       * Returns an array of the intersection points of the ellipse and the line.
       * Returns `null` if no intersection exists.
       */
      intersectsWithLine(line) {
        const intersections = [];
        const rx = this.a;
        const ry = this.b;
        const a1 = line.start;
        const a2 = line.end;
        const dir = line.vector();
        const diff = a1.diff(new Point(this.x, this.y));
        const mDir = new Point(dir.x / (rx * rx), dir.y / (ry * ry));
        const mDiff = new Point(diff.x / (rx * rx), diff.y / (ry * ry));
        const a = dir.dot(mDir);
        const b = dir.dot(mDiff);
        const c = diff.dot(mDiff) - 1;
        const d = b * b - a * c;
        if (d < 0) {
          return null;
        }
        if (d > 0) {
          const root = Math.sqrt(d);
          const ta = (-b - root) / a;
          const tb = (-b + root) / a;
          if ((ta < 0 || ta > 1) && (tb < 0 || tb > 1)) {
            return null;
          }
          if (ta >= 0 && ta <= 1) {
            intersections.push(a1.lerp(a2, ta));
          }
          if (tb >= 0 && tb <= 1) {
            intersections.push(a1.lerp(a2, tb));
          }
        } else {
          const t = -b / a;
          if (t >= 0 && t <= 1) {
            intersections.push(a1.lerp(a2, t));
          } else {
            return null;
          }
        }
        return intersections;
      }
      /**
       * Returns the point on the boundary of the ellipse that is the
       * intersection of the ellipse with a line starting in the center
       * of the ellipse ending in the point `p`.
       *
       * If angle is specified, the intersection will take into account
       * the rotation of the ellipse by angle degrees around its center.
       */
      intersectsWithLineFromCenterToPoint(p, angle = 0) {
        const ref = Point.clone(p);
        if (angle) {
          ref.rotate(angle, this.getCenter());
        }
        const dx = ref.x - this.x;
        const dy = ref.y - this.y;
        let result;
        if (dx === 0) {
          result = this.bbox().getNearestPointToPoint(ref);
          if (angle) {
            return result.rotate(-angle, this.getCenter());
          }
          return result;
        }
        const m = dy / dx;
        const mSquared = m * m;
        const aSquared = this.a * this.a;
        const bSquared = this.b * this.b;
        let x = Math.sqrt(1 / (1 / aSquared + mSquared / bSquared));
        x = dx < 0 ? -x : x;
        const y = m * x;
        result = new Point(this.x + x, this.y + y);
        if (angle) {
          return result.rotate(-angle, this.getCenter());
        }
        return result;
      }
      /**
       * Returns the angle between the x-axis and the tangent from a point. It is
       * valid for points lying on the ellipse boundary only.
       */
      tangentTheta(p) {
        const ref = Point.clone(p);
        const x0 = ref.x;
        const y0 = ref.y;
        const a = this.a;
        const b = this.b;
        const center = this.bbox().center;
        const cx = center.x;
        const cy = center.y;
        const refPointDelta = 30;
        const q1 = x0 > center.x + a / 2;
        const q3 = x0 < center.x - a / 2;
        let x;
        let y;
        if (q1 || q3) {
          y = x0 > center.x ? y0 - refPointDelta : y0 + refPointDelta;
          x = a * a / (x0 - cx) - a * a * (y0 - cy) * (y - cy) / (b * b * (x0 - cx)) + cx;
        } else {
          x = y0 > center.y ? x0 + refPointDelta : x0 - refPointDelta;
          y = b * b / (y0 - cy) - b * b * (x0 - cx) * (x - cx) / (a * a * (y0 - cy)) + cy;
        }
        return new Point(x, y).theta(ref);
      }
      scale(sx, sy) {
        this.a *= sx;
        this.b *= sy;
        return this;
      }
      rotate(angle, origin) {
        const rect = Rectangle.fromEllipse(this);
        rect.rotate(angle, origin);
        const ellipse = _Ellipse.fromRect(rect);
        this.a = ellipse.a;
        this.b = ellipse.b;
        this.x = ellipse.x;
        this.y = ellipse.y;
        return this;
      }
      translate(dx, dy) {
        const p = Point.create(dx, dy);
        this.x += p.x;
        this.y += p.y;
        return this;
      }
      equals(ellipse) {
        return ellipse != null && ellipse.x === this.x && ellipse.y === this.y && ellipse.a === this.a && ellipse.b === this.b;
      }
      clone() {
        return new _Ellipse(this.x, this.y, this.a, this.b);
      }
      toJSON() {
        return { x: this.x, y: this.y, a: this.a, b: this.b };
      }
      serialize() {
        return `${this.x} ${this.y} ${this.a} ${this.b}`;
      }
    };
    (function(Ellipse2) {
      function isEllipse(instance) {
        return instance != null && instance instanceof Ellipse2;
      }
      Ellipse2.isEllipse = isEllipse;
    })(Ellipse || (Ellipse = {}));
    (function(Ellipse2) {
      function create(x, y, a, b) {
        if (x == null || typeof x === "number") {
          return new Ellipse2(x, y, a, b);
        }
        return parse2(x);
      }
      Ellipse2.create = create;
      function parse2(e) {
        if (Ellipse2.isEllipse(e)) {
          return e.clone();
        }
        if (Array.isArray(e)) {
          return new Ellipse2(e[0], e[1], e[2], e[3]);
        }
        return new Ellipse2(e.x, e.y, e.a, e.b);
      }
      Ellipse2.parse = parse2;
      function fromRect(rect) {
        const center = rect.center;
        return new Ellipse2(center.x, center.y, rect.width / 2, rect.height / 2);
      }
      Ellipse2.fromRect = fromRect;
    })(Ellipse || (Ellipse = {}));
  }
});

// node_modules/@antv/x6-geometry/es/polyline.js
var Polyline;
var init_polyline = __esm({
  "node_modules/@antv/x6-geometry/es/polyline.js"() {
    init_line();
    init_point();
    init_rectangle();
    init_geometry();
    Polyline = class _Polyline extends Geometry {
      get start() {
        return this.points[0] || null;
      }
      get end() {
        return this.points[this.points.length - 1] || null;
      }
      constructor(points) {
        super();
        if (points != null) {
          if (typeof points === "string") {
            return _Polyline.parse(points);
          }
          this.points = points.map((p) => Point.create(p));
        } else {
          this.points = [];
        }
      }
      scale(sx, sy, origin = new Point()) {
        this.points.forEach((p) => p.scale(sx, sy, origin));
        return this;
      }
      rotate(angle, origin) {
        this.points.forEach((p) => p.rotate(angle, origin));
        return this;
      }
      translate(dx, dy) {
        const t = Point.create(dx, dy);
        this.points.forEach((p) => p.translate(t.x, t.y));
        return this;
      }
      round(precision = 0) {
        this.points.forEach((p) => p.round(precision));
        return this;
      }
      bbox() {
        if (this.points.length === 0) {
          return new Rectangle();
        }
        let x1 = Infinity;
        let x2 = -Infinity;
        let y1 = Infinity;
        let y2 = -Infinity;
        const points = this.points;
        for (let i = 0, ii = points.length; i < ii; i += 1) {
          const point = points[i];
          const x = point.x;
          const y = point.y;
          if (x < x1)
            x1 = x;
          if (x > x2)
            x2 = x;
          if (y < y1)
            y1 = y;
          if (y > y2)
            y2 = y;
        }
        return new Rectangle(x1, y1, x2 - x1, y2 - y1);
      }
      closestPoint(p) {
        const cpLength = this.closestPointLength(p);
        return this.pointAtLength(cpLength);
      }
      closestPointLength(p) {
        const points = this.points;
        const count = points.length;
        if (count === 0 || count === 1) {
          return 0;
        }
        let length = 0;
        let cpLength = 0;
        let minSqrDistance = Infinity;
        for (let i = 0, ii = count - 1; i < ii; i += 1) {
          const line = new Line(points[i], points[i + 1]);
          const lineLength = line.length();
          const cpNormalizedLength = line.closestPointNormalizedLength(p);
          const cp = line.pointAt(cpNormalizedLength);
          const sqrDistance = cp.squaredDistance(p);
          if (sqrDistance < minSqrDistance) {
            minSqrDistance = sqrDistance;
            cpLength = length + cpNormalizedLength * lineLength;
          }
          length += lineLength;
        }
        return cpLength;
      }
      closestPointNormalizedLength(p) {
        const length = this.length();
        if (length === 0) {
          return 0;
        }
        const cpLength = this.closestPointLength(p);
        return cpLength / length;
      }
      closestPointTangent(p) {
        const cpLength = this.closestPointLength(p);
        return this.tangentAtLength(cpLength);
      }
      containsPoint(p) {
        if (this.points.length === 0) {
          return false;
        }
        const ref = Point.clone(p);
        const x = ref.x;
        const y = ref.y;
        const points = this.points;
        const count = points.length;
        let startIndex = count - 1;
        let intersectionCount = 0;
        for (let endIndex = 0; endIndex < count; endIndex += 1) {
          const start = points[startIndex];
          const end = points[endIndex];
          if (ref.equals(start)) {
            return true;
          }
          const segment = new Line(start, end);
          if (segment.containsPoint(p)) {
            return true;
          }
          if (y <= start.y && y > end.y || y > start.y && y <= end.y) {
            const xDifference = start.x - x > end.x - x ? start.x - x : end.x - x;
            if (xDifference >= 0) {
              const rayEnd = new Point(x + xDifference, y);
              const ray = new Line(p, rayEnd);
              if (segment.intersectsWithLine(ray)) {
                intersectionCount += 1;
              }
            }
          }
          startIndex = endIndex;
        }
        return intersectionCount % 2 === 1;
      }
      intersectsWithLine(line) {
        const intersections = [];
        for (let i = 0, n = this.points.length - 1; i < n; i += 1) {
          const a = this.points[i];
          const b = this.points[i + 1];
          const int = line.intersectsWithLine(new Line(a, b));
          if (int) {
            intersections.push(int);
          }
        }
        return intersections.length > 0 ? intersections : null;
      }
      isDifferentiable() {
        for (let i = 0, ii = this.points.length - 1; i < ii; i += 1) {
          const a = this.points[i];
          const b = this.points[i + 1];
          const line = new Line(a, b);
          if (line.isDifferentiable()) {
            return true;
          }
        }
        return false;
      }
      length() {
        let len = 0;
        for (let i = 0, ii = this.points.length - 1; i < ii; i += 1) {
          const a = this.points[i];
          const b = this.points[i + 1];
          len += a.distance(b);
        }
        return len;
      }
      pointAt(ratio) {
        const points = this.points;
        const count = points.length;
        if (count === 0) {
          return null;
        }
        if (count === 1) {
          return points[0].clone();
        }
        if (ratio <= 0) {
          return points[0].clone();
        }
        if (ratio >= 1) {
          return points[count - 1].clone();
        }
        const total = this.length();
        const length = total * ratio;
        return this.pointAtLength(length);
      }
      pointAtLength(length) {
        const points = this.points;
        const count = points.length;
        if (count === 0) {
          return null;
        }
        if (count === 1) {
          return points[0].clone();
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        let tmp = 0;
        for (let i = 0, ii = count - 1; i < ii; i += 1) {
          const index2 = fromStart ? i : ii - 1 - i;
          const a = points[index2];
          const b = points[index2 + 1];
          const l = new Line(a, b);
          const d = a.distance(b);
          if (length <= tmp + d) {
            return l.pointAtLength((fromStart ? 1 : -1) * (length - tmp));
          }
          tmp += d;
        }
        const lastPoint = fromStart ? points[count - 1] : points[0];
        return lastPoint.clone();
      }
      tangentAt(ratio) {
        const points = this.points;
        const count = points.length;
        if (count === 0 || count === 1) {
          return null;
        }
        if (ratio < 0) {
          ratio = 0;
        }
        if (ratio > 1) {
          ratio = 1;
        }
        const total = this.length();
        const length = total * ratio;
        return this.tangentAtLength(length);
      }
      tangentAtLength(length) {
        const points = this.points;
        const count = points.length;
        if (count === 0 || count === 1) {
          return null;
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        let lastValidLine;
        let tmp = 0;
        for (let i = 0, ii = count - 1; i < ii; i += 1) {
          const index2 = fromStart ? i : ii - 1 - i;
          const a = points[index2];
          const b = points[index2 + 1];
          const l = new Line(a, b);
          const d = a.distance(b);
          if (l.isDifferentiable()) {
            if (length <= tmp + d) {
              return l.tangentAtLength((fromStart ? 1 : -1) * (length - tmp));
            }
            lastValidLine = l;
          }
          tmp += d;
        }
        if (lastValidLine) {
          const ratio = fromStart ? 1 : 0;
          return lastValidLine.tangentAt(ratio);
        }
        return null;
      }
      simplify(options = {}) {
        const points = this.points;
        if (points.length < 3) {
          return this;
        }
        const threshold = options.threshold || 0;
        let currentIndex = 0;
        while (points[currentIndex + 2]) {
          const firstIndex = currentIndex;
          const middleIndex = currentIndex + 1;
          const lastIndex = currentIndex + 2;
          const firstPoint = points[firstIndex];
          const middlePoint = points[middleIndex];
          const lastPoint = points[lastIndex];
          const chord = new Line(firstPoint, lastPoint);
          const closestPoint = chord.closestPoint(middlePoint);
          const closestPointDistance = closestPoint.distance(middlePoint);
          if (closestPointDistance <= threshold) {
            points.splice(middleIndex, 1);
          } else {
            currentIndex += 1;
          }
        }
        return this;
      }
      toHull() {
        const points = this.points;
        const count = points.length;
        if (count === 0) {
          return new _Polyline();
        }
        let startPoint = points[0];
        for (let i = 1; i < count; i += 1) {
          if (points[i].y < startPoint.y) {
            startPoint = points[i];
          } else if (points[i].y === startPoint.y && points[i].x > startPoint.x) {
            startPoint = points[i];
          }
        }
        const sortedRecords = [];
        for (let i = 0; i < count; i += 1) {
          let angle = startPoint.theta(points[i]);
          if (angle === 0) {
            angle = 360;
          }
          sortedRecords.push([points[i], i, angle]);
        }
        sortedRecords.sort((record1, record2) => {
          let ret = record1[2] - record2[2];
          if (ret === 0) {
            ret = record2[1] - record1[1];
          }
          return ret;
        });
        if (sortedRecords.length > 2) {
          const startPoint2 = sortedRecords[sortedRecords.length - 1];
          sortedRecords.unshift(startPoint2);
        }
        const insidePoints = {};
        const hullRecords = [];
        const getKey = (record) => `${record[0].toString()}@${record[1]}`;
        while (sortedRecords.length !== 0) {
          const currentRecord = sortedRecords.pop();
          const currentPoint = currentRecord[0];
          if (insidePoints[getKey(currentRecord)]) {
            continue;
          }
          let correctTurnFound = false;
          while (!correctTurnFound) {
            if (hullRecords.length < 2) {
              hullRecords.push(currentRecord);
              correctTurnFound = true;
            } else {
              const lastHullRecord = hullRecords.pop();
              const lastHullPoint = lastHullRecord[0];
              const secondLastHullRecord = hullRecords.pop();
              const secondLastHullPoint = secondLastHullRecord[0];
              const crossProduct = secondLastHullPoint.cross(lastHullPoint, currentPoint);
              if (crossProduct < 0) {
                hullRecords.push(secondLastHullRecord);
                hullRecords.push(lastHullRecord);
                hullRecords.push(currentRecord);
                correctTurnFound = true;
              } else if (crossProduct === 0) {
                const THRESHOLD = 1e-10;
                const angleBetween = lastHullPoint.angleBetween(secondLastHullPoint, currentPoint);
                if (Math.abs(angleBetween - 180) < THRESHOLD) {
                  insidePoints[getKey(lastHullRecord)] = lastHullPoint;
                  hullRecords.push(secondLastHullRecord);
                } else if (lastHullPoint.equals(currentPoint) || secondLastHullPoint.equals(lastHullPoint)) {
                  insidePoints[getKey(lastHullRecord)] = lastHullPoint;
                  hullRecords.push(secondLastHullRecord);
                } else if (Math.abs((angleBetween + 1) % 360 - 1) < THRESHOLD) {
                  hullRecords.push(secondLastHullRecord);
                  sortedRecords.push(lastHullRecord);
                }
              } else {
                insidePoints[getKey(lastHullRecord)] = lastHullPoint;
                hullRecords.push(secondLastHullRecord);
              }
            }
          }
        }
        if (hullRecords.length > 2) {
          hullRecords.pop();
        }
        let lowestHullIndex;
        let indexOfLowestHullIndexRecord = -1;
        for (let i = 0, n = hullRecords.length; i < n; i += 1) {
          const currentHullIndex = hullRecords[i][1];
          if (lowestHullIndex === void 0 || currentHullIndex < lowestHullIndex) {
            lowestHullIndex = currentHullIndex;
            indexOfLowestHullIndexRecord = i;
          }
        }
        let hullPointRecordsReordered = [];
        if (indexOfLowestHullIndexRecord > 0) {
          const newFirstChunk = hullRecords.slice(indexOfLowestHullIndexRecord);
          const newSecondChunk = hullRecords.slice(0, indexOfLowestHullIndexRecord);
          hullPointRecordsReordered = newFirstChunk.concat(newSecondChunk);
        } else {
          hullPointRecordsReordered = hullRecords;
        }
        const hullPoints = [];
        for (let i = 0, n = hullPointRecordsReordered.length; i < n; i += 1) {
          hullPoints.push(hullPointRecordsReordered[i][0]);
        }
        return new _Polyline(hullPoints);
      }
      equals(p) {
        if (p == null) {
          return false;
        }
        if (p.points.length !== this.points.length) {
          return false;
        }
        return p.points.every((a, i) => a.equals(this.points[i]));
      }
      clone() {
        return new _Polyline(this.points.map((p) => p.clone()));
      }
      toJSON() {
        return this.points.map((p) => p.toJSON());
      }
      serialize() {
        return this.points.map((p) => `${p.serialize()}`).join(" ");
      }
    };
    (function(Polyline2) {
      function isPolyline(instance) {
        return instance != null && instance instanceof Polyline2;
      }
      Polyline2.isPolyline = isPolyline;
    })(Polyline || (Polyline = {}));
    (function(Polyline2) {
      function parse2(svgString) {
        const str = svgString.trim();
        if (str === "") {
          return new Polyline2();
        }
        const points = [];
        const coords = str.split(/\s*,\s*|\s+/);
        for (let i = 0, ii = coords.length; i < ii; i += 2) {
          points.push({ x: +coords[i], y: +coords[i + 1] });
        }
        return new Polyline2(points);
      }
      Polyline2.parse = parse2;
    })(Polyline || (Polyline = {}));
  }
});

// node_modules/@antv/x6-geometry/es/curve.js
var Curve;
var init_curve = __esm({
  "node_modules/@antv/x6-geometry/es/curve.js"() {
    init_line();
    init_point();
    init_polyline();
    init_rectangle();
    init_geometry();
    Curve = class _Curve extends Geometry {
      constructor(start, controlPoint1, controlPoint2, end) {
        super();
        this.PRECISION = 3;
        this.start = Point.create(start);
        this.controlPoint1 = Point.create(controlPoint1);
        this.controlPoint2 = Point.create(controlPoint2);
        this.end = Point.create(end);
      }
      bbox() {
        const start = this.start;
        const controlPoint1 = this.controlPoint1;
        const controlPoint2 = this.controlPoint2;
        const end = this.end;
        const x0 = start.x;
        const y0 = start.y;
        const x1 = controlPoint1.x;
        const y1 = controlPoint1.y;
        const x2 = controlPoint2.x;
        const y2 = controlPoint2.y;
        const x3 = end.x;
        const y3 = end.y;
        const points = [];
        const tvalues = [];
        const bounds = [[], []];
        let a;
        let b;
        let c;
        let t;
        let t1;
        let t2;
        let b2ac;
        let sqrtb2ac;
        for (let i = 0; i < 2; i += 1) {
          if (i === 0) {
            b = 6 * x0 - 12 * x1 + 6 * x2;
            a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
            c = 3 * x1 - 3 * x0;
          } else {
            b = 6 * y0 - 12 * y1 + 6 * y2;
            a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
            c = 3 * y1 - 3 * y0;
          }
          if (Math.abs(a) < 1e-12) {
            if (Math.abs(b) < 1e-12) {
              continue;
            }
            t = -c / b;
            if (t > 0 && t < 1)
              tvalues.push(t);
            continue;
          }
          b2ac = b * b - 4 * c * a;
          sqrtb2ac = Math.sqrt(b2ac);
          if (b2ac < 0)
            continue;
          t1 = (-b + sqrtb2ac) / (2 * a);
          if (t1 > 0 && t1 < 1)
            tvalues.push(t1);
          t2 = (-b - sqrtb2ac) / (2 * a);
          if (t2 > 0 && t2 < 1)
            tvalues.push(t2);
        }
        let x;
        let y;
        let mt;
        let j = tvalues.length;
        const jlen = j;
        while (j) {
          j -= 1;
          t = tvalues[j];
          mt = 1 - t;
          x = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;
          bounds[0][j] = x;
          y = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;
          bounds[1][j] = y;
          points[j] = { X: x, Y: y };
        }
        tvalues[jlen] = 0;
        tvalues[jlen + 1] = 1;
        points[jlen] = { X: x0, Y: y0 };
        points[jlen + 1] = { X: x3, Y: y3 };
        bounds[0][jlen] = x0;
        bounds[1][jlen] = y0;
        bounds[0][jlen + 1] = x3;
        bounds[1][jlen + 1] = y3;
        tvalues.length = jlen + 2;
        bounds[0].length = jlen + 2;
        bounds[1].length = jlen + 2;
        points.length = jlen + 2;
        const left = Math.min.apply(null, bounds[0]);
        const top = Math.min.apply(null, bounds[1]);
        const right = Math.max.apply(null, bounds[0]);
        const bottom = Math.max.apply(null, bounds[1]);
        return new Rectangle(left, top, right - left, bottom - top);
      }
      closestPoint(p, options = {}) {
        return this.pointAtT(this.closestPointT(p, options));
      }
      closestPointLength(p, options = {}) {
        const opts = this.getOptions(options);
        return this.lengthAtT(this.closestPointT(p, opts), opts);
      }
      closestPointNormalizedLength(p, options = {}) {
        const opts = this.getOptions(options);
        const cpLength = this.closestPointLength(p, opts);
        if (!cpLength) {
          return 0;
        }
        const length = this.length(opts);
        if (length === 0) {
          return 0;
        }
        return cpLength / length;
      }
      closestPointT(p, options = {}) {
        const precision = this.getPrecision(options);
        const subdivisions = this.getDivisions(options);
        const precisionRatio = Math.pow(10, -precision);
        let investigatedSubdivision = null;
        let investigatedSubdivisionStartT = 0;
        let investigatedSubdivisionEndT = 0;
        let distFromStart = 0;
        let distFromEnd = 0;
        let chordLength = 0;
        let minSumDist = null;
        const count = subdivisions.length;
        let piece = count > 0 ? 1 / count : 0;
        subdivisions.forEach((division, i) => {
          const startDist = division.start.distance(p);
          const endDist = division.end.distance(p);
          const sumDist = startDist + endDist;
          if (minSumDist == null || sumDist < minSumDist) {
            investigatedSubdivision = division;
            investigatedSubdivisionStartT = i * piece;
            investigatedSubdivisionEndT = (i + 1) * piece;
            distFromStart = startDist;
            distFromEnd = endDist;
            minSumDist = sumDist;
            chordLength = division.endpointDistance();
          }
        });
        while (true) {
          const startPrecisionRatio = distFromStart ? Math.abs(distFromStart - distFromEnd) / distFromStart : 0;
          const endPrecisionRatio = distFromEnd != null ? Math.abs(distFromStart - distFromEnd) / distFromEnd : 0;
          const hasRequiredPrecision = startPrecisionRatio < precisionRatio || endPrecisionRatio < precisionRatio;
          const hasMiniStartDistance = distFromStart ? distFromStart < chordLength * precisionRatio : true;
          const hasMiniEndDistance = distFromEnd ? distFromEnd < chordLength * precisionRatio : true;
          const hasMiniDistance = hasMiniStartDistance || hasMiniEndDistance;
          if (hasRequiredPrecision || hasMiniDistance) {
            return distFromStart <= distFromEnd ? investigatedSubdivisionStartT : investigatedSubdivisionEndT;
          }
          const divided = investigatedSubdivision.divide(0.5);
          piece /= 2;
          const startDist1 = divided[0].start.distance(p);
          const endDist1 = divided[0].end.distance(p);
          const sumDist1 = startDist1 + endDist1;
          const startDist2 = divided[1].start.distance(p);
          const endDist2 = divided[1].end.distance(p);
          const sumDist2 = startDist2 + endDist2;
          if (sumDist1 <= sumDist2) {
            investigatedSubdivision = divided[0];
            investigatedSubdivisionEndT -= piece;
            distFromStart = startDist1;
            distFromEnd = endDist1;
          } else {
            investigatedSubdivision = divided[1];
            investigatedSubdivisionStartT += piece;
            distFromStart = startDist2;
            distFromEnd = endDist2;
          }
        }
      }
      closestPointTangent(p, options = {}) {
        return this.tangentAtT(this.closestPointT(p, options));
      }
      containsPoint(p, options = {}) {
        const polyline = this.toPolyline(options);
        return polyline.containsPoint(p);
      }
      divideAt(ratio, options = {}) {
        if (ratio <= 0) {
          return this.divideAtT(0);
        }
        if (ratio >= 1) {
          return this.divideAtT(1);
        }
        const t = this.tAt(ratio, options);
        return this.divideAtT(t);
      }
      divideAtLength(length, options = {}) {
        const t = this.tAtLength(length, options);
        return this.divideAtT(t);
      }
      divide(t) {
        return this.divideAtT(t);
      }
      divideAtT(t) {
        const start = this.start;
        const controlPoint1 = this.controlPoint1;
        const controlPoint2 = this.controlPoint2;
        const end = this.end;
        if (t <= 0) {
          return [
            new _Curve(start, start, start, start),
            new _Curve(start, controlPoint1, controlPoint2, end)
          ];
        }
        if (t >= 1) {
          return [
            new _Curve(start, controlPoint1, controlPoint2, end),
            new _Curve(end, end, end, end)
          ];
        }
        const dividerPoints = this.getSkeletonPoints(t);
        const startControl1 = dividerPoints.startControlPoint1;
        const startControl2 = dividerPoints.startControlPoint2;
        const divider = dividerPoints.divider;
        const dividerControl1 = dividerPoints.dividerControlPoint1;
        const dividerControl2 = dividerPoints.dividerControlPoint2;
        return [
          new _Curve(start, startControl1, startControl2, divider),
          new _Curve(divider, dividerControl1, dividerControl2, end)
        ];
      }
      endpointDistance() {
        return this.start.distance(this.end);
      }
      getSkeletonPoints(t) {
        const start = this.start;
        const control1 = this.controlPoint1;
        const control2 = this.controlPoint2;
        const end = this.end;
        if (t <= 0) {
          return {
            startControlPoint1: start.clone(),
            startControlPoint2: start.clone(),
            divider: start.clone(),
            dividerControlPoint1: control1.clone(),
            dividerControlPoint2: control2.clone()
          };
        }
        if (t >= 1) {
          return {
            startControlPoint1: control1.clone(),
            startControlPoint2: control2.clone(),
            divider: end.clone(),
            dividerControlPoint1: end.clone(),
            dividerControlPoint2: end.clone()
          };
        }
        const midpoint1 = new Line(start, control1).pointAt(t);
        const midpoint2 = new Line(control1, control2).pointAt(t);
        const midpoint3 = new Line(control2, end).pointAt(t);
        const subControl1 = new Line(midpoint1, midpoint2).pointAt(t);
        const subControl2 = new Line(midpoint2, midpoint3).pointAt(t);
        const divideLine = new Line(subControl1, subControl2).pointAt(t);
        return {
          startControlPoint1: midpoint1,
          startControlPoint2: subControl1,
          divider: divideLine,
          dividerControlPoint1: subControl2,
          dividerControlPoint2: midpoint3
        };
      }
      getSubdivisions(options = {}) {
        const precision = this.getPrecision(options);
        let subdivisions = [
          new _Curve(this.start, this.controlPoint1, this.controlPoint2, this.end)
        ];
        if (precision === 0) {
          return subdivisions;
        }
        let previousLength = this.endpointDistance();
        const precisionRatio = Math.pow(10, -precision);
        let iteration = 0;
        while (true) {
          iteration += 1;
          const divisions = [];
          subdivisions.forEach((c) => {
            const divided = c.divide(0.5);
            divisions.push(divided[0], divided[1]);
          });
          const length = divisions.reduce((memo, c) => memo + c.endpointDistance(), 0);
          const ratio = length !== 0 ? (length - previousLength) / length : 0;
          if (iteration > 1 && ratio < precisionRatio) {
            return divisions;
          }
          subdivisions = divisions;
          previousLength = length;
        }
      }
      length(options = {}) {
        const divisions = this.getDivisions(options);
        return divisions.reduce((memo, c) => {
          return memo + c.endpointDistance();
        }, 0);
      }
      lengthAtT(t, options = {}) {
        if (t <= 0) {
          return 0;
        }
        const precision = options.precision === void 0 ? this.PRECISION : options.precision;
        const subCurve = this.divide(t)[0];
        return subCurve.length({ precision });
      }
      pointAt(ratio, options = {}) {
        if (ratio <= 0) {
          return this.start.clone();
        }
        if (ratio >= 1) {
          return this.end.clone();
        }
        const t = this.tAt(ratio, options);
        return this.pointAtT(t);
      }
      pointAtLength(length, options = {}) {
        const t = this.tAtLength(length, options);
        return this.pointAtT(t);
      }
      pointAtT(t) {
        if (t <= 0) {
          return this.start.clone();
        }
        if (t >= 1) {
          return this.end.clone();
        }
        return this.getSkeletonPoints(t).divider;
      }
      isDifferentiable() {
        const start = this.start;
        const control1 = this.controlPoint1;
        const control2 = this.controlPoint2;
        const end = this.end;
        return !(start.equals(control1) && control1.equals(control2) && control2.equals(end));
      }
      tangentAt(ratio, options = {}) {
        if (!this.isDifferentiable())
          return null;
        if (ratio < 0) {
          ratio = 0;
        } else if (ratio > 1) {
          ratio = 1;
        }
        const t = this.tAt(ratio, options);
        return this.tangentAtT(t);
      }
      tangentAtLength(length, options = {}) {
        if (!this.isDifferentiable()) {
          return null;
        }
        const t = this.tAtLength(length, options);
        return this.tangentAtT(t);
      }
      tangentAtT(t) {
        if (!this.isDifferentiable()) {
          return null;
        }
        if (t < 0) {
          t = 0;
        }
        if (t > 1) {
          t = 1;
        }
        const skeletonPoints = this.getSkeletonPoints(t);
        const p1 = skeletonPoints.startControlPoint2;
        const p2 = skeletonPoints.dividerControlPoint1;
        const tangentStart = skeletonPoints.divider;
        const tangentLine = new Line(p1, p2);
        tangentLine.translate(tangentStart.x - p1.x, tangentStart.y - p1.y);
        return tangentLine;
      }
      getPrecision(options = {}) {
        return options.precision == null ? this.PRECISION : options.precision;
      }
      getDivisions(options = {}) {
        if (options.subdivisions != null) {
          return options.subdivisions;
        }
        const precision = this.getPrecision(options);
        return this.getSubdivisions({ precision });
      }
      getOptions(options = {}) {
        const precision = this.getPrecision(options);
        const subdivisions = this.getDivisions(options);
        return { precision, subdivisions };
      }
      tAt(ratio, options = {}) {
        if (ratio <= 0) {
          return 0;
        }
        if (ratio >= 1) {
          return 1;
        }
        const opts = this.getOptions(options);
        const total = this.length(opts);
        const length = total * ratio;
        return this.tAtLength(length, opts);
      }
      tAtLength(length, options = {}) {
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const precision = this.getPrecision(options);
        const subdivisions = this.getDivisions(options);
        const opts = { precision, subdivisions };
        let investigatedSubdivision = null;
        let investigatedSubdivisionStartT;
        let investigatedSubdivisionEndT;
        let baselinePointDistFromStart = 0;
        let baselinePointDistFromEnd = 0;
        let memo = 0;
        const count = subdivisions.length;
        let piece = count > 0 ? 1 / count : 0;
        for (let i = 0; i < count; i += 1) {
          const index2 = fromStart ? i : count - 1 - i;
          const division = subdivisions[i];
          const dist = division.endpointDistance();
          if (length <= memo + dist) {
            investigatedSubdivision = division;
            investigatedSubdivisionStartT = index2 * piece;
            investigatedSubdivisionEndT = (index2 + 1) * piece;
            baselinePointDistFromStart = fromStart ? length - memo : dist + memo - length;
            baselinePointDistFromEnd = fromStart ? dist + memo - length : length - memo;
            break;
          }
          memo += dist;
        }
        if (investigatedSubdivision == null) {
          return fromStart ? 1 : 0;
        }
        const total = this.length(opts);
        const precisionRatio = Math.pow(10, -precision);
        while (true) {
          let ratio;
          ratio = total !== 0 ? baselinePointDistFromStart / total : 0;
          if (ratio < precisionRatio) {
            return investigatedSubdivisionStartT;
          }
          ratio = total !== 0 ? baselinePointDistFromEnd / total : 0;
          if (ratio < precisionRatio) {
            return investigatedSubdivisionEndT;
          }
          let newBaselinePointDistFromStart;
          let newBaselinePointDistFromEnd;
          const divided = investigatedSubdivision.divide(0.5);
          piece /= 2;
          const baseline1Length = divided[0].endpointDistance();
          const baseline2Length = divided[1].endpointDistance();
          if (baselinePointDistFromStart <= baseline1Length) {
            investigatedSubdivision = divided[0];
            investigatedSubdivisionEndT -= piece;
            newBaselinePointDistFromStart = baselinePointDistFromStart;
            newBaselinePointDistFromEnd = baseline1Length - newBaselinePointDistFromStart;
          } else {
            investigatedSubdivision = divided[1];
            investigatedSubdivisionStartT += piece;
            newBaselinePointDistFromStart = baselinePointDistFromStart - baseline1Length;
            newBaselinePointDistFromEnd = baseline2Length - newBaselinePointDistFromStart;
          }
          baselinePointDistFromStart = newBaselinePointDistFromStart;
          baselinePointDistFromEnd = newBaselinePointDistFromEnd;
        }
      }
      toPoints(options = {}) {
        const subdivisions = this.getDivisions(options);
        const points = [subdivisions[0].start.clone()];
        subdivisions.forEach((c) => points.push(c.end.clone()));
        return points;
      }
      toPolyline(options = {}) {
        return new Polyline(this.toPoints(options));
      }
      scale(sx, sy, origin) {
        this.start.scale(sx, sy, origin);
        this.controlPoint1.scale(sx, sy, origin);
        this.controlPoint2.scale(sx, sy, origin);
        this.end.scale(sx, sy, origin);
        return this;
      }
      rotate(angle, origin) {
        this.start.rotate(angle, origin);
        this.controlPoint1.rotate(angle, origin);
        this.controlPoint2.rotate(angle, origin);
        this.end.rotate(angle, origin);
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.start.translate(tx, ty);
          this.controlPoint1.translate(tx, ty);
          this.controlPoint2.translate(tx, ty);
          this.end.translate(tx, ty);
        } else {
          this.start.translate(tx);
          this.controlPoint1.translate(tx);
          this.controlPoint2.translate(tx);
          this.end.translate(tx);
        }
        return this;
      }
      equals(c) {
        return c != null && this.start.equals(c.start) && this.controlPoint1.equals(c.controlPoint1) && this.controlPoint2.equals(c.controlPoint2) && this.end.equals(c.end);
      }
      clone() {
        return new _Curve(this.start, this.controlPoint1, this.controlPoint2, this.end);
      }
      toJSON() {
        return {
          start: this.start.toJSON(),
          controlPoint1: this.controlPoint1.toJSON(),
          controlPoint2: this.controlPoint2.toJSON(),
          end: this.end.toJSON()
        };
      }
      serialize() {
        return [
          this.start.serialize(),
          this.controlPoint1.serialize(),
          this.controlPoint2.serialize(),
          this.end.serialize()
        ].join(" ");
      }
    };
    (function(Curve2) {
      function isCurve(instance) {
        return instance != null && instance instanceof Curve2;
      }
      Curve2.isCurve = isCurve;
    })(Curve || (Curve = {}));
    (function(Curve2) {
      function getFirstControlPoints(rhs) {
        const n = rhs.length;
        const x = [];
        const tmp = [];
        let b = 2;
        x[0] = rhs[0] / b;
        for (let i = 1; i < n; i += 1) {
          tmp[i] = 1 / b;
          b = (i < n - 1 ? 4 : 3.5) - tmp[i];
          x[i] = (rhs[i] - x[i - 1]) / b;
        }
        for (let i = 1; i < n; i += 1) {
          x[n - i - 1] -= tmp[n - i] * x[n - i];
        }
        return x;
      }
      function getCurveControlPoints(points) {
        const knots = points.map((p) => Point.clone(p));
        const firstControlPoints = [];
        const secondControlPoints = [];
        const n = knots.length - 1;
        if (n === 1) {
          firstControlPoints[0] = new Point((2 * knots[0].x + knots[1].x) / 3, (2 * knots[0].y + knots[1].y) / 3);
          secondControlPoints[0] = new Point(2 * firstControlPoints[0].x - knots[0].x, 2 * firstControlPoints[0].y - knots[0].y);
          return [firstControlPoints, secondControlPoints];
        }
        const rhs = [];
        for (let i = 1; i < n - 1; i += 1) {
          rhs[i] = 4 * knots[i].x + 2 * knots[i + 1].x;
        }
        rhs[0] = knots[0].x + 2 * knots[1].x;
        rhs[n - 1] = (8 * knots[n - 1].x + knots[n].x) / 2;
        const x = getFirstControlPoints(rhs);
        for (let i = 1; i < n - 1; i += 1) {
          rhs[i] = 4 * knots[i].y + 2 * knots[i + 1].y;
        }
        rhs[0] = knots[0].y + 2 * knots[1].y;
        rhs[n - 1] = (8 * knots[n - 1].y + knots[n].y) / 2;
        const y = getFirstControlPoints(rhs);
        for (let i = 0; i < n; i += 1) {
          firstControlPoints.push(new Point(x[i], y[i]));
          if (i < n - 1) {
            secondControlPoints.push(new Point(2 * knots[i + 1].x - x[i + 1], 2 * knots[i + 1].y - y[i + 1]));
          } else {
            secondControlPoints.push(new Point((knots[n].x + x[n - 1]) / 2, (knots[n].y + y[n - 1]) / 2));
          }
        }
        return [firstControlPoints, secondControlPoints];
      }
      function throughPoints(points) {
        if (points == null || Array.isArray(points) && points.length < 2) {
          throw new Error("At least 2 points are required");
        }
        const controlPoints = getCurveControlPoints(points);
        const curves = [];
        for (let i = 0, ii = controlPoints[0].length; i < ii; i += 1) {
          const controlPoint1 = new Point(controlPoints[0][i].x, controlPoints[0][i].y);
          const controlPoint2 = new Point(controlPoints[1][i].x, controlPoints[1][i].y);
          curves.push(new Curve2(points[i], controlPoint1, controlPoint2, points[i + 1]));
        }
        return curves;
      }
      Curve2.throughPoints = throughPoints;
    })(Curve || (Curve = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/segment.js
var Segment;
var init_segment = __esm({
  "node_modules/@antv/x6-geometry/es/path/segment.js"() {
    init_geometry();
    Segment = class extends Geometry {
      constructor() {
        super(...arguments);
        this.isVisible = true;
        this.isSegment = true;
        this.isSubpathStart = false;
      }
      get end() {
        return this.endPoint;
      }
      get start() {
        if (this.previousSegment == null) {
          throw new Error("Missing previous segment. (This segment cannot be the first segment of a path, or segment has not yet been added to a path.)");
        }
        return this.previousSegment.end;
      }
      closestPointT(p, options) {
        if (this.closestPointNormalizedLength) {
          return this.closestPointNormalizedLength(p);
        }
        throw new Error("Neither `closestPointT` nor `closestPointNormalizedLength` method is implemented.");
      }
      // eslint-disable-next-line
      lengthAtT(t, options) {
        if (t <= 0) {
          return 0;
        }
        const length = this.length();
        if (t >= 1) {
          return length;
        }
        return length * t;
      }
      divideAtT(t) {
        if (this.divideAt) {
          return this.divideAt(t);
        }
        throw new Error("Neither `divideAtT` nor `divideAt` method is implemented.");
      }
      pointAtT(t) {
        if (this.pointAt) {
          return this.pointAt(t);
        }
        throw new Error("Neither `pointAtT` nor `pointAt` method is implemented.");
      }
      tangentAtT(t) {
        if (this.tangentAt) {
          return this.tangentAt(t);
        }
        throw new Error("Neither `tangentAtT` nor `tangentAt` method is implemented.");
      }
    };
  }
});

// node_modules/@antv/x6-geometry/es/path/normalize.js
function rotate2(x, y, rad) {
  return {
    x: x * Math.cos(rad) - y * Math.sin(rad),
    y: x * Math.sin(rad) + y * Math.cos(rad)
  };
}
function q2c(x1, y1, ax, ay, x2, y2) {
  const v13 = 1 / 3;
  const v23 = 2 / 3;
  return [
    v13 * x1 + v23 * ax,
    v13 * y1 + v23 * ay,
    v13 * x2 + v23 * ax,
    v13 * y2 + v23 * ay,
    x2,
    y2
  ];
}
function a2c(x1, y1, rx, ry, angle, largeArcFlag, sweepFlag, x2, y2, recursive) {
  const v120 = Math.PI * 120 / 180;
  const rad = Math.PI / 180 * (+angle || 0);
  let res = [];
  let xy;
  let f1;
  let f2;
  let cx;
  let cy;
  if (!recursive) {
    xy = rotate2(x1, y1, -rad);
    x1 = xy.x;
    y1 = xy.y;
    xy = rotate2(x2, y2, -rad);
    x2 = xy.x;
    y2 = xy.y;
    const x = (x1 - x2) / 2;
    const y = (y1 - y2) / 2;
    let h = x * x / (rx * rx) + y * y / (ry * ry);
    if (h > 1) {
      h = Math.sqrt(h);
      rx = h * rx;
      ry = h * ry;
    }
    const rx2 = rx * rx;
    const ry2 = ry * ry;
    const k = (largeArcFlag === sweepFlag ? -1 : 1) * Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)));
    cx = k * rx * y / ry + (x1 + x2) / 2;
    cy = k * -ry * x / rx + (y1 + y2) / 2;
    f1 = Math.asin((y1 - cy) / ry);
    f2 = Math.asin((y2 - cy) / ry);
    f1 = x1 < cx ? Math.PI - f1 : f1;
    f2 = x2 < cx ? Math.PI - f2 : f2;
    if (f1 < 0) {
      f1 = Math.PI * 2 + f1;
    }
    if (f2 < 0) {
      f2 = Math.PI * 2 + f2;
    }
    if (sweepFlag && f1 > f2) {
      f1 -= Math.PI * 2;
    }
    if (!sweepFlag && f2 > f1) {
      f2 -= Math.PI * 2;
    }
  } else {
    f1 = recursive[0];
    f2 = recursive[1];
    cx = recursive[2];
    cy = recursive[3];
  }
  let df = f2 - f1;
  if (Math.abs(df) > v120) {
    const f2old = f2;
    const x2old = x2;
    const y2old = y2;
    f2 = f1 + v120 * (sweepFlag && f2 > f1 ? 1 : -1);
    x2 = cx + rx * Math.cos(f2);
    y2 = cy + ry * Math.sin(f2);
    res = a2c(x2, y2, rx, ry, angle, 0, sweepFlag, x2old, y2old, [
      f2,
      f2old,
      cx,
      cy
    ]);
  }
  df = f2 - f1;
  const c1 = Math.cos(f1);
  const s1 = Math.sin(f1);
  const c2 = Math.cos(f2);
  const s2 = Math.sin(f2);
  const t = Math.tan(df / 4);
  const hx = 4 / 3 * (rx * t);
  const hy = 4 / 3 * (ry * t);
  const m1 = [x1, y1];
  const m2 = [x1 + hx * s1, y1 - hy * c1];
  const m3 = [x2 + hx * s2, y2 - hy * c2];
  const m4 = [x2, y2];
  m2[0] = 2 * m1[0] - m2[0];
  m2[1] = 2 * m1[1] - m2[1];
  if (recursive) {
    return [m2, m3, m4].concat(res);
  }
  {
    res = [m2, m3, m4].concat(res).join().split(",");
    const newres = [];
    const ii = res.length;
    for (let i = 0; i < ii; i += 1) {
      newres[i] = i % 2 ? rotate2(+res[i - 1], +res[i], rad).y : rotate2(+res[i], +res[i + 1], rad).x;
    }
    return newres;
  }
}
function parse(pathData) {
  if (!pathData) {
    return null;
  }
  const spaces = "	\n\v\f\r   ᠎             　\u2028\u2029";
  const segmentReg = new RegExp(
    `([a-z])[${spaces},]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[${spaces}]*,?[${spaces}]*)+)`,
    // eslint-disable-line
    "ig"
  );
  const commandParamReg = new RegExp(
    // eslint-disable-next-line
    `(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[${spaces}]*,?[${spaces}]*`,
    "ig"
  );
  const paramsCount = {
    a: 7,
    c: 6,
    h: 1,
    l: 2,
    m: 2,
    q: 4,
    s: 4,
    t: 2,
    v: 1,
    z: 0
  };
  const segmetns = [];
  pathData.replace(segmentReg, (input, cmd, args) => {
    const params = [];
    let command = cmd.toLowerCase();
    args.replace(commandParamReg, (a, b) => {
      if (b) {
        params.push(+b);
      }
      return a;
    });
    if (command === "m" && params.length > 2) {
      segmetns.push([cmd, ...params.splice(0, 2)]);
      command = "l";
      cmd = cmd === "m" ? "l" : "L";
    }
    const count = paramsCount[command];
    while (params.length >= count) {
      segmetns.push([cmd, ...params.splice(0, count)]);
      if (!count) {
        break;
      }
    }
    return input;
  });
  return segmetns;
}
function abs(pathString) {
  const pathArray = parse(pathString);
  if (!pathArray || !pathArray.length) {
    return [["M", 0, 0]];
  }
  let x = 0;
  let y = 0;
  let mx = 0;
  let my = 0;
  const segments = [];
  for (let i = 0, ii = pathArray.length; i < ii; i += 1) {
    const r = [];
    segments.push(r);
    const segment = pathArray[i];
    const command = segment[0];
    if (command !== command.toUpperCase()) {
      r[0] = command.toUpperCase();
      switch (r[0]) {
        case "A":
          r[1] = segment[1];
          r[2] = segment[2];
          r[3] = segment[3];
          r[4] = segment[4];
          r[5] = segment[5];
          r[6] = +segment[6] + x;
          r[7] = +segment[7] + y;
          break;
        case "V":
          r[1] = +segment[1] + y;
          break;
        case "H":
          r[1] = +segment[1] + x;
          break;
        case "M":
          mx = +segment[1] + x;
          my = +segment[2] + y;
          for (let j = 1, jj = segment.length; j < jj; j += 1) {
            r[j] = +segment[j] + (j % 2 ? x : y);
          }
          break;
        default:
          for (let j = 1, jj = segment.length; j < jj; j += 1) {
            r[j] = +segment[j] + (j % 2 ? x : y);
          }
          break;
      }
    } else {
      for (let j = 0, jj = segment.length; j < jj; j += 1) {
        r[j] = segment[j];
      }
    }
    switch (r[0]) {
      case "Z":
        x = +mx;
        y = +my;
        break;
      case "H":
        x = r[1];
        break;
      case "V":
        y = r[1];
        break;
      case "M":
        mx = r[r.length - 2];
        my = r[r.length - 1];
        x = r[r.length - 2];
        y = r[r.length - 1];
        break;
      default:
        x = r[r.length - 2];
        y = r[r.length - 1];
        break;
    }
  }
  return segments;
}
function normalize(path) {
  const pathArray = abs(path);
  const attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null };
  function processPath(path2, d, pcom) {
    let nx;
    let ny;
    if (!path2) {
      return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
    }
    if (!(path2[0] in { T: 1, Q: 1 })) {
      d.qx = null;
      d.qy = null;
    }
    switch (path2[0]) {
      case "M":
        d.X = path2[1];
        d.Y = path2[2];
        break;
      case "A":
        if (parseFloat(path2[1]) === 0 || parseFloat(path2[2]) === 0) {
          return ["L", path2[6], path2[7]];
        }
        return ["C"].concat(a2c.apply(0, [d.x, d.y].concat(path2.slice(1))));
      case "S":
        if (pcom === "C" || pcom === "S") {
          nx = d.x * 2 - d.bx;
          ny = d.y * 2 - d.by;
        } else {
          nx = d.x;
          ny = d.y;
        }
        return ["C", nx, ny].concat(path2.slice(1));
      case "T":
        if (pcom === "Q" || pcom === "T") {
          d.qx = d.x * 2 - d.qx;
          d.qy = d.y * 2 - d.qy;
        } else {
          d.qx = d.x;
          d.qy = d.y;
        }
        return ["C"].concat(q2c(d.x, d.y, d.qx, d.qy, path2[1], path2[2]));
      case "Q":
        d.qx = path2[1];
        d.qy = path2[2];
        return ["C"].concat(q2c(d.x, d.y, path2[1], path2[2], path2[3], path2[4]));
      case "H":
        return ["L"].concat(path2[1], d.y);
      case "V":
        return ["L"].concat(d.x, path2[1]);
      case "L":
        break;
      case "Z":
        break;
      default:
        break;
    }
    return path2;
  }
  function fixArc(pp, i) {
    if (pp[i].length > 7) {
      pp[i].shift();
      const pi = pp[i];
      while (pi.length) {
        commands[i] = "A";
        i += 1;
        pp.splice(i, 0, ["C"].concat(pi.splice(0, 6)));
      }
      pp.splice(i, 1);
      ii = pathArray.length;
    }
  }
  const commands = [];
  let prevCommand = "";
  let ii = pathArray.length;
  for (let i = 0; i < ii; i += 1) {
    let command = "";
    if (pathArray[i]) {
      command = pathArray[i][0];
    }
    if (command !== "C") {
      commands[i] = command;
      if (i > 0) {
        prevCommand = commands[i - 1];
      }
    }
    pathArray[i] = processPath(pathArray[i], attrs, prevCommand);
    if (commands[i] !== "A" && command === "C") {
      commands[i] = "C";
    }
    fixArc(pathArray, i);
    const seg = pathArray[i];
    const seglen = seg.length;
    attrs.x = seg[seglen - 2];
    attrs.y = seg[seglen - 1];
    attrs.bx = parseFloat(seg[seglen - 4]) || attrs.x;
    attrs.by = parseFloat(seg[seglen - 3]) || attrs.y;
  }
  if (!pathArray[0][0] || pathArray[0][0] !== "M") {
    pathArray.unshift(["M", 0, 0]);
  }
  return pathArray;
}
function normalizePathData(pathData) {
  return normalize(pathData).map((segment) => segment.map((item) => typeof item === "string" ? item : GeometryUtil.round(item, 2))).join(",").split(",").join(" ");
}
var init_normalize = __esm({
  "node_modules/@antv/x6-geometry/es/path/normalize.js"() {
    init_util4();
  }
});

// node_modules/@antv/x6-geometry/es/path/util.js
function isValid(data2) {
  if (typeof data2 !== "string") {
    return false;
  }
  return regexSupportedData.test(data2);
}
function mod2(n, m) {
  return (n % m + m) % m;
}
function draw(points, round, initialMove, close, exclude) {
  const data2 = [];
  const end = points[points.length - 1];
  const rounded = round != null && round > 0;
  const arcSize = round || 0;
  if (close && rounded) {
    points = points.slice();
    const p0 = points[0];
    const wp = new Point(end.x + (p0.x - end.x) / 2, end.y + (p0.y - end.y) / 2);
    points.splice(0, 0, wp);
  }
  let pt = points[0];
  let i = 1;
  if (initialMove) {
    data2.push("M", pt.x, pt.y);
  } else {
    data2.push("L", pt.x, pt.y);
  }
  while (i < (close ? points.length : points.length - 1)) {
    let tmp = points[mod2(i, points.length)];
    let dx = pt.x - tmp.x;
    let dy = pt.y - tmp.y;
    if (rounded && (dx !== 0 || dy !== 0) && (exclude == null || exclude.indexOf(i - 1) < 0)) {
      let dist = Math.sqrt(dx * dx + dy * dy);
      const nx1 = dx * Math.min(arcSize, dist / 2) / dist;
      const ny1 = dy * Math.min(arcSize, dist / 2) / dist;
      const x1 = tmp.x + nx1;
      const y1 = tmp.y + ny1;
      data2.push("L", x1, y1);
      let next = points[mod2(i + 1, points.length)];
      while (i < points.length - 2 && Math.round(next.x - tmp.x) === 0 && Math.round(next.y - tmp.y) === 0) {
        next = points[mod2(i + 2, points.length)];
        i += 1;
      }
      dx = next.x - tmp.x;
      dy = next.y - tmp.y;
      dist = Math.max(1, Math.sqrt(dx * dx + dy * dy));
      const nx2 = dx * Math.min(arcSize, dist / 2) / dist;
      const ny2 = dy * Math.min(arcSize, dist / 2) / dist;
      const x2 = tmp.x + nx2;
      const y2 = tmp.y + ny2;
      data2.push("Q", tmp.x, tmp.y, x2, y2);
      tmp = new Point(x2, y2);
    } else {
      data2.push("L", tmp.x, tmp.y);
    }
    pt = tmp;
    i += 1;
  }
  if (close) {
    data2.push("Z");
  } else {
    data2.push("L", end.x, end.y);
  }
  return data2.map((v) => typeof v === "string" ? v : +v.toFixed(3)).join(" ");
}
function drawPoints(points, options = {}) {
  const pts = [];
  if (points && points.length) {
    points.forEach((p) => {
      if (Array.isArray(p)) {
        pts.push({ x: p[0], y: p[1] });
      } else {
        pts.push({ x: p.x, y: p.y });
      }
    });
  }
  return draw(pts, options.round, options.initialMove == null || options.initialMove, options.close, options.exclude);
}
function arcToCurves(x0, y0, r1, r2, angle = 0, largeArcFlag = 0, sweepFlag = 0, x, y) {
  if (r1 === 0 || r2 === 0) {
    return [];
  }
  x -= x0;
  y -= y0;
  r1 = Math.abs(r1);
  r2 = Math.abs(r2);
  const ctx = -x / 2;
  const cty = -y / 2;
  const cpsi = Math.cos(angle * Math.PI / 180);
  const spsi = Math.sin(angle * Math.PI / 180);
  const rxd = cpsi * ctx + spsi * cty;
  const ryd = -1 * spsi * ctx + cpsi * cty;
  const rxdd = rxd * rxd;
  const rydd = ryd * ryd;
  const r1x = r1 * r1;
  const r2y = r2 * r2;
  const lamda = rxdd / r1x + rydd / r2y;
  let sds;
  if (lamda > 1) {
    r1 = Math.sqrt(lamda) * r1;
    r2 = Math.sqrt(lamda) * r2;
    sds = 0;
  } else {
    let seif = 1;
    if (largeArcFlag === sweepFlag) {
      seif = -1;
    }
    sds = seif * Math.sqrt((r1x * r2y - r1x * rydd - r2y * rxdd) / (r1x * rydd + r2y * rxdd));
  }
  const txd = sds * r1 * ryd / r2;
  const tyd = -1 * sds * r2 * rxd / r1;
  const tx = cpsi * txd - spsi * tyd + x / 2;
  const ty = spsi * txd + cpsi * tyd + y / 2;
  let rad = Math.atan2((ryd - tyd) / r2, (rxd - txd) / r1) - Math.atan2(0, 1);
  let s1 = rad >= 0 ? rad : 2 * Math.PI + rad;
  rad = Math.atan2((-ryd - tyd) / r2, (-rxd - txd) / r1) - Math.atan2((ryd - tyd) / r2, (rxd - txd) / r1);
  let dr = rad >= 0 ? rad : 2 * Math.PI + rad;
  if (sweepFlag === 0 && dr > 0) {
    dr -= 2 * Math.PI;
  } else if (sweepFlag !== 0 && dr < 0) {
    dr += 2 * Math.PI;
  }
  const sse = dr * 2 / Math.PI;
  const seg = Math.ceil(sse < 0 ? -1 * sse : sse);
  const segr = dr / seg;
  const t = 8 / 3 * Math.sin(segr / 4) * Math.sin(segr / 4) / Math.sin(segr / 2);
  const cpsir1 = cpsi * r1;
  const cpsir2 = cpsi * r2;
  const spsir1 = spsi * r1;
  const spsir2 = spsi * r2;
  let mc = Math.cos(s1);
  let ms = Math.sin(s1);
  let x2 = -t * (cpsir1 * ms + spsir2 * mc);
  let y2 = -t * (spsir1 * ms - cpsir2 * mc);
  let x3 = 0;
  let y3 = 0;
  const result = [];
  for (let n = 0; n < seg; n += 1) {
    s1 += segr;
    mc = Math.cos(s1);
    ms = Math.sin(s1);
    x3 = cpsir1 * mc - spsir2 * ms + tx;
    y3 = spsir1 * mc + cpsir2 * ms + ty;
    const dx = -t * (cpsir1 * ms + spsir2 * mc);
    const dy = -t * (spsir1 * ms - cpsir2 * mc);
    const index2 = n * 6;
    result[index2] = Number(x2 + x0);
    result[index2 + 1] = Number(y2 + y0);
    result[index2 + 2] = Number(x3 - dx + x0);
    result[index2 + 3] = Number(y3 - dy + y0);
    result[index2 + 4] = Number(x3 + x0);
    result[index2 + 5] = Number(y3 + y0);
    x2 = x3 + dx;
    y2 = y3 + dy;
  }
  return result.map((num) => +num.toFixed(2));
}
function drawArc(startX, startY, rx, ry, xAxisRotation = 0, largeArcFlag = 0, sweepFlag = 0, stopX, stopY) {
  const data2 = [];
  const points = arcToCurves(startX, startY, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, stopX, stopY);
  if (points != null) {
    for (let i = 0, ii = points.length; i < ii; i += 6) {
      data2.push("C", points[i], points[i + 1], points[i + 2], points[i + 3], points[i + 4], points[i + 5]);
    }
  }
  return data2.join(" ");
}
var regexSupportedData;
var init_util5 = __esm({
  "node_modules/@antv/x6-geometry/es/path/util.js"() {
    init_point();
    regexSupportedData = new RegExp(`^[\\s\\dLMCZz,.]*$`);
  }
});

// node_modules/@antv/x6-geometry/es/path/lineto.js
var LineTo;
var init_lineto = __esm({
  "node_modules/@antv/x6-geometry/es/path/lineto.js"() {
    init_line();
    init_point();
    init_segment();
    LineTo = class _LineTo extends Segment {
      constructor(x, y) {
        super();
        if (Line.isLine(x)) {
          this.endPoint = x.end.clone().round(2);
        } else {
          this.endPoint = Point.create(x, y).round(2);
        }
      }
      get type() {
        return "L";
      }
      get line() {
        return new Line(this.start, this.end);
      }
      bbox() {
        return this.line.bbox();
      }
      closestPoint(p) {
        return this.line.closestPoint(p);
      }
      closestPointLength(p) {
        return this.line.closestPointLength(p);
      }
      closestPointNormalizedLength(p) {
        return this.line.closestPointNormalizedLength(p);
      }
      closestPointTangent(p) {
        return this.line.closestPointTangent(p);
      }
      length() {
        return this.line.length();
      }
      divideAt(ratio) {
        const divided = this.line.divideAt(ratio);
        return [new _LineTo(divided[0]), new _LineTo(divided[1])];
      }
      divideAtLength(length) {
        const divided = this.line.divideAtLength(length);
        return [new _LineTo(divided[0]), new _LineTo(divided[1])];
      }
      getSubdivisions() {
        return [];
      }
      pointAt(ratio) {
        return this.line.pointAt(ratio);
      }
      pointAtLength(length) {
        return this.line.pointAtLength(length);
      }
      tangentAt(ratio) {
        return this.line.tangentAt(ratio);
      }
      tangentAtLength(length) {
        return this.line.tangentAtLength(length);
      }
      isDifferentiable() {
        if (this.previousSegment == null) {
          return false;
        }
        return !this.start.equals(this.end);
      }
      clone() {
        return new _LineTo(this.end);
      }
      scale(sx, sy, origin) {
        this.end.scale(sx, sy, origin);
        return this;
      }
      rotate(angle, origin) {
        this.end.rotate(angle, origin);
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.end.translate(tx, ty);
        } else {
          this.end.translate(tx);
        }
        return this;
      }
      equals(s) {
        return this.type === s.type && this.start.equals(s.start) && this.end.equals(s.end);
      }
      toJSON() {
        return {
          type: this.type,
          start: this.start.toJSON(),
          end: this.end.toJSON()
        };
      }
      serialize() {
        const end = this.end;
        return `${this.type} ${end.x} ${end.y}`;
      }
    };
    (function(LineTo2) {
      function create(...args) {
        const len = args.length;
        const arg0 = args[0];
        if (Line.isLine(arg0)) {
          return new LineTo2(arg0);
        }
        if (Point.isPointLike(arg0)) {
          if (len === 1) {
            return new LineTo2(arg0);
          }
          return args.map((arg) => new LineTo2(arg));
        }
        if (len === 2) {
          return new LineTo2(+args[0], +args[1]);
        }
        const segments = [];
        for (let i = 0; i < len; i += 2) {
          const x = +args[i];
          const y = +args[i + 1];
          segments.push(new LineTo2(x, y));
        }
        return segments;
      }
      LineTo2.create = create;
    })(LineTo || (LineTo = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/close.js
var Close;
var init_close = __esm({
  "node_modules/@antv/x6-geometry/es/path/close.js"() {
    init_line();
    init_lineto();
    init_segment();
    Close = class _Close extends Segment {
      get end() {
        if (!this.subpathStartSegment) {
          throw new Error("Missing subpath start segment. (This segment needs a subpath start segment (e.g. MoveTo), or segment has not yet been added to a path.)");
        }
        return this.subpathStartSegment.end;
      }
      get type() {
        return "Z";
      }
      get line() {
        return new Line(this.start, this.end);
      }
      bbox() {
        return this.line.bbox();
      }
      closestPoint(p) {
        return this.line.closestPoint(p);
      }
      closestPointLength(p) {
        return this.line.closestPointLength(p);
      }
      closestPointNormalizedLength(p) {
        return this.line.closestPointNormalizedLength(p);
      }
      closestPointTangent(p) {
        return this.line.closestPointTangent(p);
      }
      length() {
        return this.line.length();
      }
      divideAt(ratio) {
        const divided = this.line.divideAt(ratio);
        return [
          // do not actually cut into the segment, first divided part can stay as Z
          divided[1].isDifferentiable() ? new LineTo(divided[0]) : this.clone(),
          new LineTo(divided[1])
        ];
      }
      divideAtLength(length) {
        const divided = this.line.divideAtLength(length);
        return [
          divided[1].isDifferentiable() ? new LineTo(divided[0]) : this.clone(),
          new LineTo(divided[1])
        ];
      }
      getSubdivisions() {
        return [];
      }
      pointAt(ratio) {
        return this.line.pointAt(ratio);
      }
      pointAtLength(length) {
        return this.line.pointAtLength(length);
      }
      tangentAt(ratio) {
        return this.line.tangentAt(ratio);
      }
      tangentAtLength(length) {
        return this.line.tangentAtLength(length);
      }
      isDifferentiable() {
        if (!this.previousSegment || !this.subpathStartSegment) {
          return false;
        }
        return !this.start.equals(this.end);
      }
      scale() {
        return this;
      }
      rotate() {
        return this;
      }
      translate() {
        return this;
      }
      equals(s) {
        return this.type === s.type && this.start.equals(s.start) && this.end.equals(s.end);
      }
      clone() {
        return new _Close();
      }
      toJSON() {
        return {
          type: this.type,
          start: this.start.toJSON(),
          end: this.end.toJSON()
        };
      }
      serialize() {
        return this.type;
      }
    };
    (function(Close2) {
      function create() {
        return new Close2();
      }
      Close2.create = create;
    })(Close || (Close = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/moveto.js
var MoveTo;
var init_moveto = __esm({
  "node_modules/@antv/x6-geometry/es/path/moveto.js"() {
    init_line();
    init_curve();
    init_point();
    init_lineto();
    init_segment();
    MoveTo = class _MoveTo extends Segment {
      constructor(x, y) {
        super();
        this.isVisible = false;
        this.isSubpathStart = true;
        if (Line.isLine(x) || Curve.isCurve(x)) {
          this.endPoint = x.end.clone().round(2);
        } else {
          this.endPoint = Point.create(x, y).round(2);
        }
      }
      get start() {
        throw new Error("Illegal access. Moveto segments should not need a start property.");
      }
      get type() {
        return "M";
      }
      bbox() {
        return null;
      }
      closestPoint() {
        return this.end.clone();
      }
      closestPointLength() {
        return 0;
      }
      closestPointNormalizedLength() {
        return 0;
      }
      closestPointT() {
        return 1;
      }
      closestPointTangent() {
        return null;
      }
      length() {
        return 0;
      }
      lengthAtT() {
        return 0;
      }
      divideAt() {
        return [this.clone(), this.clone()];
      }
      divideAtLength() {
        return [this.clone(), this.clone()];
      }
      getSubdivisions() {
        return [];
      }
      pointAt() {
        return this.end.clone();
      }
      pointAtLength() {
        return this.end.clone();
      }
      pointAtT() {
        return this.end.clone();
      }
      tangentAt() {
        return null;
      }
      tangentAtLength() {
        return null;
      }
      tangentAtT() {
        return null;
      }
      isDifferentiable() {
        return false;
      }
      scale(sx, sy, origin) {
        this.end.scale(sx, sy, origin);
        return this;
      }
      rotate(angle, origin) {
        this.end.rotate(angle, origin);
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.end.translate(tx, ty);
        } else {
          this.end.translate(tx);
        }
        return this;
      }
      clone() {
        return new _MoveTo(this.end);
      }
      equals(s) {
        return this.type === s.type && this.end.equals(s.end);
      }
      toJSON() {
        return {
          type: this.type,
          end: this.end.toJSON()
        };
      }
      serialize() {
        const end = this.end;
        return `${this.type} ${end.x} ${end.y}`;
      }
    };
    (function(MoveTo2) {
      function create(...args) {
        const len = args.length;
        const arg0 = args[0];
        if (Line.isLine(arg0)) {
          return new MoveTo2(arg0);
        }
        if (Curve.isCurve(arg0)) {
          return new MoveTo2(arg0);
        }
        if (Point.isPointLike(arg0)) {
          if (len === 1) {
            return new MoveTo2(arg0);
          }
          const segments2 = [];
          for (let i = 0; i < len; i += 1) {
            if (i === 0) {
              segments2.push(new MoveTo2(args[i]));
            } else {
              segments2.push(new LineTo(args[i]));
            }
          }
          return segments2;
        }
        if (len === 2) {
          return new MoveTo2(+args[0], +args[1]);
        }
        const segments = [];
        for (let i = 0; i < len; i += 2) {
          const x = +args[i];
          const y = +args[i + 1];
          if (i === 0) {
            segments.push(new MoveTo2(x, y));
          } else {
            segments.push(new LineTo(x, y));
          }
        }
        return segments;
      }
      MoveTo2.create = create;
    })(MoveTo || (MoveTo = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/curveto.js
var CurveTo;
var init_curveto = __esm({
  "node_modules/@antv/x6-geometry/es/path/curveto.js"() {
    init_curve();
    init_point();
    init_segment();
    CurveTo = class _CurveTo extends Segment {
      constructor(arg0, arg1, arg2, arg3, arg4, arg5) {
        super();
        if (Curve.isCurve(arg0)) {
          this.controlPoint1 = arg0.controlPoint1.clone().round(2);
          this.controlPoint2 = arg0.controlPoint2.clone().round(2);
          this.endPoint = arg0.end.clone().round(2);
        } else if (typeof arg0 === "number") {
          this.controlPoint1 = new Point(arg0, arg1).round(2);
          this.controlPoint2 = new Point(arg2, arg3).round(2);
          this.endPoint = new Point(arg4, arg5).round(2);
        } else {
          this.controlPoint1 = Point.create(arg0).round(2);
          this.controlPoint2 = Point.create(arg1).round(2);
          this.endPoint = Point.create(arg2).round(2);
        }
      }
      get type() {
        return "C";
      }
      get curve() {
        return new Curve(this.start, this.controlPoint1, this.controlPoint2, this.end);
      }
      bbox() {
        return this.curve.bbox();
      }
      closestPoint(p) {
        return this.curve.closestPoint(p);
      }
      closestPointLength(p) {
        return this.curve.closestPointLength(p);
      }
      closestPointNormalizedLength(p) {
        return this.curve.closestPointNormalizedLength(p);
      }
      closestPointTangent(p) {
        return this.curve.closestPointTangent(p);
      }
      length() {
        return this.curve.length();
      }
      divideAt(ratio, options = {}) {
        const divided = this.curve.divideAt(ratio, options);
        return [new _CurveTo(divided[0]), new _CurveTo(divided[1])];
      }
      divideAtLength(length, options = {}) {
        const divided = this.curve.divideAtLength(length, options);
        return [new _CurveTo(divided[0]), new _CurveTo(divided[1])];
      }
      divideAtT(t) {
        const divided = this.curve.divideAtT(t);
        return [new _CurveTo(divided[0]), new _CurveTo(divided[1])];
      }
      getSubdivisions() {
        return [];
      }
      pointAt(ratio) {
        return this.curve.pointAt(ratio);
      }
      pointAtLength(length) {
        return this.curve.pointAtLength(length);
      }
      tangentAt(ratio) {
        return this.curve.tangentAt(ratio);
      }
      tangentAtLength(length) {
        return this.curve.tangentAtLength(length);
      }
      isDifferentiable() {
        if (!this.previousSegment) {
          return false;
        }
        const start = this.start;
        const control1 = this.controlPoint1;
        const control2 = this.controlPoint2;
        const end = this.end;
        return !(start.equals(control1) && control1.equals(control2) && control2.equals(end));
      }
      scale(sx, sy, origin) {
        this.controlPoint1.scale(sx, sy, origin);
        this.controlPoint2.scale(sx, sy, origin);
        this.end.scale(sx, sy, origin);
        return this;
      }
      rotate(angle, origin) {
        this.controlPoint1.rotate(angle, origin);
        this.controlPoint2.rotate(angle, origin);
        this.end.rotate(angle, origin);
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.controlPoint1.translate(tx, ty);
          this.controlPoint2.translate(tx, ty);
          this.end.translate(tx, ty);
        } else {
          this.controlPoint1.translate(tx);
          this.controlPoint2.translate(tx);
          this.end.translate(tx);
        }
        return this;
      }
      equals(s) {
        return this.start.equals(s.start) && this.end.equals(s.end) && this.controlPoint1.equals(s.controlPoint1) && this.controlPoint2.equals(s.controlPoint2);
      }
      clone() {
        return new _CurveTo(this.controlPoint1, this.controlPoint2, this.end);
      }
      toJSON() {
        return {
          type: this.type,
          start: this.start.toJSON(),
          controlPoint1: this.controlPoint1.toJSON(),
          controlPoint2: this.controlPoint2.toJSON(),
          end: this.end.toJSON()
        };
      }
      serialize() {
        const c1 = this.controlPoint1;
        const c2 = this.controlPoint2;
        const end = this.end;
        return [this.type, c1.x, c1.y, c2.x, c2.y, end.x, end.y].join(" ");
      }
    };
    (function(CurveTo2) {
      function create(...args) {
        const len = args.length;
        const arg0 = args[0];
        if (Curve.isCurve(arg0)) {
          return new CurveTo2(arg0);
        }
        if (Point.isPointLike(arg0)) {
          if (len === 3) {
            return new CurveTo2(args[0], args[1], args[2]);
          }
          const segments2 = [];
          for (let i = 0; i < len; i += 3) {
            segments2.push(new CurveTo2(args[i], args[i + 1], args[i + 2]));
          }
          return segments2;
        }
        if (len === 6) {
          return new CurveTo2(args[0], args[1], args[2], args[3], args[4], args[5]);
        }
        const segments = [];
        for (let i = 0; i < len; i += 6) {
          segments.push(new CurveTo2(args[i], args[i + 1], args[i + 2], args[i + 3], args[i + 4], args[i + 5]));
        }
        return segments;
      }
      CurveTo2.create = create;
    })(CurveTo || (CurveTo = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/path.js
var Path;
var init_path2 = __esm({
  "node_modules/@antv/x6-geometry/es/path/path.js"() {
    init_util4();
    init_util5();
    init_line();
    init_point();
    init_curve();
    init_polyline();
    init_rectangle();
    init_geometry();
    init_close();
    init_lineto();
    init_moveto();
    init_curveto();
    init_normalize();
    Path = class _Path extends Geometry {
      constructor(args) {
        super();
        this.PRECISION = 3;
        this.segments = [];
        if (Array.isArray(args)) {
          if (Line.isLine(args[0]) || Curve.isCurve(args[0])) {
            let previousObj = null;
            const arr = args;
            arr.forEach((o, i) => {
              if (i === 0) {
                this.appendSegment(_Path.createSegment("M", o.start));
              }
              if (previousObj != null && !previousObj.end.equals(o.start)) {
                this.appendSegment(_Path.createSegment("M", o.start));
              }
              if (Line.isLine(o)) {
                this.appendSegment(_Path.createSegment("L", o.end));
              } else if (Curve.isCurve(o)) {
                this.appendSegment(_Path.createSegment("C", o.controlPoint1, o.controlPoint2, o.end));
              }
              previousObj = o;
            });
          } else {
            const arr = args;
            arr.forEach((s) => {
              if (s.isSegment) {
                this.appendSegment(s);
              }
            });
          }
        } else if (args != null) {
          if (Line.isLine(args)) {
            this.appendSegment(_Path.createSegment("M", args.start));
            this.appendSegment(_Path.createSegment("L", args.end));
          } else if (Curve.isCurve(args)) {
            this.appendSegment(_Path.createSegment("M", args.start));
            this.appendSegment(_Path.createSegment("C", args.controlPoint1, args.controlPoint2, args.end));
          } else if (Polyline.isPolyline(args)) {
            if (args.points && args.points.length) {
              args.points.forEach((point, index2) => {
                const segment = index2 === 0 ? _Path.createSegment("M", point) : _Path.createSegment("L", point);
                this.appendSegment(segment);
              });
            }
          } else if (args.isSegment) {
            this.appendSegment(args);
          }
        }
      }
      get start() {
        const segments = this.segments;
        const count = segments.length;
        if (count === 0) {
          return null;
        }
        for (let i = 0; i < count; i += 1) {
          const segment = segments[i];
          if (segment.isVisible) {
            return segment.start;
          }
        }
        return segments[count - 1].end;
      }
      get end() {
        const segments = this.segments;
        const count = segments.length;
        if (count === 0) {
          return null;
        }
        for (let i = count - 1; i >= 0; i -= 1) {
          const segment = segments[i];
          if (segment.isVisible) {
            return segment.end;
          }
        }
        return segments[count - 1].end;
      }
      moveTo(...args) {
        return this.appendSegment(MoveTo.create.call(null, ...args));
      }
      lineTo(...args) {
        return this.appendSegment(LineTo.create.call(null, ...args));
      }
      curveTo(...args) {
        return this.appendSegment(CurveTo.create.call(null, ...args));
      }
      arcTo(rx, ry, xAxisRotation, largeArcFlag, sweepFlag, endX, endY) {
        const start = this.end || new Point();
        const points = typeof endX === "number" ? arcToCurves(start.x, start.y, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, endX, endY) : arcToCurves(start.x, start.y, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, endX.x, endX.y);
        if (points != null) {
          for (let i = 0, ii = points.length; i < ii; i += 6) {
            this.curveTo(points[i], points[i + 1], points[i + 2], points[i + 3], points[i + 4], points[i + 5]);
          }
        }
        return this;
      }
      quadTo(x1, y1, x, y) {
        const start = this.end || new Point();
        const data2 = ["M", start.x, start.y];
        if (typeof x1 === "number") {
          data2.push("Q", x1, y1, x, y);
        } else {
          const p = y1;
          data2.push(`Q`, x1.x, x1.y, p.x, p.y);
        }
        const path = _Path.parse(data2.join(" "));
        this.appendSegment(path.segments.slice(1));
        return this;
      }
      close() {
        return this.appendSegment(Close.create());
      }
      drawPoints(points, options = {}) {
        const raw = drawPoints(points, options);
        const sub = _Path.parse(raw);
        if (sub && sub.segments) {
          this.appendSegment(sub.segments);
        }
      }
      bbox() {
        const segments = this.segments;
        const count = segments.length;
        if (count === 0) {
          return null;
        }
        let bbox;
        for (let i = 0; i < count; i += 1) {
          const segment = segments[i];
          if (segment.isVisible) {
            const segmentBBox = segment.bbox();
            if (segmentBBox != null) {
              bbox = bbox ? bbox.union(segmentBBox) : segmentBBox;
            }
          }
        }
        if (bbox != null) {
          return bbox;
        }
        const lastSegment = segments[count - 1];
        return new Rectangle(lastSegment.end.x, lastSegment.end.y, 0, 0);
      }
      appendSegment(seg) {
        const count = this.segments.length;
        let previousSegment = count !== 0 ? this.segments[count - 1] : null;
        let currentSegment;
        const nextSegment = null;
        if (Array.isArray(seg)) {
          for (let i = 0, ii = seg.length; i < ii; i += 1) {
            const segment = seg[i];
            currentSegment = this.prepareSegment(segment, previousSegment, nextSegment);
            this.segments.push(currentSegment);
            previousSegment = currentSegment;
          }
        } else if (seg != null && seg.isSegment) {
          currentSegment = this.prepareSegment(seg, previousSegment, nextSegment);
          this.segments.push(currentSegment);
        }
        return this;
      }
      insertSegment(index2, seg) {
        const count = this.segments.length;
        if (index2 < 0) {
          index2 = count + index2 + 1;
        }
        if (index2 > count || index2 < 0) {
          throw new Error("Index out of range.");
        }
        let currentSegment;
        let previousSegment = null;
        let nextSegment = null;
        if (count !== 0) {
          if (index2 >= 1) {
            previousSegment = this.segments[index2 - 1];
            nextSegment = previousSegment.nextSegment;
          } else {
            previousSegment = null;
            nextSegment = this.segments[0];
          }
        }
        if (!Array.isArray(seg)) {
          currentSegment = this.prepareSegment(seg, previousSegment, nextSegment);
          this.segments.splice(index2, 0, currentSegment);
        } else {
          for (let i = 0, ii = seg.length; i < ii; i += 1) {
            const segment = seg[i];
            currentSegment = this.prepareSegment(segment, previousSegment, nextSegment);
            this.segments.splice(index2 + i, 0, currentSegment);
            previousSegment = currentSegment;
          }
        }
        return this;
      }
      removeSegment(index2) {
        const idx = this.fixIndex(index2);
        const removedSegment = this.segments.splice(idx, 1)[0];
        const previousSegment = removedSegment.previousSegment;
        const nextSegment = removedSegment.nextSegment;
        if (previousSegment) {
          previousSegment.nextSegment = nextSegment;
        }
        if (nextSegment) {
          nextSegment.previousSegment = previousSegment;
        }
        if (removedSegment.isSubpathStart && nextSegment) {
          this.updateSubpathStartSegment(nextSegment);
        }
        return removedSegment;
      }
      replaceSegment(index2, seg) {
        const idx = this.fixIndex(index2);
        let currentSegment;
        const replacedSegment = this.segments[idx];
        let previousSegment = replacedSegment.previousSegment;
        const nextSegment = replacedSegment.nextSegment;
        let updateSubpathStart = replacedSegment.isSubpathStart;
        if (!Array.isArray(seg)) {
          currentSegment = this.prepareSegment(seg, previousSegment, nextSegment);
          this.segments.splice(idx, 1, currentSegment);
          if (updateSubpathStart && currentSegment.isSubpathStart) {
            updateSubpathStart = false;
          }
        } else {
          this.segments.splice(index2, 1);
          for (let i = 0, ii = seg.length; i < ii; i += 1) {
            const segment = seg[i];
            currentSegment = this.prepareSegment(segment, previousSegment, nextSegment);
            this.segments.splice(index2 + i, 0, currentSegment);
            previousSegment = currentSegment;
            if (updateSubpathStart && currentSegment.isSubpathStart) {
              updateSubpathStart = false;
            }
          }
        }
        if (updateSubpathStart && nextSegment) {
          this.updateSubpathStartSegment(nextSegment);
        }
      }
      getSegment(index2) {
        const idx = this.fixIndex(index2);
        return this.segments[idx];
      }
      fixIndex(index2) {
        const length = this.segments.length;
        if (length === 0) {
          throw new Error("Path has no segments.");
        }
        let i = index2;
        while (i < 0) {
          i = length + i;
        }
        if (i >= length || i < 0) {
          throw new Error("Index out of range.");
        }
        return i;
      }
      segmentAt(ratio, options = {}) {
        const index2 = this.segmentIndexAt(ratio, options);
        if (!index2) {
          return null;
        }
        return this.getSegment(index2);
      }
      segmentAtLength(length, options = {}) {
        const index2 = this.segmentIndexAtLength(length, options);
        if (!index2)
          return null;
        return this.getSegment(index2);
      }
      segmentIndexAt(ratio, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        const rate = GeometryUtil.clamp(ratio, 0, 1);
        const opt = this.getOptions(options);
        const len = this.length(opt);
        const length = len * rate;
        return this.segmentIndexAtLength(length, opt);
      }
      segmentIndexAtLength(length, options = {}) {
        const count = this.segments.length;
        if (count === 0) {
          return null;
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let memo = 0;
        let lastVisibleIndex = null;
        for (let i = 0; i < count; i += 1) {
          const index2 = fromStart ? i : count - 1 - i;
          const segment = this.segments[index2];
          const subdivisions = segmentSubdivisions[index2];
          const len = segment.length({ precision, subdivisions });
          if (segment.isVisible) {
            if (length <= memo + len) {
              return index2;
            }
            lastVisibleIndex = index2;
          }
          memo += len;
        }
        return lastVisibleIndex;
      }
      getSegmentSubdivisions(options = {}) {
        const precision = this.getPrecision(options);
        const segmentSubdivisions = [];
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const segment = this.segments[i];
          const subdivisions = segment.getSubdivisions({ precision });
          segmentSubdivisions.push(subdivisions);
        }
        return segmentSubdivisions;
      }
      updateSubpathStartSegment(segment) {
        let previous = segment.previousSegment;
        let current = segment;
        while (current && !current.isSubpathStart) {
          if (previous != null) {
            current.subpathStartSegment = previous.subpathStartSegment;
          } else {
            current.subpathStartSegment = null;
          }
          previous = current;
          current = current.nextSegment;
        }
      }
      prepareSegment(segment, previousSegment, nextSegment) {
        segment.previousSegment = previousSegment;
        segment.nextSegment = nextSegment;
        if (previousSegment != null) {
          previousSegment.nextSegment = segment;
        }
        if (nextSegment != null) {
          nextSegment.previousSegment = segment;
        }
        let updateSubpathStart = segment;
        if (segment.isSubpathStart) {
          segment.subpathStartSegment = segment;
          updateSubpathStart = nextSegment;
        }
        if (updateSubpathStart != null) {
          this.updateSubpathStartSegment(updateSubpathStart);
        }
        return segment;
      }
      closestPoint(p, options = {}) {
        const t = this.closestPointT(p, options);
        if (!t) {
          return null;
        }
        return this.pointAtT(t);
      }
      closestPointLength(p, options = {}) {
        const opts = this.getOptions(options);
        const t = this.closestPointT(p, opts);
        if (!t) {
          return 0;
        }
        return this.lengthAtT(t, opts);
      }
      closestPointNormalizedLength(p, options = {}) {
        const opts = this.getOptions(options);
        const cpLength = this.closestPointLength(p, opts);
        if (cpLength === 0) {
          return 0;
        }
        const length = this.length(opts);
        if (length === 0) {
          return 0;
        }
        return cpLength / length;
      }
      closestPointT(p, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let closestPointT;
        let minSquaredDistance = Infinity;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const segment = this.segments[i];
          const subdivisions = segmentSubdivisions[i];
          if (segment.isVisible) {
            const segmentClosestPointT = segment.closestPointT(p, {
              precision,
              subdivisions
            });
            const segmentClosestPoint = segment.pointAtT(segmentClosestPointT);
            const squaredDistance = GeometryUtil.squaredLength(segmentClosestPoint, p);
            if (squaredDistance < minSquaredDistance) {
              closestPointT = { segmentIndex: i, value: segmentClosestPointT };
              minSquaredDistance = squaredDistance;
            }
          }
        }
        if (closestPointT) {
          return closestPointT;
        }
        return { segmentIndex: this.segments.length - 1, value: 1 };
      }
      closestPointTangent(p, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let closestPointTangent;
        let minSquaredDistance = Infinity;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const segment = this.segments[i];
          const subdivisions = segmentSubdivisions[i];
          if (segment.isDifferentiable()) {
            const segmentClosestPointT = segment.closestPointT(p, {
              precision,
              subdivisions
            });
            const segmentClosestPoint = segment.pointAtT(segmentClosestPointT);
            const squaredDistance = GeometryUtil.squaredLength(segmentClosestPoint, p);
            if (squaredDistance < minSquaredDistance) {
              closestPointTangent = segment.tangentAtT(segmentClosestPointT);
              minSquaredDistance = squaredDistance;
            }
          }
        }
        if (closestPointTangent) {
          return closestPointTangent;
        }
        return null;
      }
      containsPoint(p, options = {}) {
        const polylines = this.toPolylines(options);
        if (!polylines) {
          return false;
        }
        let numIntersections = 0;
        for (let i = 0, ii = polylines.length; i < ii; i += 1) {
          const polyline = polylines[i];
          if (polyline.containsPoint(p)) {
            numIntersections += 1;
          }
        }
        return numIntersections % 2 === 1;
      }
      pointAt(ratio, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        if (ratio <= 0) {
          return this.start.clone();
        }
        if (ratio >= 1) {
          return this.end.clone();
        }
        const opts = this.getOptions(options);
        const pathLength = this.length(opts);
        const length = pathLength * ratio;
        return this.pointAtLength(length, opts);
      }
      pointAtLength(length, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        if (length === 0) {
          return this.start.clone();
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let lastVisibleSegment;
        let memo = 0;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const index2 = fromStart ? i : ii - 1 - i;
          const segment = this.segments[index2];
          const subdivisions = segmentSubdivisions[index2];
          const d = segment.length({
            precision,
            subdivisions
          });
          if (segment.isVisible) {
            if (length <= memo + d) {
              return segment.pointAtLength((fromStart ? 1 : -1) * (length - memo), {
                precision,
                subdivisions
              });
            }
            lastVisibleSegment = segment;
          }
          memo += d;
        }
        if (lastVisibleSegment) {
          return fromStart ? lastVisibleSegment.end : lastVisibleSegment.start;
        }
        const lastSegment = this.segments[this.segments.length - 1];
        return lastSegment.end.clone();
      }
      pointAtT(t) {
        const segments = this.segments;
        const numSegments = segments.length;
        if (numSegments === 0)
          return null;
        const segmentIndex = t.segmentIndex;
        if (segmentIndex < 0)
          return segments[0].pointAtT(0);
        if (segmentIndex >= numSegments) {
          return segments[numSegments - 1].pointAtT(1);
        }
        const tValue = GeometryUtil.clamp(t.value, 0, 1);
        return segments[segmentIndex].pointAtT(tValue);
      }
      divideAt(ratio, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        const rate = GeometryUtil.clamp(ratio, 0, 1);
        const opts = this.getOptions(options);
        const len = this.length(opts);
        const length = len * rate;
        return this.divideAtLength(length, opts);
      }
      divideAtLength(length, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let memo = 0;
        let divided;
        let dividedSegmentIndex;
        let lastValidSegment;
        let lastValidSegmentIndex;
        let t;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const index3 = fromStart ? i : ii - 1 - i;
          const segment = this.getSegment(index3);
          const subdivisions = segmentSubdivisions[index3];
          const opts = { precision, subdivisions };
          const len = segment.length(opts);
          if (segment.isDifferentiable()) {
            lastValidSegment = segment;
            lastValidSegmentIndex = index3;
            if (length <= memo + len) {
              dividedSegmentIndex = index3;
              divided = segment.divideAtLength((fromStart ? 1 : -1) * (length - memo), opts);
              break;
            }
          }
          memo += len;
        }
        if (!lastValidSegment) {
          return null;
        }
        if (!divided) {
          dividedSegmentIndex = lastValidSegmentIndex;
          t = fromStart ? 1 : 0;
          divided = lastValidSegment.divideAtT(t);
        }
        const pathCopy = this.clone();
        const index2 = dividedSegmentIndex;
        pathCopy.replaceSegment(index2, divided);
        const divisionStartIndex = index2;
        let divisionMidIndex = index2 + 1;
        let divisionEndIndex = index2 + 2;
        if (!divided[0].isDifferentiable()) {
          pathCopy.removeSegment(divisionStartIndex);
          divisionMidIndex -= 1;
          divisionEndIndex -= 1;
        }
        const movetoEnd = pathCopy.getSegment(divisionMidIndex).start;
        pathCopy.insertSegment(divisionMidIndex, _Path.createSegment("M", movetoEnd));
        divisionEndIndex += 1;
        if (!divided[1].isDifferentiable()) {
          pathCopy.removeSegment(divisionEndIndex - 1);
          divisionEndIndex -= 1;
        }
        const secondPathSegmentIndexConversion = divisionEndIndex - divisionStartIndex - 1;
        for (let i = divisionEndIndex, ii = pathCopy.segments.length; i < ii; i += 1) {
          const originalSegment = this.getSegment(i - secondPathSegmentIndexConversion);
          const segment = pathCopy.getSegment(i);
          if (segment.type === "Z" && !originalSegment.subpathStartSegment.end.equals(segment.subpathStartSegment.end)) {
            const convertedSegment = _Path.createSegment("L", originalSegment.end);
            pathCopy.replaceSegment(i, convertedSegment);
          }
        }
        const firstPath = new _Path(pathCopy.segments.slice(0, divisionMidIndex));
        const secondPath = new _Path(pathCopy.segments.slice(divisionMidIndex));
        return [firstPath, secondPath];
      }
      intersectsWithLine(line, options = {}) {
        const polylines = this.toPolylines(options);
        if (polylines == null) {
          return null;
        }
        let intersections = null;
        for (let i = 0, ii = polylines.length; i < ii; i += 1) {
          const polyline = polylines[i];
          const intersection = line.intersect(polyline);
          if (intersection) {
            if (intersections == null) {
              intersections = [];
            }
            if (Array.isArray(intersection)) {
              intersections.push(...intersection);
            } else {
              intersections.push(intersection);
            }
          }
        }
        return intersections;
      }
      isDifferentiable() {
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const segment = this.segments[i];
          if (segment.isDifferentiable()) {
            return true;
          }
        }
        return false;
      }
      isValid() {
        const segments = this.segments;
        const isValid2 = segments.length === 0 || segments[0].type === "M";
        return isValid2;
      }
      length(options = {}) {
        if (this.segments.length === 0) {
          return 0;
        }
        const segmentSubdivisions = this.getSubdivisions(options);
        let length = 0;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const segment = this.segments[i];
          const subdivisions = segmentSubdivisions[i];
          length += segment.length({ subdivisions });
        }
        return length;
      }
      lengthAtT(t, options = {}) {
        const count = this.segments.length;
        if (count === 0) {
          return 0;
        }
        let segmentIndex = t.segmentIndex;
        if (segmentIndex < 0) {
          return 0;
        }
        let tValue = GeometryUtil.clamp(t.value, 0, 1);
        if (segmentIndex >= count) {
          segmentIndex = count - 1;
          tValue = 1;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let length = 0;
        for (let i = 0; i < segmentIndex; i += 1) {
          const segment2 = this.segments[i];
          const subdivisions2 = segmentSubdivisions[i];
          length += segment2.length({ precision, subdivisions: subdivisions2 });
        }
        const segment = this.segments[segmentIndex];
        const subdivisions = segmentSubdivisions[segmentIndex];
        length += segment.lengthAtT(tValue, { precision, subdivisions });
        return length;
      }
      tangentAt(ratio, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        const rate = GeometryUtil.clamp(ratio, 0, 1);
        const opts = this.getOptions(options);
        const len = this.length(opts);
        const length = len * rate;
        return this.tangentAtLength(length, opts);
      }
      tangentAtLength(length, options = {}) {
        if (this.segments.length === 0) {
          return null;
        }
        let fromStart = true;
        if (length < 0) {
          fromStart = false;
          length = -length;
        }
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        let lastValidSegment;
        let memo = 0;
        for (let i = 0, ii = this.segments.length; i < ii; i += 1) {
          const index2 = fromStart ? i : ii - 1 - i;
          const segment = this.segments[index2];
          const subdivisions = segmentSubdivisions[index2];
          const len = segment.length({ precision, subdivisions });
          if (segment.isDifferentiable()) {
            if (length <= memo + len) {
              return segment.tangentAtLength((fromStart ? 1 : -1) * (length - memo), {
                precision,
                subdivisions
              });
            }
            lastValidSegment = segment;
          }
          memo += len;
        }
        if (lastValidSegment) {
          const t = fromStart ? 1 : 0;
          return lastValidSegment.tangentAtT(t);
        }
        return null;
      }
      tangentAtT(t) {
        const count = this.segments.length;
        if (count === 0) {
          return null;
        }
        const segmentIndex = t.segmentIndex;
        if (segmentIndex < 0) {
          return this.segments[0].tangentAtT(0);
        }
        if (segmentIndex >= count) {
          return this.segments[count - 1].tangentAtT(1);
        }
        const tValue = GeometryUtil.clamp(t.value, 0, 1);
        return this.segments[segmentIndex].tangentAtT(tValue);
      }
      getPrecision(options = {}) {
        return options.precision == null ? this.PRECISION : options.precision;
      }
      getSubdivisions(options = {}) {
        if (options.segmentSubdivisions == null) {
          const precision = this.getPrecision(options);
          return this.getSegmentSubdivisions({ precision });
        }
        return options.segmentSubdivisions;
      }
      getOptions(options = {}) {
        const precision = this.getPrecision(options);
        const segmentSubdivisions = this.getSubdivisions(options);
        return { precision, segmentSubdivisions };
      }
      toPoints(options = {}) {
        const segments = this.segments;
        const count = segments.length;
        if (count === 0) {
          return null;
        }
        const segmentSubdivisions = this.getSubdivisions(options);
        const points = [];
        let partialPoints = [];
        for (let i = 0; i < count; i += 1) {
          const segment = segments[i];
          if (segment.isVisible) {
            const divisions = segmentSubdivisions[i];
            if (divisions.length > 0) {
              divisions.forEach((c) => partialPoints.push(c.start));
            } else {
              partialPoints.push(segment.start);
            }
          } else if (partialPoints.length > 0) {
            partialPoints.push(segments[i - 1].end);
            points.push(partialPoints);
            partialPoints = [];
          }
        }
        if (partialPoints.length > 0) {
          partialPoints.push(this.end);
          points.push(partialPoints);
        }
        return points;
      }
      toPolylines(options = {}) {
        const points = this.toPoints(options);
        if (!points) {
          return null;
        }
        return points.map((arr) => new Polyline(arr));
      }
      scale(sx, sy, origin) {
        this.segments.forEach((s) => s.scale(sx, sy, origin));
        return this;
      }
      rotate(angle, origin) {
        this.segments.forEach((segment) => segment.rotate(angle, origin));
        return this;
      }
      translate(tx, ty) {
        if (typeof tx === "number") {
          this.segments.forEach((s) => s.translate(tx, ty));
        } else {
          this.segments.forEach((s) => s.translate(tx));
        }
        return this;
      }
      clone() {
        const path = new _Path();
        this.segments.forEach((s) => path.appendSegment(s.clone()));
        return path;
      }
      equals(p) {
        if (p == null) {
          return false;
        }
        const segments = this.segments;
        const otherSegments = p.segments;
        const count = segments.length;
        if (otherSegments.length !== count) {
          return false;
        }
        for (let i = 0; i < count; i += 1) {
          const a = segments[i];
          const b = otherSegments[i];
          if (a.type !== b.type || !a.equals(b)) {
            return false;
          }
        }
        return true;
      }
      toJSON() {
        return this.segments.map((s) => s.toJSON());
      }
      serialize() {
        if (!this.isValid()) {
          throw new Error("Invalid path segments.");
        }
        return this.segments.map((s) => s.serialize()).join(" ");
      }
      toString() {
        return this.serialize();
      }
    };
    (function(Path2) {
      function isPath(instance) {
        return instance != null && instance instanceof Path2;
      }
      Path2.isPath = isPath;
    })(Path || (Path = {}));
    (function(Path2) {
      function parse2(pathData) {
        if (!pathData) {
          return new Path2();
        }
        const path = new Path2();
        const commandRe = /(?:[a-zA-Z] *)(?:(?:-?\d+(?:\.\d+)?(?:e[-+]?\d+)? *,? *)|(?:-?\.\d+ *,? *))+|(?:[a-zA-Z] *)(?! |\d|-|\.)/g;
        const commands = Path2.normalize(pathData).match(commandRe);
        if (commands != null) {
          for (let i = 0, ii = commands.length; i < ii; i += 1) {
            const command = commands[i];
            const argRe = /(?:[a-zA-Z])|(?:(?:-?\d+(?:\.\d+)?(?:e[-+]?\d+)?))|(?:(?:-?\.\d+))/g;
            const args = command.match(argRe);
            if (args != null) {
              const type = args[0];
              const coords = args.slice(1).map((a) => +a);
              const segment = createSegment.call(null, type, ...coords);
              path.appendSegment(segment);
            }
          }
        }
        return path;
      }
      Path2.parse = parse2;
      function createSegment(type, ...args) {
        if (type === "M") {
          return MoveTo.create.call(null, ...args);
        }
        if (type === "L") {
          return LineTo.create.call(null, ...args);
        }
        if (type === "C") {
          return CurveTo.create.call(null, ...args);
        }
        if (type === "z" || type === "Z") {
          return Close.create();
        }
        throw new Error(`Invalid path segment type "${type}"`);
      }
      Path2.createSegment = createSegment;
    })(Path || (Path = {}));
    (function(Path2) {
      Path2.normalize = normalizePathData;
      Path2.isValid = isValid;
      Path2.drawArc = drawArc;
      Path2.drawPoints = drawPoints;
      Path2.arcToCurves = arcToCurves;
    })(Path || (Path = {}));
  }
});

// node_modules/@antv/x6-geometry/es/path/index.js
var init_path3 = __esm({
  "node_modules/@antv/x6-geometry/es/path/index.js"() {
    init_path2();
    init_segment();
    init_normalize();
  }
});

// node_modules/@antv/x6-geometry/es/index.js
var es_exports2 = {};
__export(es_exports2, {
  Angle: () => Angle,
  Curve: () => Curve,
  Ellipse: () => Ellipse,
  GeometryUtil: () => GeometryUtil,
  Line: () => Line,
  Path: () => Path,
  Point: () => Point,
  Polyline: () => Polyline,
  Rectangle: () => Rectangle,
  Segment: () => Segment,
  normalizePathData: () => normalizePathData
});
var init_es2 = __esm({
  "node_modules/@antv/x6-geometry/es/index.js"() {
    init_angle();
    init_point();
    init_line();
    init_ellipse();
    init_rectangle();
    init_path3();
    init_curve();
    init_polyline();
    init_util4();
  }
});

export {
  Disposable,
  DisposableDelegate,
  DisposableSet,
  main_exports,
  Events,
  object_exports,
  Basecoat,
  Disablable,
  array_exports,
  string_exports,
  number_exports,
  Platform,
  main_exports2,
  DataUri,
  Unit,
  Vector,
  main_exports3,
  SizeSensor,
  PriorityQueue,
  Dijkstra,
  Color,
  Dictionary,
  ModifierKey,
  Timing,
  Interp,
  loader_exports,
  es_exports,
  init_es,
  Angle,
  GeometryUtil,
  Point,
  Rectangle,
  Line,
  Ellipse,
  Polyline,
  Curve,
  Segment,
  normalizePathData,
  Path,
  es_exports2,
  init_es2
};
//# sourceMappingURL=chunk-JJ4XOBWH.js.map