@formily-design/shared 1.0.0

package/dist/designable.shared.umd.production.min.js

@@ -0,0 +1,2051 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Designable = global.Designable || {}, global.Designable.Shared = {})));
+})(this, (function (exports) { 'use strict';
+
+  const isType = (type) => (obj) => obj != null &&
+      (Array.isArray(type) ? type : [type]).some((t) => getType(obj) === `[object ${t}]`);
+  const getType = (obj) => Object.prototype.toString.call(obj);
+  const isFn = isType([
+      'Function',
+      'AsyncFunction',
+      'GeneratorFunction',
+  ]);
+  const isWindow = isType('Window');
+  const isHTMLElement = (obj) => {
+      return (obj === null || obj === void 0 ? void 0 : obj['nodeName']) || (obj === null || obj === void 0 ? void 0 : obj['tagName']);
+  };
+  const isArr = Array.isArray;
+  const isPlainObj = isType('Object');
+  const isStr = isType('String');
+  const isBool = isType('Boolean');
+  const isNum = isType('Number');
+  const isObj = (val) => typeof val === 'object';
+  const isRegExp = isType('RegExp');
+  const isValid = (val) => val !== null && val !== undefined;
+  const isValidNumber = (val) => !isNaN(val) && isNum(val);
+
+  const UNSUBSCRIBE_ID_SYMBOL = Symbol('UNSUBSCRIBE_ID_SYMBOL');
+  class Subscribable {
+      constructor() {
+          this.subscribers = {
+              index: 0,
+          };
+          this.unsubscribe = (id) => {
+              if (id === undefined || id === null) {
+                  for (const key in this.subscribers) {
+                      this.unsubscribe(key);
+                  }
+                  return;
+              }
+              if (!isFn(id)) {
+                  delete this.subscribers[id];
+              }
+              else {
+                  delete this.subscribers[id[UNSUBSCRIBE_ID_SYMBOL]];
+              }
+          };
+      }
+      dispatch(event, context) {
+          let interrupted = false;
+          for (const key in this.subscribers) {
+              if (isFn(this.subscribers[key])) {
+                  event['context'] = context;
+                  if (this.subscribers[key](event) === false) {
+                      interrupted = true;
+                  }
+              }
+          }
+          return interrupted ? false : true;
+      }
+      subscribe(subscriber) {
+          let id;
+          if (isFn(subscriber)) {
+              id = this.subscribers.index + 1;
+              this.subscribers[id] = subscriber;
+              this.subscribers.index++;
+          }
+          const unsubscribe = () => {
+              this.unsubscribe(id);
+          };
+          unsubscribe[UNSUBSCRIBE_ID_SYMBOL] = id;
+          return unsubscribe;
+      }
+  }
+
+  function getGlobalThis() {
+      try {
+          if (typeof self !== 'undefined') {
+              return self;
+          }
+      }
+      catch (e) { }
+      try {
+          if (typeof globalThisPolyfill !== 'undefined') {
+              return globalThisPolyfill;
+          }
+      }
+      catch (e) { }
+      try {
+          if (typeof global !== 'undefined') {
+              return global;
+          }
+      }
+      catch (e) { }
+      return Function('return this')();
+  }
+  const globalThisPolyfill = getGlobalThis();
+
+  const ATTACHED_SYMBOL = Symbol('ATTACHED_SYMBOL');
+  const EVENTS_SYMBOL = Symbol('__EVENTS_SYMBOL__');
+  const EVENTS_ONCE_SYMBOL = Symbol('EVENTS_ONCE_SYMBOL');
+  const EVENTS_BATCH_SYMBOL = Symbol('EVENTS_BATCH_SYMBOL');
+  const DRIVER_INSTANCES_SYMBOL = Symbol('DRIVER_INSTANCES_SYMBOL');
+  const isOnlyMode = (mode) => mode === 'onlyOne' || mode === 'onlyChild' || mode === 'onlyParent';
+  /**
+   * 事件驱动器基类
+   */
+  class EventDriver {
+      constructor(engine, context) {
+          this.container = document;
+          this.contentWindow = globalThisPolyfill;
+          this.engine = engine;
+          this.context = context;
+      }
+      dispatch(event) {
+          return this.engine.dispatch(event, this.context);
+      }
+      subscribe(subscriber) {
+          return this.engine.subscribe(subscriber);
+      }
+      subscribeTo(type, subscriber) {
+          return this.engine.subscribeTo(type, subscriber);
+      }
+      subscribeWith(type, subscriber) {
+          return this.engine.subscribeWith(type, subscriber);
+      }
+      attach(container) {
+          console.error('attach must implement.');
+      }
+      detach(container) {
+          console.error('attach must implement.');
+      }
+      eventTarget(type) {
+          var _a;
+          if (type === 'resize' || type === 'scroll') {
+              if (this.container === ((_a = this.contentWindow) === null || _a === void 0 ? void 0 : _a.document)) {
+                  return this.contentWindow;
+              }
+          }
+          return this.container;
+      }
+      addEventListener(type, listener, options) {
+          var _a, _b, _c, _d;
+          const target = this.eventTarget(type);
+          if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+              target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+              const constructor = this['constructor'];
+              constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+              const handler = target[EVENTS_ONCE_SYMBOL][type];
+              const container = constructor[EVENTS_ONCE_SYMBOL][type];
+              if (!handler) {
+                  if (container) {
+                      if (options.mode === 'onlyChild') {
+                          if (container.contains(target)) {
+                              container.removeEventListener(type, container[EVENTS_ONCE_SYMBOL][type], options);
+                              delete container[EVENTS_ONCE_SYMBOL][type];
+                          }
+                      }
+                      else if (options.mode === 'onlyParent') {
+                          if (container.contains(target))
+                              return;
+                      }
+                  }
+                  target.addEventListener(type, listener, options);
+                  target[EVENTS_ONCE_SYMBOL][type] = listener;
+                  constructor[EVENTS_ONCE_SYMBOL][type] = target;
+              }
+          }
+          else {
+              target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+              target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+              if (!((_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, listener))) {
+                  target.addEventListener(type, listener, options);
+                  (_d = (_c = target[EVENTS_SYMBOL][type]) === null || _c === void 0 ? void 0 : _c.set) === null || _d === void 0 ? void 0 : _d.call(_c, listener, true);
+              }
+          }
+      }
+      removeEventListener(type, listener, options) {
+          var _a, _b;
+          const target = this.eventTarget(type);
+          if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+              const constructor = this['constructor'];
+              constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+              target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+              delete constructor[EVENTS_ONCE_SYMBOL][type];
+              delete target[EVENTS_ONCE_SYMBOL][type];
+              target.removeEventListener(type, listener, options);
+          }
+          else {
+              target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+              target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+              (_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.delete) === null || _b === void 0 ? void 0 : _b.call(_a, listener);
+              target.removeEventListener(type, listener, options);
+          }
+      }
+      batchAddEventListener(type, listener, options) {
+          this.engine[DRIVER_INSTANCES_SYMBOL] =
+              this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+          if (!this.engine[DRIVER_INSTANCES_SYMBOL].includes(this)) {
+              this.engine[DRIVER_INSTANCES_SYMBOL].push(this);
+          }
+          this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+              const target = driver.eventTarget(type);
+              target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+              if (!target[EVENTS_BATCH_SYMBOL][type]) {
+                  target.addEventListener(type, listener, options);
+                  target[EVENTS_BATCH_SYMBOL][type] = listener;
+              }
+          });
+      }
+      batchRemoveEventListener(type, listener, options) {
+          this.engine[DRIVER_INSTANCES_SYMBOL] =
+              this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+          this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+              const target = driver.eventTarget(type);
+              target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+              target.removeEventListener(type, listener, options);
+              delete target[EVENTS_BATCH_SYMBOL][type];
+          });
+      }
+  }
+  /**
+   * 事件引擎
+   */
+  class Event extends Subscribable {
+      constructor(props) {
+          super();
+          this.drivers = [];
+          this.containers = [];
+          if (isArr(props === null || props === void 0 ? void 0 : props.effects)) {
+              props.effects.forEach((plugin) => {
+                  plugin(this);
+              });
+          }
+          if (isArr(props === null || props === void 0 ? void 0 : props.drivers)) {
+              this.drivers = props.drivers;
+          }
+      }
+      subscribeTo(type, subscriber) {
+          return this.subscribe((event) => {
+              if (type && event instanceof type) {
+                  return subscriber(event);
+              }
+          });
+      }
+      subscribeWith(type, subscriber) {
+          return this.subscribe((event) => {
+              if (isArr(type)) {
+                  if (type.includes(event === null || event === void 0 ? void 0 : event.type)) {
+                      return subscriber(event);
+                  }
+              }
+              else {
+                  if (type && (event === null || event === void 0 ? void 0 : event.type) === type) {
+                      return subscriber(event);
+                  }
+              }
+          });
+      }
+      attachEvents(container, contentWindow = globalThisPolyfill, context) {
+          if (!container)
+              return;
+          if (isWindow(container)) {
+              return this.attachEvents(container.document, container, context);
+          }
+          if (container[ATTACHED_SYMBOL])
+              return;
+          container[ATTACHED_SYMBOL] = this.drivers.map((EventDriver) => {
+              const driver = new EventDriver(this, context);
+              driver.contentWindow = contentWindow;
+              driver.container = container;
+              driver.attach(container);
+              return driver;
+          });
+          if (!this.containers.includes(container)) {
+              this.containers.push(container);
+          }
+      }
+      detachEvents(container) {
+          if (!container) {
+              this.containers.forEach((container) => {
+                  this.detachEvents(container);
+              });
+              return;
+          }
+          if (isWindow(container)) {
+              return this.detachEvents(container.document);
+          }
+          if (!container[ATTACHED_SYMBOL])
+              return;
+          container[ATTACHED_SYMBOL].forEach((driver) => {
+              driver.detach(container);
+          });
+          this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL] || [];
+          this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL].reduce((drivers, driver) => {
+              if (driver.container === container) {
+                  driver.detach(container);
+                  return drivers;
+              }
+              return drivers.concat(driver);
+          }, []);
+          this.containers = this.containers.filter((item) => item !== container);
+          delete container[ATTACHED_SYMBOL];
+          delete container[EVENTS_SYMBOL];
+          delete container[EVENTS_ONCE_SYMBOL];
+          delete container[EVENTS_BATCH_SYMBOL];
+      }
+  }
+
+  const createUniformSpeedAnimation = (speed = 10, callback) => {
+      let request = null;
+      let startTime = null;
+      const start = () => {
+          if (request)
+              return;
+          request = requestAnimationFrame((timestamp) => {
+              if (startTime === null) {
+                  startTime = timestamp;
+              }
+              const deltaTime = timestamp - startTime;
+              const delta = (deltaTime / 1000) * speed;
+              callback(delta);
+              request = null;
+              start();
+          });
+      };
+      start();
+      return () => {
+          if (request) {
+              cancelAnimationFrame(request);
+              request = null;
+          }
+          startTime = null;
+      };
+  };
+  //越接近阈值，速度越小，越远离阈值，速度越大
+  const calcSpeedFactor = (delta = 0, threshold = Infinity) => {
+      if (threshold >= delta) {
+          return (threshold - delta) / threshold;
+      }
+      return 0;
+  };
+
+  const MAX_SPEED = 80; // px/s
+  const calcAutoScrollBasicInfo = (point, axis, viewport, maxSpeed = MAX_SPEED) => {
+      const { left, right, top, bottom } = viewport;
+      const { x, y } = point;
+      let begin;
+      let end;
+      let pos;
+      let speedFactor;
+      if (axis === 'x') {
+          begin = left;
+          end = right;
+          pos = x;
+      }
+      else {
+          begin = top;
+          end = bottom;
+          pos = y;
+      }
+      const scrollerSize = end - begin;
+      const moveDistance = scrollerSize > 400 ? 100 : scrollerSize / 3;
+      if (end - pos < moveDistance) {
+          return {
+              direction: 'end',
+              speedFactor,
+              speed: maxSpeed * calcSpeedFactor(end - pos, moveDistance),
+          };
+      }
+      else if (pos - begin < moveDistance) {
+          return {
+              direction: 'begin',
+              speedFactor,
+              speed: maxSpeed * calcSpeedFactor(pos - begin, moveDistance),
+          };
+      }
+      return null;
+  };
+  const updateScrollValue = (element, axis, value, callback) => {
+      if (element) {
+          if (!isWindow(element)) {
+              if (axis === 'x') {
+                  if (element.scrollLeft + value > element.scrollWidth)
+                      return;
+                  element.scrollLeft += value;
+                  if (isFn(callback)) {
+                      callback(element.scrollLeft);
+                  }
+              }
+              else {
+                  if (element.scrollTop + value > element.scrollHeight)
+                      return;
+                  element.scrollTop += value;
+                  if (isFn(callback)) {
+                      callback(element.scrollTop);
+                  }
+              }
+          }
+          else {
+              if (axis === 'x') {
+                  element.scrollBy({
+                      left: value,
+                      behavior: 'smooth',
+                  });
+              }
+              else {
+                  element.scrollBy({
+                      top: value,
+                      behavior: 'smooth',
+                  });
+              }
+              if (isFn(callback)) {
+                  callback(value);
+              }
+          }
+      }
+  };
+  const scrollAnimate = (element, axis, direction, speed, callback) => {
+      return createUniformSpeedAnimation(speed, (delta) => {
+          updateScrollValue(element, axis, direction === 'begin' ? 0 - delta : delta, callback);
+      });
+  };
+
+  function isRect(rect) {
+      return (rect === null || rect === void 0 ? void 0 : rect.x) && (rect === null || rect === void 0 ? void 0 : rect.y) && (rect === null || rect === void 0 ? void 0 : rect.width) && (rect === null || rect === void 0 ? void 0 : rect.height);
+  }
+  function isPoint(val) {
+      return isValidNumber(val === null || val === void 0 ? void 0 : val.x) && isValidNumber(val === null || val === void 0 ? void 0 : val.y);
+  }
+  function isLineSegment(val) {
+      return isPoint(val === null || val === void 0 ? void 0 : val.start) && isPoint(val === null || val === void 0 ? void 0 : val.end);
+  }
+  class Point {
+      constructor(x, y) {
+          this.x = x;
+          this.y = y;
+      }
+  }
+  class Rect {
+      constructor(x, y, width, height) {
+          this.x = 0;
+          this.y = 0;
+          this.width = 0;
+          this.height = 0;
+          this.x = x;
+          this.y = y;
+          this.width = width;
+          this.height = height;
+      }
+      get left() {
+          return this.x;
+      }
+      get right() {
+          return this.x + this.width;
+      }
+      get top() {
+          return this.y;
+      }
+      get bottom() {
+          return this.y + this.height;
+      }
+  }
+  class LineSegment {
+      constructor(start, end) {
+          this.start = { ...start };
+          this.end = { ...end };
+      }
+  }
+  exports.RectQuadrant = void 0;
+  (function (RectQuadrant) {
+      RectQuadrant["Inner1"] = "I1";
+      RectQuadrant["Inner2"] = "I2";
+      RectQuadrant["Inner3"] = "I3";
+      RectQuadrant["Inner4"] = "I4";
+      RectQuadrant["Outer1"] = "O1";
+      RectQuadrant["Outer2"] = "O2";
+      RectQuadrant["Outer3"] = "O3";
+      RectQuadrant["Outer4"] = "O4";
+  })(exports.RectQuadrant || (exports.RectQuadrant = {}));
+  function isPointInRect(point, rect, sensitive = true) {
+      const boundSensor = (value) => {
+          if (!sensitive)
+              return 0;
+          const sensor = value * 0.1;
+          if (sensor > 20)
+              return 20;
+          if (sensor < 10)
+              return 10;
+          return sensor;
+      };
+      return (point.x >= rect.x + boundSensor(rect.width) &&
+          point.x <= rect.x + rect.width - boundSensor(rect.width) &&
+          point.y >= rect.y + boundSensor(rect.height) &&
+          point.y <= rect.y + rect.height - boundSensor(rect.height));
+  }
+  function isEqualRect(target, source) {
+      return ((target === null || target === void 0 ? void 0 : target.x) === (source === null || source === void 0 ? void 0 : source.x) &&
+          target.y === source.y &&
+          target.width === source.width &&
+          target.height === source.height);
+  }
+  function getRectPoints(source) {
+      const p1 = new Point(source.x, source.y);
+      const p2 = new Point(source.x + source.width, source.y);
+      const p3 = new Point(source.x + source.width, source.y + source.height);
+      const p4 = new Point(source.x, source.y + source.height);
+      return [p1, p2, p3, p4];
+  }
+  function isRectInRect(target, source) {
+      const [p1, p2, p3, p4] = getRectPoints(target);
+      return (isPointInRect(p1, source, false) &&
+          isPointInRect(p2, source, false) &&
+          isPointInRect(p3, source, false) &&
+          isPointInRect(p4, source, false));
+  }
+  function isCrossRectInRect(target, source) {
+      const targetCenterPoint = new Point(target.x + target.width / 2, target.y + target.height / 2);
+      const sourceCenterPoint = new Point(source.x + source.width / 2, source.y + source.height / 2);
+      return (Math.abs(targetCenterPoint.x - sourceCenterPoint.x) <=
+          target.width / 2 + source.width / 2 &&
+          Math.abs(targetCenterPoint.y - sourceCenterPoint.y) <=
+              target.height / 2 + source.height / 2);
+  }
+  /**
+   * 计算点在矩形的哪个象限
+   * @param point
+   * @param rect
+   */
+  function calcQuadrantOfPointToRect(point, rect) {
+      const isInner = isPointInRect(point, rect);
+      if (point.x <= rect.x + rect.width / 2) {
+          if (point.y <= rect.y + rect.height / 2) {
+              if (isInner) {
+                  return exports.RectQuadrant.Inner1;
+              }
+              else {
+                  return exports.RectQuadrant.Outer1;
+              }
+          }
+          else {
+              if (isInner) {
+                  return exports.RectQuadrant.Inner4;
+              }
+              else {
+                  return exports.RectQuadrant.Outer4;
+              }
+          }
+      }
+      else {
+          if (point.y <= rect.y + rect.height / 2) {
+              if (isInner) {
+                  return exports.RectQuadrant.Inner2;
+              }
+              else {
+                  return exports.RectQuadrant.Outer2;
+              }
+          }
+          else {
+              if (isInner) {
+                  return exports.RectQuadrant.Inner3;
+              }
+              else {
+                  return exports.RectQuadrant.Outer3;
+              }
+          }
+      }
+  }
+  function calcDistanceOfPointToRect(point, rect) {
+      let minX = Math.min(Math.abs(point.x - rect.x), Math.abs(point.x - (rect.x + rect.width)));
+      let minY = Math.min(Math.abs(point.y - rect.y), Math.abs(point.y - (rect.y + rect.height)));
+      if (point.x >= rect.x && point.x <= rect.x + rect.width) {
+          minX = 0;
+      }
+      if (point.y >= rect.y && point.y <= rect.y + rect.height) {
+          minY = 0;
+      }
+      return Math.sqrt(minX ** 2 + minY ** 2);
+  }
+  function calcDistancePointToEdge(point, rect) {
+      const distanceTop = Math.abs(point.y - rect.y);
+      const distanceBottom = Math.abs(point.y - (rect.y + rect.height));
+      const distanceLeft = Math.abs(point.x - rect.x);
+      const distanceRight = Math.abs(point.x - (rect.x + rect.width));
+      return Math.min(distanceTop, distanceBottom, distanceLeft, distanceRight);
+  }
+  function isNearAfter(point, rect, inline = false) {
+      if (inline) {
+          return (Math.abs(point.x - rect.x) + Math.abs(point.y - rect.y) >
+              Math.abs(point.x - (rect.x + rect.width)) +
+                  Math.abs(point.y - (rect.y + rect.height)));
+      }
+      return Math.abs(point.y - rect.y) > Math.abs(point.y - (rect.y + rect.height));
+  }
+  /**
+   * 计算点鱼矩形的相对位置信息
+   * @param point
+   * @param rect
+   */
+  function calcRelativeOfPointToRect(point, rect) {
+      const distance = calcDistanceOfPointToRect(point, rect);
+      const quadrant = calcQuadrantOfPointToRect(point, rect);
+      return {
+          quadrant,
+          distance,
+      };
+  }
+  function calcBoundingRect(rects) {
+      if (!(rects === null || rects === void 0 ? void 0 : rects.length))
+          return;
+      if ((rects === null || rects === void 0 ? void 0 : rects.length) === 1 && !rects[0])
+          return;
+      let minTop = Infinity;
+      let maxBottom = -Infinity;
+      let minLeft = Infinity;
+      let maxRight = -Infinity;
+      rects.forEach((item) => {
+          const rect = new Rect(item.x, item.y, item.width, item.height);
+          if (rect.top <= minTop) {
+              minTop = rect.top;
+          }
+          if (rect.bottom >= maxBottom) {
+              maxBottom = rect.bottom;
+          }
+          if (rect.left <= minLeft) {
+              minLeft = rect.left;
+          }
+          if (rect.right >= maxRight) {
+              maxRight = rect.right;
+          }
+      });
+      return new Rect(minLeft, minTop, maxRight - minLeft, maxBottom - minTop);
+  }
+  function calcRectByStartEndPoint(startPoint, endPoint, scrollX = 0, scrollY = 0) {
+      let drawStartX = 0, drawStartY = 0;
+      if (endPoint.x + scrollX >= startPoint.x &&
+          endPoint.y + scrollY >= startPoint.y) {
+          //4象限
+          drawStartX = startPoint.x;
+          drawStartY = startPoint.y;
+          return new Rect(drawStartX - scrollX, drawStartY - scrollY, Math.abs(endPoint.x - startPoint.x + scrollX), Math.abs(endPoint.y - startPoint.y + scrollY));
+      }
+      else if (endPoint.x + scrollX < startPoint.x &&
+          endPoint.y + scrollY < startPoint.y) {
+          //1象限
+          drawStartX = endPoint.x;
+          drawStartY = endPoint.y;
+          return new Rect(drawStartX, drawStartY, Math.abs(endPoint.x - startPoint.x + scrollX), Math.abs(endPoint.y - startPoint.y + scrollY));
+      }
+      else if (endPoint.x + scrollX < startPoint.x &&
+          endPoint.y + scrollY >= startPoint.y) {
+          //3象限
+          drawStartX = endPoint.x;
+          drawStartY = startPoint.y;
+          return new Rect(drawStartX - scrollX, drawStartY - scrollY, Math.abs(endPoint.x - startPoint.x + scrollX), Math.abs(endPoint.y - startPoint.y + scrollY));
+      }
+      else {
+          //2象限
+          drawStartX = startPoint.x;
+          drawStartY = endPoint.y;
+          return new Rect(drawStartX, drawStartY, Math.abs(endPoint.x - startPoint.x + scrollX), Math.abs(endPoint.y - startPoint.y + scrollY));
+      }
+  }
+  function calcEdgeLinesOfRect(rect) {
+      return {
+          v: [
+              new LineSegment(new Point(rect.x, rect.y), new Point(rect.x, rect.y + rect.height)),
+              new LineSegment(new Point(rect.x + rect.width / 2, rect.y), new Point(rect.x + rect.width / 2, rect.y + rect.height)),
+              new LineSegment(new Point(rect.x + rect.width, rect.y), new Point(rect.x + rect.width, rect.y + rect.height)),
+          ],
+          h: [
+              new LineSegment(new Point(rect.x, rect.y), new Point(rect.x + rect.width, rect.y)),
+              new LineSegment(new Point(rect.x, rect.y + rect.height / 2), new Point(rect.x + rect.width, rect.y + rect.height / 2)),
+              new LineSegment(new Point(rect.x, rect.y + rect.height), new Point(rect.x + rect.width, rect.y + rect.height)),
+          ],
+      };
+  }
+  function calcRectOfAxisLineSegment(line) {
+      if (!isLineSegment(line))
+          return;
+      const isXAxis = line.start.x === line.end.x;
+      return new Rect(line.start.x, line.start.y, isXAxis ? 0 : line.end.x - line.start.x, isXAxis ? line.end.y - line.start.y : 0);
+  }
+  function calcSpaceBlockOfRect(target, source, type) {
+      const targetRect = new Rect(target.x, target.y, target.width, target.height);
+      const sourceRect = new Rect(source.x, source.y, source.width, source.height);
+      if (sourceRect.bottom < targetRect.top && sourceRect.left > targetRect.right)
+          return;
+      if (sourceRect.top > targetRect.bottom && sourceRect.left > targetRect.right)
+          return;
+      if (sourceRect.bottom < targetRect.top && sourceRect.right < targetRect.left)
+          return;
+      if (sourceRect.top > targetRect.bottom && sourceRect.right < targetRect.left)
+          return;
+      if (sourceRect.bottom < targetRect.top) {
+          const distance = targetRect.top - sourceRect.bottom;
+          const left = Math.min(sourceRect.left, targetRect.left);
+          const right = Math.max(sourceRect.right, targetRect.right);
+          if (type && type !== 'top')
+              return;
+          return {
+              type: 'top',
+              distance,
+              rect: new Rect(left, sourceRect.bottom, right - left, distance),
+          };
+      }
+      else if (sourceRect.top > targetRect.bottom) {
+          const distance = sourceRect.top - targetRect.bottom;
+          const left = Math.min(sourceRect.left, targetRect.left);
+          const right = Math.max(sourceRect.right, targetRect.right);
+          if (type && type !== 'bottom')
+              return;
+          return {
+              type: 'bottom',
+              distance,
+              rect: new Rect(left, targetRect.bottom, right - left, distance),
+          };
+      }
+      else if (sourceRect.right < targetRect.left) {
+          const distance = targetRect.left - sourceRect.right;
+          const top = Math.min(sourceRect.top, targetRect.top);
+          const bottom = Math.max(sourceRect.bottom, targetRect.bottom);
+          if (type && type !== 'left')
+              return;
+          return {
+              type: 'left',
+              distance,
+              rect: new Rect(sourceRect.right, top, distance, bottom - top),
+          };
+      }
+      else if (sourceRect.left > targetRect.right) {
+          const distance = sourceRect.left - targetRect.right;
+          const top = Math.min(sourceRect.top, targetRect.top);
+          const bottom = Math.max(sourceRect.bottom, targetRect.bottom);
+          if (type && type !== 'right')
+              return;
+          return {
+              type: 'right',
+              distance,
+              rect: new Rect(targetRect.right, top, distance, bottom - top),
+          };
+      }
+  }
+  function calcExtendsLineSegmentOfRect(targetRect, referRect) {
+      if (referRect.right < targetRect.right &&
+          targetRect.left <= referRect.right) {
+          //右侧
+          if (referRect.bottom < targetRect.top) {
+              //上方
+              return {
+                  start: { x: referRect.right, y: referRect.bottom },
+                  end: { x: targetRect.right, y: referRect.bottom },
+              };
+          }
+          else if (referRect.top > targetRect.bottom) {
+              //下方
+              return {
+                  start: { x: referRect.right, y: referRect.top },
+                  end: { x: targetRect.right, y: referRect.top },
+              };
+          }
+      }
+      else if (referRect.left > targetRect.left &&
+          targetRect.right >= referRect.left) {
+          //左侧
+          if (referRect.bottom < targetRect.top) {
+              //上方
+              return {
+                  start: { x: targetRect.left, y: referRect.bottom },
+                  end: { x: referRect.left, y: referRect.bottom },
+              };
+          }
+          else if (referRect.top > targetRect.bottom) {
+              //下方
+              return {
+                  start: { x: targetRect.left, y: referRect.top },
+                  end: { x: referRect.left, y: referRect.top },
+              };
+          }
+      }
+      if (referRect.top < targetRect.top && targetRect.bottom >= referRect.top) {
+          //refer在上方
+          if (referRect.right < targetRect.left) {
+              //右侧
+              return {
+                  start: { x: referRect.right, y: referRect.bottom },
+                  end: { x: referRect.right, y: targetRect.bottom },
+              };
+          }
+          else if (referRect.left > targetRect.right) {
+              //左侧
+              return {
+                  start: { x: referRect.left, y: referRect.bottom },
+                  end: { x: referRect.left, y: targetRect.bottom },
+              };
+          }
+      }
+      else if (referRect.bottom > targetRect.bottom &&
+          referRect.top <= targetRect.bottom) {
+          //refer下方
+          if (referRect.right < targetRect.left) {
+              //右侧
+              return {
+                  start: { x: referRect.right, y: targetRect.top },
+                  end: { x: referRect.right, y: referRect.top },
+              };
+          }
+          else if (referRect.left > targetRect.right) {
+              //左侧
+              return {
+                  start: { x: referRect.left, y: targetRect.top },
+                  end: { x: referRect.left, y: referRect.top },
+              };
+          }
+      }
+  }
+  function calcOffsetOfSnapLineSegmentToEdge(line, current) {
+      const edges = calcEdgeLinesOfRect(current);
+      const isVerticalLine = line.start.x === line.end.x;
+      if (isVerticalLine) {
+          return { x: calcMinDistanceValue(edges.x, line.start.x) - current.x, y: 0 };
+      }
+      function calcEdgeLinesOfRect(rect) {
+          return {
+              x: [rect.x, rect.x + rect.width / 2, rect.x + rect.width],
+              y: [rect.y, rect.y + rect.height / 2, rect.y + rect.height],
+          };
+      }
+      function calcMinDistanceValue(edges, targetValue) {
+          let minDistance = Infinity, minDistanceIndex = -1;
+          for (let i = 0; i < edges.length; i++) {
+              const distance = Math.abs(edges[i] - targetValue);
+              if (minDistance > distance) {
+                  minDistance = distance;
+                  minDistanceIndex = i;
+              }
+          }
+          return edges[minDistanceIndex];
+      }
+      return { x: 0, y: calcMinDistanceValue(edges.y, line.start.y) - current.y };
+  }
+  function calcDistanceOfSnapLineToEdges(line, edges) {
+      var _a, _b, _c, _d;
+      let distance = Infinity;
+      if (((_a = line === null || line === void 0 ? void 0 : line.start) === null || _a === void 0 ? void 0 : _a.y) === ((_b = line === null || line === void 0 ? void 0 : line.end) === null || _b === void 0 ? void 0 : _b.y)) {
+          edges.h.forEach((target) => {
+              const _distance = Math.abs(target.start.y - line.start.y);
+              if (_distance < distance) {
+                  distance = _distance;
+              }
+          });
+      }
+      else if (((_c = line === null || line === void 0 ? void 0 : line.start) === null || _c === void 0 ? void 0 : _c.x) === ((_d = line === null || line === void 0 ? void 0 : line.end) === null || _d === void 0 ? void 0 : _d.x)) {
+          edges.v.forEach((target) => {
+              const _distance = Math.abs(target.start.x - line.start.x);
+              if (_distance < distance) {
+                  distance = _distance;
+              }
+          });
+      }
+      else {
+          throw new Error('can not calculate slash distance');
+      }
+      return distance;
+  }
+  function calcCombineSnapLineSegment(target, source) {
+      if (target.start.x === target.end.x) {
+          return new LineSegment(new Point(target.start.x, target.start.y > source.start.y ? source.start.y : target.start.y), new Point(target.start.x, target.end.y > source.end.y ? target.end.y : source.end.y));
+      }
+      return new LineSegment(new Point(target.start.x > source.start.x ? source.start.x : target.start.x, target.start.y), new Point(target.end.x > source.end.x ? target.end.x : source.end.x, target.end.y));
+  }
+  function calcClosestEdges(line, edges) {
+      var _a, _b, _c, _d;
+      let result;
+      let distance = Infinity;
+      if (((_a = line === null || line === void 0 ? void 0 : line.start) === null || _a === void 0 ? void 0 : _a.y) === ((_b = line === null || line === void 0 ? void 0 : line.end) === null || _b === void 0 ? void 0 : _b.y)) {
+          edges.h.forEach((target) => {
+              const _distance = Math.abs(target.start.y - line.start.y);
+              if (_distance < distance) {
+                  distance = _distance;
+                  result = target;
+              }
+          });
+      }
+      else if (((_c = line === null || line === void 0 ? void 0 : line.start) === null || _c === void 0 ? void 0 : _c.x) === ((_d = line === null || line === void 0 ? void 0 : line.end) === null || _d === void 0 ? void 0 : _d.x)) {
+          edges.v.forEach((target) => {
+              const _distance = Math.abs(target.start.x - line.start.x);
+              if (_distance < distance) {
+                  distance = _distance;
+                  result = target;
+              }
+          });
+      }
+      else {
+          throw new Error('can not calculate slash distance');
+      }
+      return [distance, result];
+  }
+
+  let IDX = 36, HEX = '';
+  while (IDX--)
+      HEX += IDX.toString(36);
+  function uid(len) {
+      let str = '', num = len || 11;
+      while (num--)
+          str += HEX[(Math.random() * 36) | 0];
+      return str;
+  }
+
+  const instOf = (value, cls) => {
+      if (isFn(cls))
+          return value instanceof cls;
+      if (isStr(cls))
+          return globalThisPolyfill[cls]
+              ? value instanceof globalThisPolyfill[cls]
+              : false;
+      return false;
+  };
+
+  const NATIVE_KEYS = [
+      ['Map', (map) => new Map(map)],
+      ['WeakMap', (map) => new WeakMap(map)],
+      ['WeakSet', (set) => new WeakSet(set)],
+      ['Set', (set) => new Set(set)],
+      ['Date', (date) => new Date(date)],
+      'FileList',
+      'File',
+      'URL',
+      'RegExp',
+      [
+          'Promise',
+          (promise) => new Promise((resolve, reject) => promise.then(resolve, reject)),
+      ],
+  ];
+  const isNativeObject = (values) => {
+      for (let i = 0; i < NATIVE_KEYS.length; i++) {
+          const item = NATIVE_KEYS[i];
+          if (Array.isArray(item) && item[0]) {
+              if (instOf(values, item[0])) {
+                  return item[1] ? item[1] : item[0];
+              }
+          }
+          else {
+              if (instOf(values, item)) {
+                  return item;
+              }
+          }
+      }
+  };
+  const shallowClone = (values) => {
+      let nativeClone;
+      if (Array.isArray(values)) {
+          return values.slice(0);
+      }
+      else if (isNativeObject(values)) {
+          nativeClone = isNativeObject(values);
+          return isFn(nativeClone) ? nativeClone(values) : values;
+      }
+      else if (typeof values === 'object' && !!values) {
+          return {
+              ...values,
+          };
+      }
+  };
+  const clone = (values, filter) => {
+      let nativeClone;
+      if (Array.isArray(values)) {
+          return values.map((item) => clone(item, filter));
+      }
+      else if (isNativeObject(values)) {
+          nativeClone = isNativeObject(values);
+          return isFn(nativeClone) ? nativeClone(values) : values;
+      }
+      else if (typeof values === 'object' && !!values) {
+          if ('$$typeof' in values && '_owner' in values) {
+              return values;
+          }
+          if (values._isAMomentObject) {
+              return values;
+          }
+          if (values._isJSONSchemaObject) {
+              return values;
+          }
+          if (isFn(values.toJS)) {
+              return values;
+          }
+          if (isFn(values.toJSON)) {
+              return values;
+          }
+          if (Object.getOwnPropertySymbols(values || {}).length) {
+              return values;
+          }
+          const res = {};
+          for (const key in values) {
+              if (Object.hasOwnProperty.call(values, key)) {
+                  if (isFn(filter)) {
+                      if (filter(values[key], key)) {
+                          res[key] = clone(values[key], filter);
+                      }
+                      else {
+                          res[key] = values[key];
+                      }
+                  }
+                  else {
+                      res[key] = clone(values[key], filter);
+                  }
+              }
+          }
+          return res;
+      }
+      else {
+          return values;
+      }
+  };
+
+  /**
+   * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+   * recently used items while discarding least recently used items when its limit
+   * is reached.
+   *
+   * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+   * See README.md for details.
+   *
+   * Illustration of the design:
+   *
+   *       entry             entry             entry             entry
+   *       ______            ______            ______            ______
+   *      | head |.newer => |      |.newer => |      |.newer => | tail |
+   *      |  A   |          |  B   |          |  C   |          |  D   |
+   *      |______| <= older.|______| <= older.|______| <= older.|______|
+   *
+   *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+   */
+  /* eslint-disable */
+  const NEWER = Symbol('newer');
+  const OLDER = Symbol('older');
+  function Entry(key, value) {
+      this.key = key;
+      this.value = value;
+      this[NEWER] = undefined;
+      this[OLDER] = undefined;
+  }
+  class LRUMap {
+      constructor(limit, entries) {
+          if (typeof limit !== 'number') {
+              // called as (entries)
+              entries = limit;
+              limit = 0;
+          }
+          this.size = 0;
+          this.limit = limit;
+          this.oldest = this.newest = undefined;
+          this._keymap = new Map();
+          if (entries) {
+              this.assign(entries);
+              if (limit < 1) {
+                  this.limit = this.size;
+              }
+          }
+      }
+      _markEntryAsUsed(entry) {
+          if (entry === this.newest) {
+              // Already the most recenlty used entry, so no need to update the list
+              return;
+          }
+          // HEAD--------------TAIL
+          //   <.older   .newer>
+          //  <--- add direction --
+          //   A  B  C  <D>  E
+          if (entry[NEWER]) {
+              if (entry === this.oldest) {
+                  this.oldest = entry[NEWER];
+              }
+              entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.
+          }
+          if (entry[OLDER]) {
+              entry[OLDER][NEWER] = entry[NEWER]; // C. --> E
+          }
+          entry[NEWER] = undefined; // D --x
+          entry[OLDER] = this.newest; // D. --> E
+          if (this.newest) {
+              this.newest[NEWER] = entry; // E. <-- D
+          }
+          this.newest = entry;
+      }
+      assign(entries) {
+          let entry;
+          let limit = this.limit || Number.MAX_VALUE;
+          this._keymap.clear();
+          const it = entries[Symbol.iterator]();
+          for (let itv = it.next(); !itv.done; itv = it.next()) {
+              const e = new Entry(itv.value[0], itv.value[1]);
+              this._keymap.set(e.key, e);
+              if (!entry) {
+                  this.oldest = e;
+              }
+              else {
+                  entry[NEWER] = e;
+                  e[OLDER] = entry;
+              }
+              entry = e;
+              if (limit-- === 0) {
+                  throw new Error('overflow');
+              }
+          }
+          this.newest = entry;
+          this.size = this._keymap.size;
+      }
+      get(key) {
+          // First, find our cache entry
+          const entry = this._keymap.get(key);
+          if (!entry) {
+              return;
+          } // Not cached. Sorry.
+          // As <key> was found in the cache, register it as being requested recently
+          this._markEntryAsUsed(entry);
+          return entry.value;
+      }
+      set(key, value) {
+          let entry = this._keymap.get(key);
+          if (entry) {
+              // update existing
+              entry.value = value;
+              this._markEntryAsUsed(entry);
+              return this;
+          }
+          // new entry
+          this._keymap.set(key, (entry = new Entry(key, value)));
+          if (this.newest) {
+              // link previous tail to the new tail (entry)
+              this.newest[NEWER] = entry;
+              entry[OLDER] = this.newest;
+          }
+          else {
+              // we're first in -- yay
+              this.oldest = entry;
+          }
+          // add new entry to the end of the linked list -- it's now the freshest entry.
+          this.newest = entry;
+          ++this.size;
+          if (this.size > this.limit) {
+              // we hit the limit -- remove the head
+              this.shift();
+          }
+          return this;
+      }
+      shift() {
+          // todo: handle special case when limit == 1
+          const entry = this.oldest;
+          if (entry) {
+              if (this.oldest[NEWER]) {
+                  // advance the list
+                  this.oldest = this.oldest[NEWER];
+                  this.oldest[OLDER] = undefined;
+              }
+              else {
+                  // the cache is exhausted
+                  this.oldest = undefined;
+                  this.newest = undefined;
+              }
+              // Remove last strong reference to <entry> and remove links from the purged
+              // entry being returned:
+              entry[NEWER] = entry[OLDER] = undefined;
+              this._keymap.delete(entry.key);
+              --this.size;
+              return [entry.key, entry.value];
+          }
+      }
+      find(key) {
+          const e = this._keymap.get(key);
+          return e ? e.value : undefined;
+      }
+      has(key) {
+          return this._keymap.has(key);
+      }
+      delete(key) {
+          const entry = this._keymap.get(key);
+          if (!entry) {
+              return;
+          }
+          this._keymap.delete(entry.key);
+          if (entry[NEWER] && entry[OLDER]) {
+              // relink the older entry with the newer entry
+              entry[OLDER][NEWER] = entry[NEWER];
+              entry[NEWER][OLDER] = entry[OLDER];
+          }
+          else if (entry[NEWER]) {
+              // remove the link to us
+              entry[NEWER][OLDER] = undefined;
+              // link the newer entry to head
+              this.oldest = entry[NEWER];
+          }
+          else if (entry[OLDER]) {
+              // remove the link to us
+              entry[OLDER][NEWER] = undefined;
+              // link the newer entry to head
+              this.newest = entry[OLDER];
+          }
+          else {
+              // if(entry[OLDER] === undefined && entry.newer === undefined) {
+              this.oldest = this.newest = undefined;
+          }
+          this.size--;
+          return entry.value;
+      }
+      clear() {
+          // Not clearing links should be safe, as we don't expose live links to user
+          this.oldest = this.newest = undefined;
+          this.size = 0;
+          this._keymap.clear();
+      }
+      keys() {
+          return new KeyIterator(this.oldest);
+      }
+      values() {
+          return new ValueIterator(this.oldest);
+      }
+      entries() { }
+      forEach(fun, thisObj) {
+          if (typeof thisObj !== 'object') {
+              thisObj = this;
+          }
+          let entry = this.oldest;
+          while (entry) {
+              fun.call(thisObj, entry.value, entry.key, this);
+              entry = entry[NEWER];
+          }
+      }
+      toJSON() {
+          const s = new Array(this.size);
+          let i = 0;
+          let entry = this.oldest;
+          while (entry) {
+              s[i++] = { key: entry.key, value: entry.value };
+              entry = entry[NEWER];
+          }
+          return s;
+      }
+      toString() {
+          let s = '';
+          let entry = this.oldest;
+          while (entry) {
+              s += String(entry.key) + ':' + entry.value;
+              entry = entry[NEWER];
+              if (entry) {
+                  s += ' < ';
+              }
+          }
+          return s;
+      }
+      [Symbol.iterator]() {
+          return new EntryIterator(this.oldest);
+      }
+  }
+  class EntryIterator {
+      constructor(oldestEntry) {
+          this.entry = oldestEntry;
+      }
+      [Symbol.iterator]() {
+          return this;
+      }
+      next() {
+          const ent = this.entry;
+          if (ent) {
+              this.entry = ent[NEWER];
+              return { done: false, value: [ent.key, ent.value] };
+          }
+          else {
+              return { done: true, value: undefined };
+          }
+      }
+  }
+  class KeyIterator {
+      constructor(oldestEntry) {
+          this.entry = oldestEntry;
+      }
+      [Symbol.iterator]() {
+          return this;
+      }
+      next() {
+          const ent = this.entry;
+          if (ent) {
+              this.entry = ent[NEWER];
+              return { done: false, value: ent.key };
+          }
+          else {
+              return { done: true, value: undefined };
+          }
+      }
+  }
+  class ValueIterator {
+      constructor(oldestEntry) {
+          this.entry = oldestEntry;
+      }
+      [Symbol.iterator]() {
+          return this;
+      }
+      next() {
+          const ent = this.entry;
+          if (ent) {
+              this.entry = ent[NEWER];
+              return { done: false, value: ent.value };
+          }
+          else {
+              return { done: true, value: undefined };
+          }
+      }
+  }
+
+  const compose = (...fns) => {
+      return (payload) => {
+          return fns.reduce((buf, fn) => {
+              return fn(buf);
+          }, payload);
+      };
+  };
+
+  const toArr = (val) => (isArr(val) ? val : val ? [val] : []);
+  function each(val, iterator, revert) {
+      if (isArr(val) || isStr(val)) {
+          if (revert) {
+              for (let i = val.length - 1; i >= 0; i--) {
+                  if (iterator(val[i], i) === false) {
+                      return;
+                  }
+              }
+          }
+          else {
+              for (let i = 0; i < val.length; i++) {
+                  if (iterator(val[i], i) === false) {
+                      return;
+                  }
+              }
+          }
+      }
+      else if (isObj(val)) {
+          let key;
+          for (key in val) {
+              if (Object.hasOwnProperty.call(val, key)) {
+                  if (iterator(val[key], key) === false) {
+                      return;
+                  }
+              }
+          }
+      }
+  }
+  function map(val, iterator, revert) {
+      const res = isArr(val) || isStr(val) ? [] : {};
+      each(val, (item, key) => {
+          const value = iterator(item, key);
+          if (isArr(res)) {
+              res.push(value);
+          }
+          else {
+              res[key] = value;
+          }
+      }, revert);
+      return res;
+  }
+  function reduce(val, iterator, accumulator, revert) {
+      let result = accumulator;
+      each(val, (item, key) => {
+          result = iterator(result, item, key);
+      }, revert);
+      return result;
+  }
+  function every(val, iterator, revert) {
+      let res = true;
+      each(val, (item, key) => {
+          if (!iterator(item, key)) {
+              res = false;
+              return false;
+          }
+      }, revert);
+      return res;
+  }
+  function some(val, iterator, revert) {
+      let res = false;
+      each(val, (item, key) => {
+          if (iterator(item, key)) {
+              res = true;
+              return false;
+          }
+      }, revert);
+      return res;
+  }
+  function findIndex(val, iterator, revert) {
+      let res = -1;
+      each(val, (item, key) => {
+          if (iterator(item, key)) {
+              res = key;
+              return false;
+          }
+      }, revert);
+      return res;
+  }
+  function find(val, iterator, revert) {
+      let res;
+      each(val, (item, key) => {
+          if (iterator(item, key)) {
+              res = item;
+              return false;
+          }
+      }, revert);
+      return res;
+  }
+  function includes(val, searchElement, revert) {
+      if (isStr(val))
+          return val.includes(searchElement);
+      return some(val, (item) => item === searchElement, revert);
+  }
+  function includesWith(val, search) {
+      if (isArr(val)) {
+          return val.some((item) => search(item));
+      }
+      else {
+          return false;
+      }
+  }
+  const flat = (array) => {
+      return toArr(array).reduce((buf, item) => {
+          if (isArr(item))
+              return buf.concat(flat(item));
+          return buf.concat(item);
+      }, []);
+  };
+
+  exports.KeyCode = void 0;
+  (function (KeyCode) {
+      KeyCode["Backspace"] = "Backspace";
+      KeyCode["Tab"] = "Tab";
+      KeyCode["Enter"] = "Enter";
+      KeyCode["Shift"] = "Shift";
+      KeyCode["Control"] = "Control";
+      KeyCode["Alt"] = "Alt";
+      KeyCode["CapsLock"] = "CapsLock";
+      KeyCode["Escape"] = "Escape";
+      KeyCode["Space"] = " ";
+      KeyCode["PageUp"] = "PageUp";
+      KeyCode["PageDown"] = "PageDown";
+      KeyCode["End"] = "End";
+      KeyCode["Home"] = "Home";
+      KeyCode["ArrowLeft"] = "ArrowLeft";
+      KeyCode["ArrowUp"] = "ArrowUp";
+      KeyCode["ArrowRight"] = "ArrowRight";
+      KeyCode["ArrowDown"] = "ArrowDown";
+      KeyCode["Left"] = "Left";
+      KeyCode["Up"] = "Up";
+      KeyCode["Right"] = "Right";
+      KeyCode["Down"] = "Down";
+      KeyCode["Insert"] = "Insert";
+      KeyCode["Delete"] = "Delete";
+      KeyCode["Zero"] = "0";
+      KeyCode["ClosedParen"] = ")";
+      KeyCode["One"] = "1";
+      KeyCode["ExclamationMark"] = "!";
+      KeyCode["Two"] = "2";
+      KeyCode["AtSign"] = "@";
+      KeyCode["Three"] = "3";
+      KeyCode["PoundSign"] = "\u00A3";
+      KeyCode["Hash"] = "#";
+      KeyCode["Four"] = "4";
+      KeyCode["DollarSign"] = "$";
+      KeyCode["Five"] = "5";
+      KeyCode["PercentSign"] = "%";
+      KeyCode["Six"] = "6";
+      KeyCode["Caret"] = "^";
+      KeyCode["Hat"] = "^";
+      KeyCode["Seven"] = "7";
+      KeyCode["Ampersand"] = "&";
+      KeyCode["Eight"] = "8";
+      KeyCode["Star"] = "*";
+      KeyCode["Asterisk"] = "*";
+      KeyCode["Nine"] = "9";
+      KeyCode["OpenParen"] = "(";
+      KeyCode["a"] = "a";
+      KeyCode["b"] = "b";
+      KeyCode["c"] = "c";
+      KeyCode["d"] = "d";
+      KeyCode["e"] = "e";
+      KeyCode["f"] = "f";
+      KeyCode["g"] = "g";
+      KeyCode["h"] = "h";
+      KeyCode["i"] = "i";
+      KeyCode["j"] = "j";
+      KeyCode["k"] = "k";
+      KeyCode["l"] = "l";
+      KeyCode["m"] = "m";
+      KeyCode["n"] = "n";
+      KeyCode["o"] = "o";
+      KeyCode["p"] = "p";
+      KeyCode["q"] = "q";
+      KeyCode["r"] = "r";
+      KeyCode["s"] = "s";
+      KeyCode["t"] = "t";
+      KeyCode["u"] = "u";
+      KeyCode["v"] = "v";
+      KeyCode["w"] = "w";
+      KeyCode["x"] = "x";
+      KeyCode["y"] = "y";
+      KeyCode["z"] = "z";
+      KeyCode["A"] = "A";
+      KeyCode["B"] = "B";
+      KeyCode["C"] = "C";
+      KeyCode["D"] = "D";
+      KeyCode["E"] = "E";
+      KeyCode["F"] = "F";
+      KeyCode["G"] = "G";
+      KeyCode["H"] = "H";
+      KeyCode["I"] = "I";
+      KeyCode["J"] = "J";
+      KeyCode["K"] = "K";
+      KeyCode["L"] = "L";
+      KeyCode["M"] = "M";
+      KeyCode["N"] = "N";
+      KeyCode["O"] = "O";
+      KeyCode["P"] = "P";
+      KeyCode["Q"] = "Q";
+      KeyCode["R"] = "R";
+      KeyCode["S"] = "S";
+      KeyCode["T"] = "T";
+      KeyCode["U"] = "U";
+      KeyCode["V"] = "V";
+      KeyCode["W"] = "W";
+      KeyCode["X"] = "X";
+      KeyCode["Y"] = "Y";
+      KeyCode["Z"] = "Z";
+      KeyCode["Meta"] = "Meta";
+      KeyCode["LeftWindowKey"] = "Meta";
+      KeyCode["RightWindowKey"] = "Meta";
+      KeyCode["Numpad0"] = "0";
+      KeyCode["Numpad1"] = "1";
+      KeyCode["Numpad2"] = "2";
+      KeyCode["Numpad3"] = "3";
+      KeyCode["Numpad4"] = "4";
+      KeyCode["Numpad5"] = "5";
+      KeyCode["Numpad6"] = "6";
+      KeyCode["Numpad7"] = "7";
+      KeyCode["Numpad8"] = "8";
+      KeyCode["Numpad9"] = "9";
+      KeyCode["Multiply"] = "*";
+      KeyCode["Add"] = "+";
+      KeyCode["Subtract"] = "-";
+      KeyCode["DecimalPoint"] = ".";
+      KeyCode["MSDecimalPoint"] = "Decimal";
+      KeyCode["Divide"] = "/";
+      KeyCode["F1"] = "F1";
+      KeyCode["F2"] = "F2";
+      KeyCode["F3"] = "F3";
+      KeyCode["F4"] = "F4";
+      KeyCode["F5"] = "F5";
+      KeyCode["F6"] = "F6";
+      KeyCode["F7"] = "F7";
+      KeyCode["F8"] = "F8";
+      KeyCode["F9"] = "F9";
+      KeyCode["F10"] = "F10";
+      KeyCode["F11"] = "F11";
+      KeyCode["F12"] = "F12";
+      KeyCode["NumLock"] = "NumLock";
+      KeyCode["ScrollLock"] = "ScrollLock";
+      KeyCode["SemiColon"] = ";";
+      KeyCode["Equals"] = "=";
+      KeyCode["Comma"] = ",";
+      KeyCode["Dash"] = "-";
+      KeyCode["Period"] = ".";
+      KeyCode["UnderScore"] = "_";
+      KeyCode["PlusSign"] = "+";
+      KeyCode["ForwardSlash"] = "/";
+      KeyCode["Tilde"] = "~";
+      KeyCode["GraveAccent"] = "`";
+      KeyCode["OpenBracket"] = "[";
+      KeyCode["ClosedBracket"] = "]";
+      KeyCode["Quote"] = "'";
+  })(exports.KeyCode || (exports.KeyCode = {}));
+  const getKeyCodeFromEvent = (event) => {
+      return event.key;
+  };
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function createCommonjsModule(fn) {
+    var module = { exports: {} };
+  	return fn(module, module.exports), module.exports;
+  }
+
+  createCommonjsModule(function (module) {
+  (function (factory) {
+  	if (module.exports) {
+  		module.exports = factory();
+  	} else {
+  		window.idleCallbackShim = factory();
+  	}
+  }(function(){
+  	var scheduleStart, throttleDelay, lazytimer, lazyraf;
+  	var root = typeof window != 'undefined' ?
+  		window :
+  		typeof commonjsGlobal != undefined ?
+  			commonjsGlobal :
+  			this || {};
+  	var requestAnimationFrame = root.cancelRequestAnimationFrame && root.requestAnimationFrame || setTimeout;
+  	var cancelRequestAnimationFrame = root.cancelRequestAnimationFrame || clearTimeout;
+  	var tasks = [];
+  	var runAttempts = 0;
+  	var isRunning = false;
+  	var remainingTime = 7;
+  	var minThrottle = 35;
+  	var throttle = 125;
+  	var index = 0;
+  	var taskStart = 0;
+  	var tasklength = 0;
+  	var IdleDeadline = {
+  		get didTimeout(){
+  			return false;
+  		},
+  		timeRemaining: function(){
+  			var timeRemaining = remainingTime - (Date.now() - taskStart);
+  			return timeRemaining < 0 ? 0 : timeRemaining;
+  		},
+  	};
+  	var setInactive = debounce(function(){
+  		remainingTime = 22;
+  		throttle = 66;
+  		minThrottle = 0;
+  	});
+
+  	function debounce(fn){
+  		var id, timestamp;
+  		var wait = 99;
+  		var check = function(){
+  			var last = (Date.now()) - timestamp;
+
+  			if (last < wait) {
+  				id = setTimeout(check, wait - last);
+  			} else {
+  				id = null;
+  				fn();
+  			}
+  		};
+  		return function(){
+  			timestamp = Date.now();
+  			if(!id){
+  				id = setTimeout(check, wait);
+  			}
+  		};
+  	}
+
+  	function abortRunning(){
+  		if(isRunning){
+  			if(lazyraf){
+  				cancelRequestAnimationFrame(lazyraf);
+  			}
+  			if(lazytimer){
+  				clearTimeout(lazytimer);
+  			}
+  			isRunning = false;
+  		}
+  	}
+
+  	function onInputorMutation(){
+  		if(throttle != 125){
+  			remainingTime = 7;
+  			throttle = 125;
+  			minThrottle = 35;
+
+  			if(isRunning) {
+  				abortRunning();
+  				scheduleLazy();
+  			}
+  		}
+  		setInactive();
+  	}
+
+  	function scheduleAfterRaf() {
+  		lazyraf = null;
+  		lazytimer = setTimeout(runTasks, 0);
+  	}
+
+  	function scheduleRaf(){
+  		lazytimer = null;
+  		requestAnimationFrame(scheduleAfterRaf);
+  	}
+
+  	function scheduleLazy(){
+
+  		if(isRunning){return;}
+  		throttleDelay = throttle - (Date.now() - taskStart);
+
+  		scheduleStart = Date.now();
+
+  		isRunning = true;
+
+  		if(minThrottle && throttleDelay < minThrottle){
+  			throttleDelay = minThrottle;
+  		}
+
+  		if(throttleDelay > 9){
+  			lazytimer = setTimeout(scheduleRaf, throttleDelay);
+  		} else {
+  			throttleDelay = 0;
+  			scheduleRaf();
+  		}
+  	}
+
+  	function runTasks(){
+  		var task, i, len;
+  		var timeThreshold = remainingTime > 9 ?
+  			9 :
+  			1
+  		;
+
+  		taskStart = Date.now();
+  		isRunning = false;
+
+  		lazytimer = null;
+
+  		if(runAttempts > 2 || taskStart - throttleDelay - 50 < scheduleStart){
+  			for(i = 0, len = tasks.length; i < len && IdleDeadline.timeRemaining() > timeThreshold; i++){
+  				task = tasks.shift();
+  				tasklength++;
+  				if(task){
+  					task(IdleDeadline);
+  				}
+  			}
+  		}
+
+  		if(tasks.length){
+  			scheduleLazy();
+  		} else {
+  			runAttempts = 0;
+  		}
+  	}
+
+  	function requestIdleCallbackShim(task){
+  		index++;
+  		tasks.push(task);
+  		scheduleLazy();
+  		return index;
+  	}
+
+  	function cancelIdleCallbackShim(id){
+  		var index = id - 1 - tasklength;
+  		if(tasks[index]){
+  			tasks[index] = null;
+  		}
+  	}
+
+  	if(!root.requestIdleCallback || !root.cancelIdleCallback){
+  		root.requestIdleCallback = requestIdleCallbackShim;
+  		root.cancelIdleCallback = cancelIdleCallbackShim;
+
+  		if(root.document && document.addEventListener){
+  			root.addEventListener('scroll', onInputorMutation, true);
+  			root.addEventListener('resize', onInputorMutation);
+
+  			document.addEventListener('focus', onInputorMutation, true);
+  			document.addEventListener('mouseover', onInputorMutation, true);
+  			['click', 'keypress', 'touchstart', 'mousedown'].forEach(function(name){
+  				document.addEventListener(name, onInputorMutation, {capture: true, passive: true});
+  			});
+
+  			if(root.MutationObserver){
+  				new MutationObserver( onInputorMutation ).observe( document.documentElement, {childList: true, subtree: true, attributes: true} );
+  			}
+  		}
+  	} else {
+  		try{
+  			root.requestIdleCallback(function(){}, {timeout: 0});
+  		} catch(e){
+  			(function(rIC){
+  				var timeRemainingProto, timeRemaining;
+  				root.requestIdleCallback = function(fn, timeout){
+  					if(timeout && typeof timeout.timeout == 'number'){
+  						return rIC(fn, timeout.timeout);
+  					}
+  					return rIC(fn);
+  				};
+  				if(root.IdleCallbackDeadline && (timeRemainingProto = IdleCallbackDeadline.prototype)){
+  					timeRemaining = Object.getOwnPropertyDescriptor(timeRemainingProto, 'timeRemaining');
+  					if(!timeRemaining || !timeRemaining.configurable || !timeRemaining.get){return;}
+  					Object.defineProperty(timeRemainingProto, 'timeRemaining', {
+  						value:  function(){
+  							return timeRemaining.get.call(this);
+  						},
+  						enumerable: true,
+  						configurable: true,
+  					});
+  				}
+  			})(root.requestIdleCallback);
+  		}
+  	}
+
+  	return {
+  		request: requestIdleCallbackShim,
+  		cancel: cancelIdleCallbackShim,
+  	};
+  }));
+  });
+
+  const requestIdle = (callback, options) => {
+      return globalThisPolyfill['requestIdleCallback'](callback, options);
+  };
+  const cancelIdle = (id) => {
+      globalThisPolyfill['cancelIdleCallback'](id);
+  };
+
+  const InlineLayoutTagNames = new Set([
+      'A',
+      'ABBR',
+      'ACRONYM',
+      'AUDIO',
+      'B',
+      'BDI',
+      'BDO',
+      'BIG',
+      'BR',
+      'BUTTON',
+      'CANVAS',
+      'CITE',
+      'CODE',
+      'DATA',
+      'DATALIST',
+      'DEL',
+      'DFN',
+      'EM',
+      'EMBED',
+      'I',
+      'IFRAME',
+      'IMG',
+      'INS',
+      'KBD',
+      'LABEL',
+      'MAP',
+      'MARK',
+      'METER',
+      'NOSCRIPT',
+      'OBJECT',
+      'OUTPUT',
+      'PICTURE',
+      'PROGRESS',
+      'Q',
+      'RUBY',
+      'S',
+      'SAMP',
+      'SELECT',
+      'SLOT',
+      'SMALL',
+      'STRONG',
+      'SUB',
+      'SUP',
+      'SVG',
+      'TEMPLATE',
+      'TEXTAREA',
+      'TIME',
+      'U',
+      'TT',
+      'VAR',
+      'VIDEO',
+      'WBR',
+      'INPUT',
+      'SPAN',
+  ]);
+  const calcElementOuterWidth = (innerWidth, style) => {
+      return (innerWidth +
+          parseFloat(style.marginLeft) +
+          parseFloat(style.marginRight) +
+          parseFloat(style.paddingLeft) +
+          parseFloat(style.paddingRight) +
+          parseFloat(style.borderLeftWidth) +
+          parseFloat(style.borderRightWidth));
+  };
+  const calcElementLayout = (element) => {
+      if (!element)
+          return 'vertical';
+      const parent = element.parentElement;
+      if (!parent)
+          return 'vertical';
+      const tagName = element.tagName;
+      const parentTagName = parent.tagName;
+      const style = getComputedStyle(element);
+      const parentStyle = getComputedStyle(parent);
+      const isNotFullWidth = () => {
+          const innerWidth = element.getBoundingClientRect().width;
+          const outerWidth = calcElementOuterWidth(innerWidth, style);
+          const parentInnerWidth = parent.getBoundingClientRect().width;
+          return outerWidth.toFixed(0) < parentInnerWidth.toFixed(0);
+      };
+      if (tagName === 'TH' || tagName === 'TD') {
+          if (parentTagName === 'TR')
+              return 'horizontal';
+      }
+      if (parentStyle.display === 'flex' && parentStyle.flexDirection === 'row')
+          return 'horizontal';
+      if (parentStyle.display === 'grid') {
+          if (isNotFullWidth()) {
+              return 'horizontal';
+          }
+      }
+      if (InlineLayoutTagNames.has(tagName)) {
+          if (style.display === 'block') {
+              if (style.float === 'left' || style.float === 'right') {
+                  if (isNotFullWidth()) {
+                      return 'horizontal';
+                  }
+              }
+              return 'vertical';
+          }
+          return 'horizontal';
+      }
+  };
+  const calcElementTranslate = (element) => {
+      var _a, _b, _c;
+      const transform = (_a = element === null || element === void 0 ? void 0 : element.style) === null || _a === void 0 ? void 0 : _a.transform;
+      if (transform) {
+          const [x, y] = (_c = (_b = transform
+              .match(/translate(?:3d)?\(\s*([-\d.]+)[a-z]+?[\s,]+([-\d.]+)[a-z]+?(?:[\s,]+([-\d.]+))?[a-z]+?\s*\)/)) === null || _b === void 0 ? void 0 : _b.slice(1, 3)) !== null && _c !== void 0 ? _c : [0, 0];
+          return new Point(Number(x), Number(y));
+      }
+      else {
+          return new Point(Number(element.offsetLeft), Number(element.offsetTop));
+      }
+  };
+  const calcElementRotate = (element) => {
+      var _a, _b, _c;
+      const transform = (_a = element === null || element === void 0 ? void 0 : element.style) === null || _a === void 0 ? void 0 : _a.transform;
+      if (transform) {
+          return Number((_c = (_b = transform.match(/rotate\(\s*([-\d.]+)/)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : 0);
+      }
+      else {
+          return 0;
+      }
+  };
+  const calcElementScale = (element) => {
+      var _a, _b, _c;
+      const transform = (_a = element === null || element === void 0 ? void 0 : element.style) === null || _a === void 0 ? void 0 : _a.transform;
+      if (transform) {
+          return Number((_c = (_b = transform.match(/scale\(\s*([-\d.]+)/)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : 0);
+      }
+      else {
+          return 0;
+      }
+  };
+
+  class LayoutObserver {
+      constructor(observer = () => { }) {
+          this.connected = false;
+          this.observe = (target) => {
+              this.resizeObserver.observe(target);
+              this.performanceObserver.observe({
+                  entryTypes: ['paint', 'element', 'layout-shift', 'event'],
+              });
+              this.mutationObserver.observe(target, {
+                  attributeFilter: ['style'],
+                  attributes: true,
+              });
+              this.connected = true;
+          };
+          this.disconnect = () => {
+              if (this.connected) {
+                  this.resizeObserver.disconnect();
+                  this.performanceObserver.disconnect();
+                  this.mutationObserver.disconnect();
+              }
+              this.connected = false;
+          };
+          this.resizeObserver = new ResizeObserver(() => observer());
+          this.performanceObserver = new PerformanceObserver(() => {
+              observer();
+          });
+          this.mutationObserver = new MutationObserver(() => observer());
+      }
+  }
+
+  exports.Event = Event;
+  exports.EventDriver = EventDriver;
+  exports.LRUMap = LRUMap;
+  exports.LayoutObserver = LayoutObserver;
+  exports.LineSegment = LineSegment;
+  exports.Point = Point;
+  exports.Rect = Rect;
+  exports.Subscribable = Subscribable;
+  exports.calcAutoScrollBasicInfo = calcAutoScrollBasicInfo;
+  exports.calcBoundingRect = calcBoundingRect;
+  exports.calcClosestEdges = calcClosestEdges;
+  exports.calcCombineSnapLineSegment = calcCombineSnapLineSegment;
+  exports.calcDistanceOfPointToRect = calcDistanceOfPointToRect;
+  exports.calcDistanceOfSnapLineToEdges = calcDistanceOfSnapLineToEdges;
+  exports.calcDistancePointToEdge = calcDistancePointToEdge;
+  exports.calcEdgeLinesOfRect = calcEdgeLinesOfRect;
+  exports.calcElementLayout = calcElementLayout;
+  exports.calcElementOuterWidth = calcElementOuterWidth;
+  exports.calcElementRotate = calcElementRotate;
+  exports.calcElementScale = calcElementScale;
+  exports.calcElementTranslate = calcElementTranslate;
+  exports.calcExtendsLineSegmentOfRect = calcExtendsLineSegmentOfRect;
+  exports.calcOffsetOfSnapLineSegmentToEdge = calcOffsetOfSnapLineSegmentToEdge;
+  exports.calcQuadrantOfPointToRect = calcQuadrantOfPointToRect;
+  exports.calcRectByStartEndPoint = calcRectByStartEndPoint;
+  exports.calcRectOfAxisLineSegment = calcRectOfAxisLineSegment;
+  exports.calcRelativeOfPointToRect = calcRelativeOfPointToRect;
+  exports.calcSpaceBlockOfRect = calcSpaceBlockOfRect;
+  exports.calcSpeedFactor = calcSpeedFactor;
+  exports.cancelIdle = cancelIdle;
+  exports.clone = clone;
+  exports.compose = compose;
+  exports.createUniformSpeedAnimation = createUniformSpeedAnimation;
+  exports.each = each;
+  exports.every = every;
+  exports.find = find;
+  exports.findIndex = findIndex;
+  exports.flat = flat;
+  exports.getKeyCodeFromEvent = getKeyCodeFromEvent;
+  exports.getRectPoints = getRectPoints;
+  exports.getType = getType;
+  exports.globalThisPolyfill = globalThisPolyfill;
+  exports.includes = includes;
+  exports.includesWith = includesWith;
+  exports.instOf = instOf;
+  exports.isArr = isArr;
+  exports.isBool = isBool;
+  exports.isCrossRectInRect = isCrossRectInRect;
+  exports.isEqualRect = isEqualRect;
+  exports.isFn = isFn;
+  exports.isHTMLElement = isHTMLElement;
+  exports.isLineSegment = isLineSegment;
+  exports.isNearAfter = isNearAfter;
+  exports.isNum = isNum;
+  exports.isObj = isObj;
+  exports.isPlainObj = isPlainObj;
+  exports.isPoint = isPoint;
+  exports.isPointInRect = isPointInRect;
+  exports.isRect = isRect;
+  exports.isRectInRect = isRectInRect;
+  exports.isRegExp = isRegExp;
+  exports.isStr = isStr;
+  exports.isValid = isValid;
+  exports.isValidNumber = isValidNumber;
+  exports.isWindow = isWindow;
+  exports.map = map;
+  exports.reduce = reduce;
+  exports.requestIdle = requestIdle;
+  exports.scrollAnimate = scrollAnimate;
+  exports.shallowClone = shallowClone;
+  exports.some = some;
+  exports.toArr = toArr;
+  exports.uid = uid;
+  exports.updateScrollValue = updateScrollValue;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));