build-dxf 0.0.18 → 0.0.19-10

package/src/index3.js

@@ -0,0 +1,2047 @@
+import * as THREE from "three";
+import { i as isString, n as noop, r as resolveUnref, t as tryOnScopeDispose, c as isClient, d as tryOnMounted, e as identity, f as buildProps, g as definePropType, _ as _export_sfc, u as useNamespace, h as isNumber, j as addUnit, w as withInstall, k as useEmptyValuesProps, l as useSizeProp, p as provideGlobalConfig, m as iconPropType, o as useGlobalComponentSettings, T as TypeComponentsMap, q as ElIcon, s as TypeComponents, v as useTimeoutFn, x as isString$1, y as isFunction, z as isBoolean, A as isElement, B as withInstallFunction, L as Lines, D as DomEventRegister, b as ElCheckbox, E as ElButton, S as SelectLocalFile } from "./selectLocalFile.js";
+import { C as Component, L as LineSegment, P as Point, B as Box2, E as EventDispatcher, b as PointVirtualGrid, Q as Quadtree } from "./build.js";
+import { watch, ref, defineComponent, computed, createElementBlock, openBlock, normalizeClass, unref, renderSlot, createVNode, Transition, withCtx, withDirectives, createElementVNode, normalizeStyle, createTextVNode, toDisplayString, vShow, shallowReactive, onMounted, createBlock, createCommentVNode, resolveDynamicComponent, Fragment, withModifiers, nextTick, isVNode, render, toRaw, watchEffect, onUnmounted, renderList, createApp } from "vue";
+import "clipper-lib";
+import "dxf-writer";
+import "three/addons/controls/OrbitControls.js";
+function unrefElement(elRef) {
+  var _a;
+  const plain = resolveUnref(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+const defaultWindow = isClient ? window : void 0;
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners;
+  let options;
+  if (isString(args[0]) || Array.isArray(args[0])) {
+    [events, listeners, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners, options] = args;
+  }
+  if (!target)
+    return noop;
+  if (!Array.isArray(events))
+    events = [events];
+  if (!Array.isArray(listeners))
+    listeners = [listeners];
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener, options2) => {
+    el.addEventListener(event, listener, options2);
+    return () => el.removeEventListener(event, listener, options2);
+  };
+  const stopWatch = watch(() => [unrefElement(target), resolveUnref(options)], ([el, options2]) => {
+    cleanup();
+    if (!el)
+      return;
+    cleanups.push(...events.flatMap((event) => {
+      return listeners.map((listener) => register(el, event, listener, options2));
+    }));
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+function useSupported(callback, sync = false) {
+  const isSupported = ref();
+  const update = () => isSupported.value = Boolean(callback());
+  update();
+  tryOnMounted(update, sync);
+  return isSupported;
+}
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+_global[globalKey] = _global[globalKey] || {};
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useResizeObserver(target, callback, options = {}) {
+  const _a = options, { window: window2 = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
+  let observer;
+  const isSupported = useSupported(() => window2 && "ResizeObserver" in window2);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (isSupported.value && window2 && el) {
+      observer = new ResizeObserver(callback);
+      observer.observe(el, observerOptions);
+    }
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+var SwipeDirection;
+(function(SwipeDirection2) {
+  SwipeDirection2["UP"] = "UP";
+  SwipeDirection2["RIGHT"] = "RIGHT";
+  SwipeDirection2["DOWN"] = "DOWN";
+  SwipeDirection2["LEFT"] = "LEFT";
+  SwipeDirection2["NONE"] = "NONE";
+})(SwipeDirection || (SwipeDirection = {}));
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const _TransitionPresets = {
+  easeInSine: [0.12, 0, 0.39, 0],
+  easeOutSine: [0.61, 1, 0.88, 1],
+  easeInOutSine: [0.37, 0, 0.63, 1],
+  easeInQuad: [0.11, 0, 0.5, 0],
+  easeOutQuad: [0.5, 1, 0.89, 1],
+  easeInOutQuad: [0.45, 0, 0.55, 1],
+  easeInCubic: [0.32, 0, 0.67, 0],
+  easeOutCubic: [0.33, 1, 0.68, 1],
+  easeInOutCubic: [0.65, 0, 0.35, 1],
+  easeInQuart: [0.5, 0, 0.75, 0],
+  easeOutQuart: [0.25, 1, 0.5, 1],
+  easeInOutQuart: [0.76, 0, 0.24, 1],
+  easeInQuint: [0.64, 0, 0.78, 0],
+  easeOutQuint: [0.22, 1, 0.36, 1],
+  easeInOutQuint: [0.83, 0, 0.17, 1],
+  easeInExpo: [0.7, 0, 0.84, 0],
+  easeOutExpo: [0.16, 1, 0.3, 1],
+  easeInOutExpo: [0.87, 0, 0.13, 1],
+  easeInCirc: [0.55, 0, 1, 0.45],
+  easeOutCirc: [0, 0.55, 0.45, 1],
+  easeInOutCirc: [0.85, 0, 0.15, 1],
+  easeInBack: [0.36, 0, 0.66, -0.56],
+  easeOutBack: [0.34, 1.56, 0.64, 1],
+  easeInOutBack: [0.68, -0.6, 0.32, 1.6]
+};
+__spreadValues({
+  linear: identity
+}, _TransitionPresets);
+const mutable = (val) => val;
+const EVENT_CODE = {
+  esc: "Escape"
+};
+const badgeProps = buildProps({
+  value: {
+    type: [String, Number],
+    default: ""
+  },
+  max: {
+    type: Number,
+    default: 99
+  },
+  isDot: Boolean,
+  hidden: Boolean,
+  type: {
+    type: String,
+    values: ["primary", "success", "warning", "info", "danger"],
+    default: "danger"
+  },
+  showZero: {
+    type: Boolean,
+    default: true
+  },
+  color: String,
+  badgeStyle: {
+    type: definePropType([String, Object, Array])
+  },
+  offset: {
+    type: definePropType(Array),
+    default: [0, 0]
+  },
+  badgeClass: {
+    type: String
+  }
+});
+const __default__$1 = defineComponent({
+  name: "ElBadge"
+});
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...__default__$1,
+  props: badgeProps,
+  setup(__props, { expose }) {
+    const props = __props;
+    const ns = useNamespace("badge");
+    const content = computed(() => {
+      if (props.isDot)
+        return "";
+      if (isNumber(props.value) && isNumber(props.max)) {
+        return props.max < props.value ? `${props.max}+` : `${props.value}`;
+      }
+      return `${props.value}`;
+    });
+    const style = computed(() => {
+      var _a, _b, _c, _d, _e;
+      return [
+        {
+          backgroundColor: props.color,
+          marginRight: addUnit(-((_b = (_a = props.offset) == null ? void 0 : _a[0]) != null ? _b : 0)),
+          marginTop: addUnit((_d = (_c = props.offset) == null ? void 0 : _c[1]) != null ? _d : 0)
+        },
+        (_e = props.badgeStyle) != null ? _e : {}
+      ];
+    });
+    expose({
+      content
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(ns).b())
+      }, [
+        renderSlot(_ctx.$slots, "default"),
+        createVNode(Transition, {
+          name: `${unref(ns).namespace.value}-zoom-in-center`,
+          persisted: ""
+        }, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("sup", {
+              class: normalizeClass([
+                unref(ns).e("content"),
+                unref(ns).em("content", _ctx.type),
+                unref(ns).is("fixed", !!_ctx.$slots.default),
+                unref(ns).is("dot", _ctx.isDot),
+                unref(ns).is("hide-zero", !_ctx.showZero && props.value === 0),
+                _ctx.badgeClass
+              ]),
+              style: normalizeStyle(unref(style))
+            }, [
+              renderSlot(_ctx.$slots, "content", { value: unref(content) }, () => [
+                createTextVNode(toDisplayString(unref(content)), 1)
+              ])
+            ], 6), [
+              [vShow, !_ctx.hidden && (unref(content) || _ctx.isDot || _ctx.$slots.content)]
+            ])
+          ]),
+          _: 3
+        }, 8, ["name"])
+      ], 2);
+    };
+  }
+});
+var Badge = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "badge.vue"]]);
+const ElBadge = withInstall(Badge);
+const configProviderProps = buildProps({
+  a11y: {
+    type: Boolean,
+    default: true
+  },
+  locale: {
+    type: definePropType(Object)
+  },
+  size: useSizeProp,
+  button: {
+    type: definePropType(Object)
+  },
+  card: {
+    type: definePropType(Object)
+  },
+  dialog: {
+    type: definePropType(Object)
+  },
+  link: {
+    type: definePropType(Object)
+  },
+  experimentalFeatures: {
+    type: definePropType(Object)
+  },
+  keyboardNavigation: {
+    type: Boolean,
+    default: true
+  },
+  message: {
+    type: definePropType(Object)
+  },
+  zIndex: Number,
+  namespace: {
+    type: String,
+    default: "el"
+  },
+  ...useEmptyValuesProps
+});
+const messageConfig = {};
+defineComponent({
+  name: "ElConfigProvider",
+  props: configProviderProps,
+  setup(props, { slots }) {
+    const config = provideGlobalConfig(props);
+    watch(() => props.message, (val) => {
+      var _a, _b;
+      Object.assign(messageConfig, (_b = (_a = config == null ? void 0 : config.value) == null ? void 0 : _a.message) != null ? _b : {}, val != null ? val : {});
+    }, { immediate: true, deep: true });
+    return () => renderSlot(slots, "default", { config: config == null ? void 0 : config.value });
+  }
+});
+const messageTypes = [
+  "primary",
+  "success",
+  "info",
+  "warning",
+  "error"
+];
+const messageDefaults = mutable({
+  customClass: "",
+  dangerouslyUseHTMLString: false,
+  duration: 3e3,
+  icon: void 0,
+  id: "",
+  message: "",
+  onClose: void 0,
+  showClose: false,
+  type: "info",
+  plain: false,
+  offset: 16,
+  zIndex: 0,
+  grouping: false,
+  repeatNum: 1,
+  appendTo: isClient ? document.body : void 0
+});
+const messageProps = buildProps({
+  customClass: {
+    type: String,
+    default: messageDefaults.customClass
+  },
+  dangerouslyUseHTMLString: {
+    type: Boolean,
+    default: messageDefaults.dangerouslyUseHTMLString
+  },
+  duration: {
+    type: Number,
+    default: messageDefaults.duration
+  },
+  icon: {
+    type: iconPropType,
+    default: messageDefaults.icon
+  },
+  id: {
+    type: String,
+    default: messageDefaults.id
+  },
+  message: {
+    type: definePropType([
+      String,
+      Object,
+      Function
+    ]),
+    default: messageDefaults.message
+  },
+  onClose: {
+    type: definePropType(Function),
+    default: messageDefaults.onClose
+  },
+  showClose: {
+    type: Boolean,
+    default: messageDefaults.showClose
+  },
+  type: {
+    type: String,
+    values: messageTypes,
+    default: messageDefaults.type
+  },
+  plain: {
+    type: Boolean,
+    default: messageDefaults.plain
+  },
+  offset: {
+    type: Number,
+    default: messageDefaults.offset
+  },
+  zIndex: {
+    type: Number,
+    default: messageDefaults.zIndex
+  },
+  grouping: {
+    type: Boolean,
+    default: messageDefaults.grouping
+  },
+  repeatNum: {
+    type: Number,
+    default: messageDefaults.repeatNum
+  }
+});
+const messageEmits = {
+  destroy: () => true
+};
+const instances = shallowReactive([]);
+const getInstance = (id) => {
+  const idx = instances.findIndex((instance) => instance.id === id);
+  const current = instances[idx];
+  let prev;
+  if (idx > 0) {
+    prev = instances[idx - 1];
+  }
+  return { current, prev };
+};
+const getLastOffset = (id) => {
+  const { prev } = getInstance(id);
+  if (!prev)
+    return 0;
+  return prev.vm.exposed.bottom.value;
+};
+const getOffsetOrSpace = (id, offset) => {
+  const idx = instances.findIndex((instance) => instance.id === id);
+  return idx > 0 ? 16 : offset;
+};
+const __default__ = defineComponent({
+  name: "ElMessage"
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: messageProps,
+  emits: messageEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { Close } = TypeComponents;
+    const isStartTransition = ref(false);
+    const { ns, zIndex } = useGlobalComponentSettings("message");
+    const { currentZIndex, nextZIndex } = zIndex;
+    const messageRef = ref();
+    const visible = ref(false);
+    const height = ref(0);
+    let stopTimer = void 0;
+    const badgeType = computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
+    const typeClass = computed(() => {
+      const type = props.type;
+      return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
+    });
+    const iconComponent = computed(() => props.icon || TypeComponentsMap[props.type] || "");
+    const lastOffset = computed(() => getLastOffset(props.id));
+    const offset = computed(() => getOffsetOrSpace(props.id, props.offset) + lastOffset.value);
+    const bottom = computed(() => height.value + offset.value);
+    const customStyle = computed(() => ({
+      top: `${offset.value}px`,
+      zIndex: currentZIndex.value
+    }));
+    function startTimer() {
+      if (props.duration === 0)
+        return;
+      ({ stop: stopTimer } = useTimeoutFn(() => {
+        close();
+      }, props.duration));
+    }
+    function clearTimer() {
+      stopTimer == null ? void 0 : stopTimer();
+    }
+    function close() {
+      visible.value = false;
+      nextTick(() => {
+        var _a;
+        if (!isStartTransition.value) {
+          (_a = props.onClose) == null ? void 0 : _a.call(props);
+          emit("destroy");
+        }
+      });
+    }
+    function keydown({ code }) {
+      if (code === EVENT_CODE.esc) {
+        close();
+      }
+    }
+    onMounted(() => {
+      startTimer();
+      nextZIndex();
+      visible.value = true;
+    });
+    watch(() => props.repeatNum, () => {
+      clearTimer();
+      startTimer();
+    });
+    useEventListener(document, "keydown", keydown);
+    useResizeObserver(messageRef, () => {
+      height.value = messageRef.value.getBoundingClientRect().height;
+    });
+    expose({
+      visible,
+      bottom,
+      close
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, {
+        name: unref(ns).b("fade"),
+        onBeforeEnter: ($event) => isStartTransition.value = true,
+        onBeforeLeave: _ctx.onClose,
+        onAfterLeave: ($event) => _ctx.$emit("destroy"),
+        persisted: ""
+      }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("div", {
+            id: _ctx.id,
+            ref_key: "messageRef",
+            ref: messageRef,
+            class: normalizeClass([
+              unref(ns).b(),
+              { [unref(ns).m(_ctx.type)]: _ctx.type },
+              unref(ns).is("closable", _ctx.showClose),
+              unref(ns).is("plain", _ctx.plain),
+              _ctx.customClass
+            ]),
+            style: normalizeStyle(unref(customStyle)),
+            role: "alert",
+            onMouseenter: clearTimer,
+            onMouseleave: startTimer
+          }, [
+            _ctx.repeatNum > 1 ? (openBlock(), createBlock(unref(ElBadge), {
+              key: 0,
+              value: _ctx.repeatNum,
+              type: unref(badgeType),
+              class: normalizeClass(unref(ns).e("badge"))
+            }, null, 8, ["value", "type", "class"])) : createCommentVNode("v-if", true),
+            unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
+              key: 1,
+              class: normalizeClass([unref(ns).e("icon"), unref(typeClass)])
+            }, {
+              default: withCtx(() => [
+                (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
+              ]),
+              _: 1
+            }, 8, ["class"])) : createCommentVNode("v-if", true),
+            renderSlot(_ctx.$slots, "default", {}, () => [
+              !_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
+                key: 0,
+                class: normalizeClass(unref(ns).e("content"))
+              }, toDisplayString(_ctx.message), 3)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+                createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
+                createElementVNode("p", {
+                  class: normalizeClass(unref(ns).e("content")),
+                  innerHTML: _ctx.message
+                }, null, 10, ["innerHTML"])
+              ], 2112))
+            ]),
+            _ctx.showClose ? (openBlock(), createBlock(unref(ElIcon), {
+              key: 2,
+              class: normalizeClass(unref(ns).e("closeBtn")),
+              onClick: withModifiers(close, ["stop"])
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(Close))
+              ]),
+              _: 1
+            }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true)
+          ], 46, ["id"]), [
+            [vShow, visible.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name", "onBeforeEnter", "onBeforeLeave", "onAfterLeave"]);
+    };
+  }
+});
+var MessageConstructor = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "message.vue"]]);
+let seed = 1;
+const normalizeOptions = (params) => {
+  const options = !params || isString$1(params) || isVNode(params) || isFunction(params) ? { message: params } : params;
+  const normalized = {
+    ...messageDefaults,
+    ...options
+  };
+  if (!normalized.appendTo) {
+    normalized.appendTo = document.body;
+  } else if (isString$1(normalized.appendTo)) {
+    let appendTo = document.querySelector(normalized.appendTo);
+    if (!isElement(appendTo)) {
+      appendTo = document.body;
+    }
+    normalized.appendTo = appendTo;
+  }
+  if (isBoolean(messageConfig.grouping) && !normalized.grouping) {
+    normalized.grouping = messageConfig.grouping;
+  }
+  if (isNumber(messageConfig.duration) && normalized.duration === 3e3) {
+    normalized.duration = messageConfig.duration;
+  }
+  if (isNumber(messageConfig.offset) && normalized.offset === 16) {
+    normalized.offset = messageConfig.offset;
+  }
+  if (isBoolean(messageConfig.showClose) && !normalized.showClose) {
+    normalized.showClose = messageConfig.showClose;
+  }
+  if (isBoolean(messageConfig.plain) && !normalized.plain) {
+    normalized.plain = messageConfig.plain;
+  }
+  return normalized;
+};
+const closeMessage = (instance) => {
+  const idx = instances.indexOf(instance);
+  if (idx === -1)
+    return;
+  instances.splice(idx, 1);
+  const { handler } = instance;
+  handler.close();
+};
+const createMessage = ({ appendTo, ...options }, context) => {
+  const id = `message_${seed++}`;
+  const userOnClose = options.onClose;
+  const container = document.createElement("div");
+  const props = {
+    ...options,
+    id,
+    onClose: () => {
+      userOnClose == null ? void 0 : userOnClose();
+      closeMessage(instance);
+    },
+    onDestroy: () => {
+      render(null, container);
+    }
+  };
+  const vnode = createVNode(MessageConstructor, props, isFunction(props.message) || isVNode(props.message) ? {
+    default: isFunction(props.message) ? props.message : () => props.message
+  } : null);
+  vnode.appContext = context || message._context;
+  render(vnode, container);
+  appendTo.appendChild(container.firstElementChild);
+  const vm = vnode.component;
+  const handler = {
+    close: () => {
+      vm.exposed.close();
+    }
+  };
+  const instance = {
+    id,
+    vnode,
+    vm,
+    handler,
+    props: vnode.component.props
+  };
+  return instance;
+};
+const message = (options = {}, context) => {
+  if (!isClient)
+    return { close: () => void 0 };
+  const normalized = normalizeOptions(options);
+  if (normalized.grouping && instances.length) {
+    const instance2 = instances.find(({ vnode: vm }) => {
+      var _a;
+      return ((_a = vm.props) == null ? void 0 : _a.message) === normalized.message;
+    });
+    if (instance2) {
+      instance2.props.repeatNum += 1;
+      instance2.props.type = normalized.type;
+      return instance2.handler;
+    }
+  }
+  if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) {
+    return { close: () => void 0 };
+  }
+  const instance = createMessage(normalized, context);
+  instances.push(instance);
+  return instance.handler;
+};
+messageTypes.forEach((type) => {
+  message[type] = (options = {}, appContext) => {
+    const normalized = normalizeOptions(options);
+    return message({ ...normalized, type }, appContext);
+  };
+});
+function closeAll(type) {
+  const instancesToClose = [...instances];
+  for (const instance of instancesToClose) {
+    if (!type || type === instance.props.type) {
+      instance.handler.close();
+    }
+  }
+}
+message.closeAll = closeAll;
+message._context = null;
+const ElMessage = withInstallFunction(message, "$message");
+class CommandFlowComponent extends Component {
+  _renderer;
+  get renderer() {
+    if (!this._renderer) this._renderer = this.parent?.findComponentByName("Renderer");
+    return this._renderer;
+  }
+  _domElement;
+  get domElement() {
+    if (!this._domElement) this._domElement = this.editor?.domContainer?.domElement;
+    return this._domElement;
+  }
+  _editor;
+  get editor() {
+    if (!this._editor) this._editor = this.parent?.findComponentByName("Editor");
+    return this._editor;
+  }
+  _eventInput;
+  get eventInput() {
+    if (!this._eventInput) this._eventInput = this.parent?.findComponentByName("EventInput");
+    return this._eventInput;
+  }
+  _renderManager;
+  get renderManager() {
+    if (!this._renderManager) this._renderManager = this.parent?.findComponentByName("RenderManager");
+    return this._renderManager;
+  }
+  _commandManager;
+  get commandManager() {
+    if (!this._commandManager) this._commandManager = this.editor?.commandManager;
+    return this._commandManager;
+  }
+  interruptKeys = ["escape"];
+  /**
+   * 创建中断
+   * @returns 
+   */
+  createInterrupt() {
+    return (next, data) => {
+      this.addEventRecord(
+        "clear",
+        this.editor?.eventInput.addEventListener("codeChange", async () => {
+          if (this.editor.eventInput.isKeyDowns(this.interruptKeys)) {
+            this.editor.commandManager.cancel();
+          }
+        })
+      );
+      next(data);
+    };
+  }
+  /**
+   * 创建鼠标图标变化
+   * @param cursor 
+   * @returns 
+   */
+  createCursor(cursor) {
+    return (next, data) => {
+      const defaultCursor = this.domElement.style.cursor;
+      this.domElement.style.cursor = cursor;
+      this.addEventRecord("clear", () => {
+        this.domElement.style.cursor = defaultCursor ?? "default";
+      });
+      next(data);
+    };
+  }
+  /**
+   * 创建清理
+   * @returns 
+   */
+  createFinally() {
+    return () => {
+      this.canceEventRecord("clear");
+    };
+  }
+}
+class DrawLine extends CommandFlowComponent {
+  static name = "DrawLine";
+  container = new THREE.Group();
+  interruptKeys = ["escape"];
+  withdrawalKeys = ["control", "z"];
+  shortcutKeys = ["control", "l"];
+  confirmKeys = ["enter"];
+  commandName = "draw-line";
+  onAddFromParent() {
+    this.editor.container.add(this.container);
+    const commandFlow = this.commandManager.addCommandFlow(this.commandName).add(this.createInterrupt()).add(this.createCursor("crosshair")).add(this.selectPoint.bind(this));
+    commandFlow.addEventListener("finally", this.createFinally());
+    commandFlow.addEventListener("completed", (e) => this.completed(e.data));
+    this.eventInput.addKeyCombination(this.commandName, this.shortcutKeys);
+    this.eventInput.addEventListener("codeChange", async () => this.eventInput.isKeyCombination(this.commandName) && await this.commandManager.start(this.commandName));
+    this.eventInput.addCancelDefaultBehavior(() => this.eventInput.isOnlyKeyDowns(this.shortcutKeys));
+  }
+  /** 选择点
+   * @param next 
+   */
+  selectPoint(next) {
+    let editor = this.parent?.findComponentByName("Editor"), start = null, end = null, points = [], circle = new THREE.Mesh(new THREE.SphereGeometry(0.05), new THREE.MeshBasicMaterial({ color: 65280 })), dom = editor.domContainer.domElement, line = new Lines([], 16711935), auxiliaryLine = new Lines([
+      new THREE.Vector3(-1e4, 0, 0),
+      new THREE.Vector3(1e4, 0, 0),
+      new THREE.Vector3(0, -1e4, 0),
+      new THREE.Vector3(0, 1e4, 0)
+    ], 16711935);
+    auxiliaryLine.material = new THREE.LineDashedMaterial({
+      color: 4235007,
+      dashSize: 0.1,
+      gapSize: 0.1,
+      linewidth: 0.1
+    });
+    this.container.add(line);
+    const updateLine = () => {
+      line.setPoint(...points, start, end);
+      auxiliaryLine.position.copy(end);
+      this.container.add(auxiliaryLine);
+      auxiliaryLine.computeLineDistances();
+    };
+    const currentPoint = new THREE.Vector3();
+    this.addEventRecord(
+      "clear",
+      editor.addEventListener("pointerPositionChange", () => {
+        const { point, find } = editor.renderManager.adsorption();
+        if (find) {
+          circle.position.set(point.x, point.y, 0);
+          this.container.add(circle);
+          dom.style.cursor = "none";
+        } else {
+          circle.removeFromParent();
+          dom.style.cursor = "crosshair";
+        }
+        currentPoint.copy(point);
+        if (!(start && end)) return;
+        if (editor.eventInput.isKeyDown("shift")) {
+          const x = Math.abs(editor.pointerPosition.x - start.x), y = Math.abs(editor.pointerPosition.y - start.y);
+          if (x > y) end.set(editor.pointerPosition.x, start.y, 0);
+          else end.set(start.x, editor.pointerPosition.y, 0);
+          updateLine();
+          currentPoint.copy(end);
+          return;
+        }
+        end.set(editor.pointerPosition.x, editor.pointerPosition.y, 0);
+        updateLine();
+      }),
+      editor.eventInput.addEventListener("codeChange", async () => {
+        if (editor.eventInput.isKeyDown("mouse_0")) {
+          if (!start) {
+            start = currentPoint.clone();
+            end = currentPoint.clone();
+            updateLine();
+            return;
+          }
+          end = currentPoint.clone();
+          points.push(start.clone(), end.clone());
+          start.copy(end);
+          updateLine();
+        } else if (editor.eventInput.isOnlyKeyDowns(this.withdrawalKeys)) {
+          if (points.length) {
+            const { point } = editor.renderManager.adsorption();
+            points.pop();
+            end?.copy(point);
+            start?.copy(points.pop());
+            updateLine();
+          }
+        } else if (editor.eventInput.isKeyDowns(this.confirmKeys)) next(points);
+      }),
+      function() {
+        line.removeFromParent();
+        circle.removeFromParent();
+        auxiliaryLine.removeFromParent();
+      }
+    );
+  }
+  /** 执行完成
+   */
+  completed(points) {
+    const editor = this.editor, lines = [];
+    for (let i = 0; i < points.length; i += 2) {
+      lines.push(new LineSegment(Point.from(points[i]), Point.from(points[i + 1])));
+    }
+    editor.renderManager.addLines(lines);
+    editor.renderManager.draw();
+  }
+}
+class Default extends Component {
+  static name = "Default";
+  get editor() {
+    return this.parent?.findComponentByName("Editor");
+  }
+  renderer;
+  container = new THREE.Group();
+  onAddFromParent() {
+    const editor = this.editor, commandManager = editor.commandManager;
+    this.renderer = this.parent?.findComponentByName("Renderer");
+    editor.container.add(this.container);
+    commandManager.addCommandFlow("default").add(this.start.bind(this)).addEventListener("finally", this.finally.bind(this));
+    commandManager.addEventListener("startedBefore", (e) => {
+      if (e.currentName === "default" && e.name !== "default") commandManager.cancel();
+    });
+    commandManager.addEventListener("finally", (e) => e.name !== "default" && commandManager.start("default"));
+    editor.eventInput.addCancelDefaultBehavior(() => editor.eventInput.isOnlyKeyDowns(["control", "g"]));
+  }
+  selectLines = [];
+  selectLineObject3D = new THREE.Mesh();
+  /** 添加选择的线段
+   * @param lineSegment 
+   */
+  addSelectLine(lineSegment) {
+    if (this.selectLines.indexOf(lineSegment) > -1) return;
+    this.selectLines.push(lineSegment);
+    this.updateSelectLinesGeometry();
+  }
+  /** 移除选择的线段
+   * @param lineSegment 
+   */
+  removeSelectLine(lineSegment) {
+    const i = this.selectLines.indexOf(lineSegment);
+    if (i > -1) {
+      this.selectLines.splice(i, 1);
+      this.updateSelectLinesGeometry();
+    }
+  }
+  /**
+   * 删除选择的线段
+   */
+  deleteSelectLine() {
+    const editor = this.editor;
+    this.selectLines.forEach((line) => editor.renderManager.removeLine(line));
+    this.selectLines.length = 0;
+    this.updateSelectLinesGeometry();
+    ElMessage({ message: "删除成功", type: "success" });
+  }
+  /**
+   * 删除选择线段上的窗户
+   */
+  deleteSelectWindow() {
+    let is = false;
+    this.selectLines.forEach((line) => {
+      if (!line.userData.isWindow) return;
+      line.userData = {};
+      is = true;
+    });
+    this.editor.renderManager.draw();
+    is && ElMessage({ message: "删除窗户成功", type: "success" });
+  }
+  /**
+   * 如果只选择两个线段，可为两个未链接的点创建连接
+   */
+  connection() {
+    if (this.selectLines.length !== 2) {
+      ElMessage({ message: "连接失败，请选择两个线段", type: "warning" });
+      return;
+    }
+    const editor = this.editor;
+    let start, end, diatance = Infinity;
+    for (let i = 0; i < 2; i++)
+      for (let j = 0; j < 2; j++) {
+        const point1 = this.selectLines[0].points[i];
+        const point2 = this.selectLines[1].points[j];
+        const d = point1.distance(point2);
+        if (d < diatance) {
+          start = point1;
+          end = point2;
+          diatance = d;
+        }
+      }
+    if (start && end) {
+      const line = new LineSegment(start.clone(), end.clone());
+      editor.renderManager.addLine(line);
+      editor.renderManager.draw();
+      ElMessage({ message: "连接成功", type: "success" });
+    }
+  }
+  /**
+   * 如果只选择两个线段，可为两个未链接的点创建连接, 通过计算交点，线段延长到交点
+   */
+  intersectionConnection() {
+    if (this.selectLines.length !== 2) {
+      ElMessage({ message: "连接失败，请选择两个线段", type: "warning" });
+      return;
+    }
+    const editor = this.editor, line1 = this.selectLines[0], line2 = this.selectLines[1], point = this.selectLines[0].getIntersection(this.selectLines[1]);
+    if (!point) return;
+    editor.renderManager.removeLine(line1);
+    editor.renderManager.removeLine(line2);
+    if (line1.start.distance(point) < line1.end.distance(point)) {
+      line1.start.copy(point);
+    } else {
+      line1.end.copy(point);
+    }
+    if (line2.start.distance(point) < line2.end.distance(point)) {
+      line2.start.copy(point);
+    } else {
+      line2.end.copy(point);
+    }
+    editor.renderManager.addLines([line1, line2]);
+    editor.renderManager.draw();
+    ElMessage({ message: "连接成功", type: "success" });
+  }
+  /**
+   * 如果只选择两个线段, 且两个线段在一条路径上，合并线段
+   */
+  mergeLine() {
+    if (this.selectLines.length !== 2) {
+      ElMessage({ message: "未执行线段合并，请选择两条线段", type: "warning" });
+      return;
+    }
+    const editor = this.editor, line1 = this.selectLines[0], line2 = this.selectLines[1];
+    for (let i = 0; i < line1.points.length; i++) {
+      const p1 = line1.points[i];
+      for (let j = 0; j < line2.points.length; j++) {
+        const p2 = line2.points[j];
+        if (p1.equal(p2)) {
+          const p1Next = line1.points[(i + 1) % 2];
+          const p2Next = line2.points[(j + 1) % 2];
+          editor.renderManager.removeLine(line1);
+          editor.renderManager.removeLine(line2);
+          const line = new LineSegment(p1Next, p2Next);
+          editor.renderManager.addLine(line);
+          editor.renderManager.draw();
+          ElMessage({ message: "已合并", type: "success" });
+          return;
+        }
+      }
+    }
+    ElMessage({ message: "合并失败，两条线未找到共用点", type: "warning" });
+  }
+  _timer = null;
+  /**
+   * 更新选择的线段
+   */
+  updateSelectLinesGeometry() {
+    if (this._timer) clearTimeout(this._timer);
+    this._timer = setTimeout(() => {
+      if (this.selectLines.length) this.container.add(this.selectLineObject3D);
+      else this.selectLineObject3D.removeFromParent();
+      const editor = this.editor;
+      const position = this.selectLines.flatMap((line) => line.expandToRectangle(0.04, "bothSides").createGeometry());
+      this.selectLineObject3D.geometry = editor.renderManager.createGeometry({ position }, position.length / 3);
+    }, 10);
+  }
+  /**
+   * 开始执行
+   * @param next 
+   */
+  start() {
+    const editor = this.editor, eventInput = editor.eventInput, object3D = new THREE.Mesh(), dom = editor.domContainer.domElement;
+    let currentSelectLine = null;
+    object3D.position.z = 0.01;
+    this.selectLineObject3D.position.z = object3D.position.z + 0.01;
+    object3D.material = new THREE.MeshBasicMaterial({ color: 55561 });
+    eventInput.addKeyCombination("intersectionConnection", ["control", "shift", "l"]);
+    eventInput.addKeyCombination("connection", ["shift", "l"]);
+    eventInput.addKeyCombination("mergeLine", ["control", "g"]);
+    this.addEventRecord("clear", () => {
+      eventInput.removeKeyCombination("intersectionConnection");
+      eventInput.removeKeyCombination("connection");
+      eventInput.removeKeyCombination("mergeLine");
+    });
+    const showSelectBox = () => {
+      const startPoint = editor.pointerPosition.clone(), endPoint = editor.pointerPosition.clone(), mesh = new THREE.Mesh();
+      this.container.add(mesh);
+      mesh.position.z = 0.05;
+      mesh.material = new THREE.MeshBasicMaterial({
+        color: 16777215,
+        transparent: true,
+        opacity: 0.5
+      });
+      const update = () => {
+        const minX = Math.min(startPoint.x, endPoint.x), maxX = Math.max(startPoint.x, endPoint.x), minY = Math.min(startPoint.y, endPoint.y), maxY = Math.max(startPoint.y, endPoint.y);
+        const position = [
+          minX,
+          maxY,
+          0,
+          maxX,
+          minY,
+          0,
+          maxX,
+          maxY,
+          0,
+          minX,
+          maxY,
+          0,
+          minX,
+          minY,
+          0,
+          maxX,
+          minY,
+          0
+        ];
+        mesh.geometry = editor.renderManager.createGeometry({ position }, position.length / 3);
+      };
+      const move = () => {
+        endPoint.copy(editor.pointerPosition);
+        update();
+      };
+      const end = () => {
+        document.removeEventListener("mousemove", move);
+        document.removeEventListener("mouseup", end);
+        mesh.removeFromParent();
+        const minX = Math.min(startPoint.x, endPoint.x), maxX = Math.max(startPoint.x, endPoint.x), minY = Math.min(startPoint.y, endPoint.y), maxY = Math.max(startPoint.y, endPoint.y);
+        const box = new Box2(minX, maxX, minY, maxY);
+        const resultList = editor.renderManager.quadtree.queryBox(box);
+        this.selectLines.length = 0;
+        resultList.forEach((result) => this.addSelectLine(result.line));
+        this.updateSelectLinesGeometry();
+      };
+      document.addEventListener("mousemove", move);
+      document.addEventListener("mouseup", end);
+    };
+    this.addEventRecord(
+      "clear",
+      // 注册鼠标指针位置变化事件
+      editor.addEventListener("pointerPositionChange", () => {
+        const { line } = editor.renderManager.adsorption(0.05);
+        if (line) {
+          const rectangle = line.expandToRectangle(0.02, "bothSides");
+          object3D.geometry = editor.renderManager.createGeometry({ position: rectangle.createGeometry() }, 6);
+          this.container.add(object3D);
+          dom.style.cursor = "pointer";
+          currentSelectLine = line;
+        } else {
+          object3D.removeFromParent();
+          dom.style.cursor = "default";
+          currentSelectLine = null;
+        }
+      }),
+      eventInput.addEventListener("codeChange", () => {
+        if (eventInput.isKeyDown("mouse_0")) {
+          if (!currentSelectLine) return showSelectBox();
+          if (eventInput.isKeyDown("alt")) {
+            return this.removeSelectLine(currentSelectLine);
+          }
+          if (!eventInput.isKeyDown("control")) this.selectLines.length = 0;
+          this.addSelectLine(currentSelectLine);
+        } else if (eventInput.isOnlyKeyDown("delete")) {
+          this.deleteSelectLine();
+        } else if (eventInput.isKeyDowns(["q", "delete"])) {
+          this.deleteSelectWindow();
+        } else if (eventInput.isKeyCombination("connection")) {
+          this.connection();
+        } else if (eventInput.isKeyCombination("intersectionConnection")) {
+          this.intersectionConnection();
+        } else if (eventInput.isKeyCombination("mergeLine")) {
+          this.mergeLine();
+        }
+      }),
+      function() {
+        object3D.removeFromParent();
+      }
+    );
+  }
+  /** 
+   * 清理
+   */
+  finally() {
+    this.canceEventRecord("clear");
+    this.selectLines.length = 0;
+    this.updateSelectLinesGeometry();
+  }
+}
+class CommandFlow extends EventDispatcher {
+  list = [];
+  add(operation) {
+    this.list.push(operation);
+    return this;
+  }
+}
+class CommandManager extends EventDispatcher {
+  commandFlowMap = /* @__PURE__ */ new Map();
+  lock = false;
+  abortController = null;
+  resolve = null;
+  currentName = null;
+  _disabled = false;
+  set disabled(disabled) {
+    this._disabled = disabled;
+    if (this._disabled) this.cancel();
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  constructor() {
+    super();
+  }
+  /** 添加命令流
+   * @param name 
+   * @returns 
+   */
+  addCommandFlow(name) {
+    if (this.commandFlowMap.has(name)) throw new Error(`${name} 命令已经存在`);
+    const commandFlow = new CommandFlow();
+    this.commandFlowMap.set(name, commandFlow);
+    return commandFlow;
+  }
+  executionPromise = null;
+  executionResolve = null;
+  /** 执行控制流
+   * @param name 
+   * @returns 
+   */
+  async start(name, data = null, step = 0) {
+    if (this.disabled) throw new Error("命令管理器已禁用，无法启动新的命令流");
+    this.dispatchEvent({
+      type: "startedBefore",
+      name,
+      currentName: this.currentName
+    });
+    this.executionPromise && await this.executionPromise;
+    this.executionPromise = null;
+    if (this.lock) {
+      throw new Error("命令管理器已被锁定，无法启动新的命令流");
+    }
+    const commandFlow = this.commandFlowMap.get(name);
+    if (!commandFlow) {
+      throw new Error(`命令流 ${name} 不存在`);
+    }
+    this.lock = true;
+    this.abortController = new AbortController();
+    this.currentName = name;
+    commandFlow.dispatchEvent({ type: "started" });
+    this.dispatchEvent({ type: "started", name });
+    try {
+      for (let i = step; i < commandFlow.list.length; i++) {
+        const operation = commandFlow.list[i];
+        commandFlow.dispatchEvent({ type: "executing", index: i });
+        this.dispatchEvent({ type: "executing", name, index: i });
+        data = await new Promise((resolve) => {
+          this.resolve = resolve;
+          operation(resolve, data);
+        });
+        if (this.abortController.signal.aborted) {
+          commandFlow.dispatchEvent({ type: "executionInterrupt", index: i });
+          this.dispatchEvent({ type: "executionInterrupt", name, index: i });
+          this.dispatchEvent({ type: "cancel", name });
+          break;
+        } else {
+          commandFlow.dispatchEvent({ type: "executionCompleted", index: i, data });
+          this.dispatchEvent({ type: "executionCompleted", name, index: i, data });
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      if (this.abortController && !this.abortController.signal.aborted) {
+        commandFlow.dispatchEvent({ type: "completed", data });
+        this.dispatchEvent({ type: "completed", name, data });
+      }
+      this.lock = false;
+      this.abortController = null;
+      this.currentName = null;
+      commandFlow.dispatchEvent({ type: "finally" });
+      this.dispatchEvent({ type: "finally", name });
+      if (this.executionResolve) {
+        this.executionResolve(null);
+        this.executionResolve = null;
+      }
+    }
+    return data;
+  }
+  /** 取消当前命令
+   */
+  cancel() {
+    if (this.abortController) {
+      this.abortController.abort();
+      if (this.resolve) this.resolve();
+      this.executionPromise = new Promise((resolve) => this.executionResolve = resolve);
+    }
+  }
+}
+const _imports_0 = "data:image/svg+xml,%3c?xml%20version='1.0'%20standalone='no'?%3e%3c!DOCTYPE%20svg%20PUBLIC%20'-//W3C//DTD%20SVG%201.1//EN'%20'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3e%3csvg%20t='1757902422799'%20class='icon'%20viewBox='0%200%201024%201024'%20version='1.1'%20xmlns='http://www.w3.org/2000/svg'%20p-id='1735'%20xmlns:xlink='http://www.w3.org/1999/xlink'%20width='200'%20height='200'%3e%3cpath%20d='M843.2%20726.4c-20.2%200-39.2%205.2-55.8%2014.3L283.8%20237.2c9-16.5%2014.1-35.4%2014.1-55.5%200-64.2-52.3-116.5-116.5-116.5S65%20117.4%2065%20181.6s52.3%20116.5%20116.5%20116.5c20.2%200%2039.2-5.2%2055.8-14.2l503.5%20503.5c-9%2016.5-14.1%2035.4-14.1%2055.5%200%2064.2%2052.3%20116.5%20116.5%20116.5s116.5-52.3%20116.5-116.5-52.3-116.5-116.5-116.5zM181.4%20232.1c-27.8%200-50.5-22.6-50.5-50.5s22.6-50.5%2050.5-50.5%2050.5%2022.6%2050.5%2050.5-22.6%2050.5-50.5%2050.5z%20m661.8%20661.3c-27.8%200-50.5-22.6-50.5-50.5%200-27.8%2022.6-50.5%2050.5-50.5s50.5%2022.6%2050.5%2050.5c0%2027.8-22.7%2050.5-50.5%2050.5z'%20fill='%23231815'%20p-id='1736'%3e%3c/path%3e%3c/svg%3e";
+const _hoisted_1 = { class: "mt-[5px] text-[#888] text-[10px] absolute left-[10px] bottom-[10px] rounded-[8px] min-w-[150px] bg-black/15 p-[10px]" };
+const _hoisted_2 = { class: "inline-block ml-[10px]" };
+const _hoisted_3 = { class: "flex p-[5px_0px] flex-row header text-[14px] font-bold p-[10px 0px] border-b-1 border-b-[#eee]" };
+const _hoisted_4 = { class: "p-[5px]" };
+const _hoisted_5 = { class: "mt-[10px] text-[14px] flex flex-col" };
+const _hoisted_6 = { class: "flex flex-row items-center gap-[10px] mt-[10px]" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "EditorTool",
+  props: {
+    dxfSystem: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const originalLineVisible = ref(true), dxfVisible = ref(true), whiteModelVisible = ref(true), isLook = ref(false), elRef = ref(), toolBarRef = ref(), dxfSystem = toRaw(props.dxfSystem), domEventRegister = dxfSystem.findComponentByType(DomEventRegister), toolBarPosition = ref({ left: 10, top: 10 }), shortcutKeys = [
+      { "name": "绘制连续线段", "shortcut": "Ctrl + L" },
+      { "name": "绘制线段确认", "shortcut": "Enter" },
+      { "name": "绘制门线", "shortcut": "Ctrl + M" },
+      { "name": "绘制窗户线", "shortcut": "Ctrl + Q" },
+      { "name": "移动线段点", "shortcut": "Ctrl + P" },
+      { "name": "删除线段", "shortcut": "选中 + Delete" },
+      { "name": "删除窗户线", "shortcut": "选中 + Q + Delete" },
+      { "name": "选中", "shortcut": "鼠标左键" },
+      { "name": "多选", "shortcut": "鼠标左键 + Ctrl" },
+      { "name": "取消选中", "shortcut": "鼠标左键 + Alt" },
+      { "name": "框选", "shortcut": "鼠标左键 + 移动" },
+      { "name": "线段同方向合并", "shortcut": "Ctrl + G" },
+      { "name": "线段连接", "shortcut": "选中 + Shift + L" },
+      { "name": "线段交点连接", "shortcut": "选中 + Ctrl + Shift + L" },
+      { "name": "取消命令", "shortcut": "Esc" }
+    ];
+    watchEffect(() => localStorage.setItem("EditorToolPosition", JSON.stringify(toolBarPosition.value)));
+    function setEditorToolPosition(left, top) {
+      const dom = elRef.value, toolBarDom = elRef.value, rect = dom.getBoundingClientRect(), toolBarRect = toolBarDom.getBoundingClientRect(), minX = 0, maxX = toolBarRect.width - rect.width, minY = 0, maxY = toolBarRect.height - rect.height;
+      left = Math.max(minX, Math.min(left, maxX));
+      top = Math.max(minY, Math.min(top, maxY));
+      toolBarPosition.value = { left, top };
+      console.log(left, top);
+    }
+    function setLines(lines) {
+      if (lines) {
+        localStorage.setItem("lines", JSON.stringify(lines));
+        try {
+          dxfSystem.Dxf.set(lines);
+          dxfSystem.Dxf.lineOffset();
+        } catch (error) {
+          console.log(error);
+        }
+      }
+    }
+    async function selectLocalFile() {
+      const data = await SelectLocalFile.json();
+      if (Array.isArray(data)) {
+        localStorage.removeItem("orbitControls");
+        setLines(data);
+      }
+    }
+    function dragMoveHelper(e) {
+      domEventRegister.mouseMoveEventProxylock = true;
+      const cusor = document.body.style.cursor;
+      document.body.style.cursor = "move";
+      const move = (e2) => {
+        setEditorToolPosition(
+          toolBarPosition.value.left + e2.movementX,
+          toolBarPosition.value.top + e2.movementY
+        );
+        e2.stopPropagation();
+        document.body.style.cursor = "move";
+      };
+      const end = () => {
+        document.body.removeEventListener("mousemove", move);
+        document.body.removeEventListener("mouseup", end);
+        document.body.style.cursor = cusor;
+        domEventRegister.mouseMoveEventProxylock = false;
+      };
+      document.body.addEventListener("mousemove", move);
+      document.body.addEventListener("mouseup", end);
+    }
+    watch(originalLineVisible, () => dxfSystem.Variable.set("originalLineVisible", originalLineVisible.value));
+    watch(dxfVisible, () => dxfSystem.Variable.set("dxfVisible", dxfVisible.value));
+    watch(whiteModelVisible, () => dxfSystem.Variable.set("whiteModelVisible", whiteModelVisible.value));
+    dxfSystem.Variable.addEventListener("isLook", (e) => isLook.value = e.value);
+    dxfSystem.Variable.addEventListener("originalLineVisible", (e) => originalLineVisible.value = e.value);
+    dxfSystem.Variable.addEventListener("dxfVisible", (e) => dxfVisible.value = e.value);
+    dxfSystem.Variable.addEventListener("whiteModelVisible", (e) => whiteModelVisible.value = e.value);
+    onMounted(() => {
+      if (localStorage.getItem("EditorToolPosition")) {
+        const { left, top } = JSON.parse(localStorage.getItem("EditorToolPosition") ?? "{}");
+        setEditorToolPosition(left, top);
+      }
+    });
+    onUnmounted(() => {
+      domEventRegister.mouseMoveEventProxylock = false;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "elRef",
+        ref: elRef,
+        class: "pointer-events-none overflow-hidden absolute left-0 top-0 w-full h-full z-[10000] flex flex-row justify-between p-[5px] box-border select-none pointer-events-[all]"
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          (openBlock(), createElementBlock(Fragment, null, renderList(shortcutKeys, (item) => {
+            return createElementVNode("p", {
+              class: "p-[2px_0px] flex justify-between text-right border-b-1 border-b-[rgba(255,255,255,0.1)] last-of-type:border-b-0",
+              key: item.name
+            }, [
+              createTextVNode(toDisplayString(item.name) + ": ", 1),
+              createElementVNode("span", _hoisted_2, toDisplayString(item.shortcut), 1)
+            ]);
+          }), 64))
+        ]),
+        createElementVNode("div", {
+          ref_key: "toolBarRef",
+          ref: toolBarRef,
+          style: normalizeStyle({ left: toolBarPosition.value.left + "px", top: toolBarPosition.value.top + "px" }),
+          class: "pointer-events-auto text-[#333] absolute rounded-[8px] min-w-[140px] z-[1000] bg-white select-none"
+        }, [
+          createElementVNode("div", _hoisted_3, [
+            (openBlock(), createElementBlock("svg", {
+              onMousedown: dragMoveHelper,
+              class: "m-[0px_5px]",
+              fill: "#aaa",
+              width: "20",
+              height: "20",
+              viewBox: "0 0 1024 1024",
+              version: "1.1",
+              xmlns: "http://www.w3.org/2000/svg"
+            }, _cache[2] || (_cache[2] = [
+              createElementVNode("path", { d: "M341.333333 298.666667a85.333333 85.333333 0 1 0 0-170.666667 85.333333 85.333333 0 0 0 0 170.666667z m0 298.666666a85.333333 85.333333 0 1 0 0-170.666666 85.333333 85.333333 0 0 0 0 170.666666z m85.333334 213.333334a85.333333 85.333333 0 1 1-170.666667 0 85.333333 85.333333 0 0 1 170.666667 0z m256-512a85.333333 85.333333 0 1 0 0-170.666667 85.333333 85.333333 0 0 0 0 170.666667z m85.333333 213.333333a85.333333 85.333333 0 1 1-170.666667 0 85.333333 85.333333 0 0 1 170.666667 0z m-85.333333 384a85.333333 85.333333 0 1 0 0-170.666667 85.333333 85.333333 0 0 0 0 170.666667z" }, null, -1)
+            ]), 32)),
+            _cache[3] || (_cache[3] = createElementVNode("span", null, "小工具", -1))
+          ]),
+          createElementVNode("div", _hoisted_4, [
+            createElementVNode("ul", _hoisted_5, [
+              (openBlock(), createElementBlock(Fragment, null, renderList(4, (i) => {
+                return createElementVNode("li", {
+                  key: i,
+                  class: "hover:bg-[#ddd] transition-all rounded-[6px] p-[5px] flex flex-row items-center cursor-pointer"
+                }, _cache[4] || (_cache[4] = [
+                  createElementVNode("div", { class: "p-[5px] bg-[#f0f0f0] rounded-[6px] mr-[10px]" }, [
+                    createElementVNode("img", {
+                      class: "w-[20px] h-[20px]",
+                      src: _imports_0,
+                      alt: "",
+                      srcset: ""
+                    })
+                  ], -1),
+                  createElementVNode("span", null, "直线", -1)
+                ]));
+              }), 64))
+            ]),
+            createElementVNode("div", _hoisted_6, [
+              createVNode(unref(ElCheckbox), {
+                modelValue: dxfVisible.value,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => dxfVisible.value = $event),
+                label: "dxf"
+              }, null, 8, ["modelValue"]),
+              createVNode(unref(ElButton), {
+                size: "small",
+                type: "success",
+                onClick: selectLocalFile
+              }, {
+                default: withCtx(() => _cache[5] || (_cache[5] = [
+                  createTextVNode(" 选择文件 ", -1)
+                ])),
+                _: 1,
+                __: [5]
+              }),
+              createVNode(unref(ElButton), {
+                size: "small",
+                type: "primary",
+                onClick: _cache[1] || (_cache[1] = ($event) => unref(dxfSystem).Dxf.download("test.dxf"))
+              }, {
+                default: withCtx(() => _cache[6] || (_cache[6] = [
+                  createTextVNode(" 下载 DXF ", -1)
+                ])),
+                _: 1,
+                __: [6]
+              })
+            ])
+          ])
+        ], 4)
+      ], 512);
+    };
+  }
+});
+let Editor$1 = class Editor extends Component {
+  static name = "Editor";
+  container = new THREE.Group();
+  get renderer() {
+    return this.parent?.findComponentByName("Renderer");
+  }
+  get dxf() {
+    return this.parent?.findComponentByName("Dxf");
+  }
+  get variable() {
+    return this.parent?.findComponentByName("Variable");
+  }
+  get eventInput() {
+    return this.parent?.findComponentByName("EventInput");
+  }
+  get renderManager() {
+    return this.parent?.findComponentByName("RenderManager");
+  }
+  get domEventRegister() {
+    return this.parent?.findComponentByName("DomEventRegister");
+  }
+  get domContainer() {
+    return this.parent?.findComponentByName("DomContainer");
+  }
+  commandManager = new CommandManager();
+  plane = new THREE.Mesh(new THREE.PlaneGeometry(2e3, 2e3, 2, 2));
+  app;
+  domElement = document.createElement("div");
+  onAddFromParent() {
+    setTimeout(() => this.openEdit(), 10);
+    const grid = new THREE.GridHelper(200, 100, 6710886, 4473924);
+    grid.rotation.x = Math.PI * 0.5;
+    grid.position.z = -0.01;
+    this.container.add(grid);
+    this.container.add(this.plane);
+    this.plane.visible = false;
+    this.app = createApp(_sfc_main, { dxfSystem: this.parent });
+    this.app.mount(this.domElement);
+    const cancelEvent = this.addEventListener("update", () => {
+      if (this.domContainer.domElement.parentElement) {
+        this.domContainer.domElement.parentElement.appendChild(this.domElement);
+        cancelEvent();
+      }
+    });
+  }
+  coords = new THREE.Vector2();
+  pointerPosition = new THREE.Vector2();
+  _exitEditCallBack;
+  /**
+   * 打开编辑器
+   */
+  openEdit() {
+    const renderer = this.renderer, domEventRegister = this.domEventRegister, dxf = this.dxf, orbitControls = renderer.orbitControls, camera = renderer.camera, center = dxf.box.center, cameraPosition = renderer.camera.position.clone(), target = orbitControls?.target?.clone(), size = new THREE.Vector2(), raycaster = new THREE.Raycaster(), coords = this.coords, pointerPosition = this.pointerPosition;
+    this.container.position.z = dxf.originalZAverage;
+    renderer.scene.add(this.container);
+    camera.position.set(center.x, center.y, 14);
+    if (orbitControls) {
+      orbitControls.target.set(center.x, center.y, 0);
+      orbitControls.enableRotate = false;
+    }
+    const mousemoveFun = () => {
+      renderer.renderer.getSize(size);
+      const x = domEventRegister.pointer.x / size.x * 2 - 1;
+      const y = -(domEventRegister.pointer.y / size.y * 2 - 1);
+      coords.set(x, y);
+      raycaster.setFromCamera(coords, renderer.camera);
+      const intersections = raycaster.intersectObject(this.plane);
+      if (intersections.length) {
+        pointerPosition.copy(intersections[0].point);
+        this.dispatchEvent({
+          type: "pointerPositionChange",
+          position: pointerPosition
+        });
+      }
+    };
+    domEventRegister.addEventListener("mousemove", mousemoveFun);
+    this.commandManager.disabled = false;
+    this.commandManager.start("default");
+    this._exitEditCallBack = () => {
+      domEventRegister.removeEventListener("mousemove", mousemoveFun);
+      camera.position.copy(cameraPosition);
+      orbitControls.enableRotate = true;
+      orbitControls.target.copy(target);
+    };
+  }
+  /**
+   * 退出编辑
+   */
+  exitEdit() {
+    if (typeof this._exitEditCallBack === "function") {
+      this._exitEditCallBack();
+      this._exitEditCallBack = void 0;
+      this.commandManager.disabled = true;
+    }
+  }
+  destroy() {
+    this.exitEdit();
+    this.renderer.scene.remove(this.container);
+    this.domElement.remove();
+    this.app?.unmount();
+  }
+};
+class RenderManager extends Component {
+  static name = "RenderManager";
+  container = new THREE.Group();
+  lines = [];
+  pointVirtualGrid = new PointVirtualGrid();
+  quadtree = new Quadtree(new Box2());
+  actionHistory = /* @__PURE__ */ new Set();
+  onAddFromParent() {
+    const dxfLineModel = this.dxfLineModel;
+    this.editor.container.add(this.container);
+    this.editor.container.add(dxfLineModel.dxfModelGroup);
+    dxfLineModel.dxfLineModel.material = new THREE.LineBasicMaterial({
+      transparent: true,
+      opacity: 0.5,
+      color: 16777215
+    });
+    dxfLineModel.addEventListener("modelUpdate", (e) => {
+      e.model.position.z = 0;
+      dxfLineModel.dxfDoorsLineModel.visible = false;
+    });
+    this.variable.addEventListener("dxfVisible", (e) => dxfLineModel.dxfModelGroup.visible = e.value);
+    this.dxf.addEventListener("createGroup", () => this.reset());
+    this.reset();
+  }
+  updatedMode = null;
+  /** 重新设置数据
+   */
+  reset() {
+    if (this.updatedMode === "self") {
+      this.updatedMode = null;
+      return;
+    } else {
+      this.updatedMode = "dxf";
+    }
+    this.pointVirtualGrid = new PointVirtualGrid();
+    const box = this.dxf.box.clone().expansion(Math.max(this.dxf.box.width, this.dxf.box.height) * 2);
+    if (box.width === 0 || box.height === 0) box.set(-200, -200, 200, 200);
+    this.quadtree = new Quadtree(box);
+    this.lines.length = 0;
+    this.dxf.lineSegments.forEach((line) => {
+      if (line.userData.isDoor && !line.userData.doorDirectConnection) return;
+      this.addLine(line.clone());
+    });
+    this.dxf.doorLineSegment.forEach((line) => {
+      const door = line.clone();
+      door.userData = {
+        isDoor: true,
+        doorDirectConnection: true
+      };
+      this.addLine(door);
+    });
+    this.draw();
+  }
+  /** 添加线段
+   * @param line 
+   */
+  addLine(line) {
+    if (!line.userData) line.userData = {};
+    this.lines.push(line);
+    this.pointVirtualGrid.insert(line.start, line);
+    this.pointVirtualGrid.insert(line.end, line);
+    const quadtreeNode = {
+      line,
+      userData: void 0
+    };
+    line.userData.quadtreeNode = quadtreeNode;
+    this.quadtree.insert(quadtreeNode);
+    this.actionHistory.add({
+      type: "addLine",
+      data: [line]
+    });
+  }
+  /**
+   * 批量添加
+   * @param lines 
+   */
+  addLines(lines) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      this.lines.push(line);
+      this.pointVirtualGrid.insert(line.start, line);
+      this.pointVirtualGrid.insert(line.end, line);
+      const quadtreeNode = {
+        line,
+        userData: void 0
+      };
+      line.userData.quadtreeNode = quadtreeNode;
+      this.quadtree.insert(quadtreeNode);
+    }
+    this.actionHistory.add({
+      type: "addLine",
+      data: [...lines]
+    });
+  }
+  /** 移除线段
+   * @param line 
+   */
+  removeLine(line) {
+    line.userData.quadtreeNode && this.quadtree.remove(line.userData.quadtreeNode);
+    this.pointVirtualGrid.remove(line.start);
+    this.pointVirtualGrid.remove(line.end);
+    const index = this.lines.indexOf(line);
+    this.lines.splice(index, 1);
+    this.draw();
+    this.actionHistory.add({
+      type: "removeLine",
+      data: [line]
+    });
+  }
+  /**
+   * 绘制
+   */
+  draw(synchronize = true) {
+    this.container.clear();
+    const position = [], doorPosition = [], windowPosition = [];
+    this.lines.forEach((line) => {
+      line.points.forEach((p) => {
+        if (line.userData.isDoor) doorPosition.push(p.x, p.y, 0);
+        else position.push(p.x, p.y, 0);
+      });
+      if (line.userData.isWindow && line.userData.drawDoorData) {
+        line.userData.drawDoorData.forEach(({ width, p }) => {
+          const center = Point.from(p), direction = line.direction(), start = center.clone().add(direction.clone().multiplyScalar(width * 0.5)), end = center.clone().add(direction.clone().multiplyScalar(-width * 0.5));
+          windowPosition.push(start.x, start.y, 1e-3);
+          windowPosition.push(end.x, end.y, 1e-3);
+        });
+      }
+    });
+    position.length && this.renderer.createLineSegments({
+      position
+    }, position.length / 3, {
+      color: 5745151
+    }, this.container);
+    doorPosition.length && this.renderer.createLineSegments({
+      position: doorPosition
+    }, doorPosition.length / 3, {
+      color: 16776960
+    }, this.container);
+    windowPosition.length && this.renderer.createLineSegments({
+      position: windowPosition
+    }, windowPosition.length / 3, {
+      color: 16711935
+    }, this.container);
+    synchronize && this.synchronizeDxf();
+  }
+  /** 获取鼠标当前点, 吸附后的点
+   * @param point 
+   * @returns 
+   */
+  adsorption(radius = 0.1, pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree) {
+    const editor = this.parent?.findComponentByName("Editor"), point = Point.from(editor.pointerPosition);
+    const p = pointVirtualGrid.queryCircle(point, radius).sort((a, b) => a.point.distance(point) - b.point.distance(point));
+    if (p.length) return {
+      point: new THREE.Vector3(p[0].point.x, p[0].point.y, 0),
+      find: true,
+      mode: "point",
+      line: p[0].userData
+    };
+    let result = quadtree.queryCircle(point, radius);
+    if (result.length) {
+      let projectPoints = result.map((res) => res.line.projectPoint(point));
+      projectPoints.sort((a, b) => {
+        if (a && b) return a.distance(point) - b.distance(point);
+        return 0;
+      });
+      result = result.filter((_, i) => !!projectPoints[i]);
+      projectPoints = projectPoints.filter((_, i) => !!projectPoints[i]);
+      return {
+        point: new THREE.Vector3(projectPoints[0].x, projectPoints[0].y, 0),
+        find: true,
+        mode: "line",
+        line: result[0].line
+      };
+    }
+    return {
+      point: new THREE.Vector3(editor.pointerPosition.x, editor.pointerPosition.y, 0),
+      find: false
+    };
+  }
+  /** 创建几何体
+   * @param rectangle 
+   */
+  createGeometry(map, count) {
+    const geometry = new THREE.BufferGeometry();
+    Object.keys(map).forEach((k) => {
+      geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(map[k]), map[k].length / count));
+    });
+    return geometry;
+  }
+  /**
+   * 转为json
+   */
+  toJson() {
+    return this.lines.map((line) => {
+      const userData = line.userData;
+      const drawDoorData = userData.drawDoorData;
+      return {
+        start: line.start.toJson(),
+        end: line.end.toJson(),
+        insetionArr: [],
+        isDoor: userData.isDoor,
+        doorDirectConnection: userData.isDoor,
+        isWindow: userData.isWindow,
+        drawDoorData: drawDoorData && drawDoorData.map((w) => ({
+          p: { x: w.p.x, y: w.p.y, z: w.p.z },
+          width: w.width,
+          full: w.full
+        }))
+      };
+    });
+  }
+  _timer = null;
+  /**
+   * 同步到dxf
+   */
+  synchronizeDxf() {
+    if (this.updatedMode === "dxf") {
+      this.updatedMode = null;
+      return;
+    }
+    if (this._timer) clearTimeout(this._timer);
+    setTimeout(() => {
+      this.updatedMode = "self";
+      const dxf = this.dxf;
+      const json = this.toJson();
+      dxf.set(json).then(() => {
+        dxf.lineOffset();
+      });
+    }, 10);
+  }
+  get renderer() {
+    return this.parent?.findComponentByName("Renderer");
+  }
+  get dxf() {
+    return this.parent?.findComponentByName("Dxf");
+  }
+  get variable() {
+    return this.parent?.findComponentByName("Variable");
+  }
+  get eventInput() {
+    return this.parent?.findComponentByName("EventInput");
+  }
+  get editor() {
+    return this.parent?.findComponentByName("Editor");
+  }
+  get dxfLineModel() {
+    return this.parent?.findComponentByName("DxfLineModel");
+  }
+}
+class DrawDoorLine extends CommandFlowComponent {
+  static name = "DrawDoorLine";
+  container = new THREE.Group();
+  interruptKeys = ["escape"];
+  shortcutKeys = ["control", "m"];
+  commandName = "draw-door-line";
+  onAddFromParent(parent) {
+    const editor = parent.findComponentByName("Editor"), eventInput = editor.eventInput, commandManager = editor.commandManager;
+    this.editor.container.add(this.container);
+    const commandFlow = this.commandManager.addCommandFlow("draw-door-line").add(this.createInterrupt()).add(this.createCursor("no-drop")).add(this.selectPoint.bind(this));
+    eventInput.addKeyCombination(this.commandName, this.shortcutKeys);
+    commandFlow.addEventListener("finally", this.createFinally());
+    commandFlow.addEventListener("completed", (e) => this.completed(e.data));
+    eventInput.addCancelDefaultBehavior(() => eventInput.isOnlyKeyDowns(this.shortcutKeys));
+    eventInput.addEventListener("codeChange", async () => {
+      eventInput.isKeyCombination(this.commandName) && await commandManager.start(this.commandName);
+    });
+  }
+  /** 选择点
+   * @param next 
+   */
+  selectPoint(next) {
+    let editor = this.parent?.findComponentByName("Editor"), start = null, circle = new THREE.Mesh(new THREE.SphereGeometry(0.05), new THREE.MeshBasicMaterial({ color: 65280 })), line = new Lines([], 16711935), auxiliaryLine = new Lines([
+      new THREE.Vector3(-1e4, 0, 0),
+      new THREE.Vector3(1e4, 0, 0),
+      new THREE.Vector3(0, -1e4, 0),
+      new THREE.Vector3(0, 1e4, 0)
+    ], 16711935);
+    auxiliaryLine.material = new THREE.LineDashedMaterial({
+      color: 4235007,
+      dashSize: 0.1,
+      gapSize: 0.1,
+      linewidth: 0.1
+    });
+    this.container.add(line);
+    let currentPoint = null;
+    this.addEventRecord(
+      "clear",
+      editor.addEventListener("pointerPositionChange", () => {
+        const { point, find } = editor.renderManager.adsorption(0.05);
+        start && line.setPoint(start, point);
+        if (find) {
+          circle.position.set(point.x, point.y, 0);
+          this.container.add(circle);
+          this.domElement.style.cursor = "none";
+          currentPoint = point.clone();
+        } else {
+          currentPoint = null;
+          circle.removeFromParent();
+          this.domElement.style.cursor = "no-drop";
+        }
+      }),
+      editor.eventInput.addEventListener("codeChange", async () => {
+        if (editor.eventInput.isKeyDown("mouse_0") && currentPoint) {
+          if (!start) {
+            start = currentPoint.clone();
+            return;
+          }
+          next([start.clone(), currentPoint.clone()]);
+        }
+      }),
+      function() {
+        line.removeFromParent();
+        circle.removeFromParent();
+        auxiliaryLine.removeFromParent();
+      }
+    );
+  }
+  /** 执行完成
+   */
+  completed(points) {
+    const editor = this.editor, lines = [];
+    for (let i = 0; i < points.length; i += 2) {
+      const line = new LineSegment(Point.from(points[i]), Point.from(points[i + 1]));
+      line.userData.isDoor = true;
+      line.userData.doorDirectConnection = true;
+      lines.push(line);
+    }
+    editor.renderManager.addLines(lines);
+    editor.renderManager.draw();
+  }
+}
+class DrawWindow extends CommandFlowComponent {
+  static name = "DrawWindow";
+  container = new THREE.Group();
+  interruptKeys = ["escape"];
+  shortcutKeys = ["control", "q"];
+  commandName = "draw-window-line";
+  onAddFromParent() {
+    this.editor.container.add(this.container);
+    const commandFlow = this.commandManager.addCommandFlow(this.commandName).add(this.createInterrupt()).add(this.createCursor("no-drop")).add(this.selectPointStart.bind(this)).add(this.selectPointEnd.bind(this));
+    commandFlow.addEventListener("finally", this.createFinally());
+    commandFlow.addEventListener("completed", (e) => this.completed(e.data));
+    this.eventInput.addKeyCombination(this.commandName, this.shortcutKeys);
+    this.eventInput.addEventListener("codeChange", async () => this.eventInput.isKeyCombination(this.commandName) && await this.commandManager.start(this.commandName));
+    this.eventInput.addCancelDefaultBehavior(() => this.eventInput.isOnlyKeyDowns(this.shortcutKeys));
+  }
+  /** 选择开始点
+   * @param next 
+   */
+  selectPointStart(next) {
+    let currentPoint = null, circle = new THREE.Mesh(new THREE.SphereGeometry(0.05), new THREE.MeshBasicMaterial({ color: 16711935 })), currentLine = null;
+    this.addEventRecord("selectPointStart").add(this.editor.addEventListener("pointerPositionChange", () => {
+      const { point, line, find } = this.editor.renderManager.adsorption();
+      if (find) {
+        this.domElement.style.cursor = "none";
+        circle.position.copy(point);
+        currentLine = line;
+        currentPoint = point.clone();
+        this.container.add(circle);
+      } else {
+        this.domElement.style.cursor = "no-drop";
+        currentPoint = null;
+        circle.removeFromParent();
+      }
+    })).add(this.eventInput.addEventListener("codeChange", () => {
+      if (this.eventInput.isKeyDown("mouse_0") && currentPoint) {
+        this.canceEventRecord("selectPointStart");
+        next({ point: currentPoint, line: currentLine });
+      }
+    }));
+    this.addEventRecord("clear").add(() => circle.removeFromParent());
+  }
+  /** 选择结束点
+   * @param next 
+   */
+  selectPointEnd(next, { point, line }) {
+    let currentPoint = null, circle = new THREE.Mesh(new THREE.SphereGeometry(0.05), new THREE.MeshBasicMaterial({ color: 16711935 }));
+    this.addEventRecord("clear").add(() => circle.removeFromParent()).add(this.editor.addEventListener("pointerPositionChange", () => {
+      const { point: point2, find, line: l } = this.editor.renderManager.adsorption();
+      if (find && l === line) {
+        this.domElement.style.cursor = "none";
+        circle.position.copy(point2);
+        currentPoint = point2.clone();
+        this.container.add(circle);
+      } else {
+        this.domElement.style.cursor = "no-drop";
+        currentPoint = null;
+        circle.removeFromParent();
+      }
+    })).add(this.eventInput.addEventListener("codeChange", () => {
+      if (this.eventInput.isKeyDown("mouse_0") && currentPoint) next({ line, start: point, end: currentPoint });
+    }));
+  }
+  /** 执行完成
+   */
+  completed(data) {
+    const start = data.start, end = data.end, line = data.line, win = new LineSegment(Point.from(start), Point.from(end)), center = win.center, len = win.length();
+    line.userData.isWindow = true;
+    if (!line.userData.drawDoorData) line.userData.drawDoorData = [];
+    line.userData.drawDoorData.push({
+      p: new THREE.Vector3(center.x, center.y, 0),
+      width: len,
+      full: Math.abs(len - line.length()) < 0.01
+    });
+    this.renderManager.draw();
+  }
+}
+class PointDrag extends CommandFlowComponent {
+  static name = "PointDrag";
+  container = new THREE.Group();
+  interruptKeys = ["escape"];
+  shortcutKeys = ["control", "p"];
+  commandName = "point";
+  onAddFromParent() {
+    this.editor.container.add(this.container);
+    this.container.position.z = 1e-3;
+    const commandFlow = this.commandManager.addCommandFlow(this.commandName).add(this.createInterrupt()).add(this.createCursor("crosshair")).add(this.selectPoint.bind(this)).add(this.drag.bind(this));
+    commandFlow.addEventListener("finally", this.createFinally());
+    commandFlow.addEventListener("completed", (e) => this.completed(e.data));
+    this.eventInput.addKeyCombination(this.commandName, this.shortcutKeys);
+    this.eventInput.addEventListener("codeChange", async () => this.eventInput.isKeyCombination(this.commandName) && await this.commandManager.start(this.commandName));
+    this.eventInput.addCancelDefaultBehavior(() => this.eventInput.isOnlyKeyDowns(this.shortcutKeys));
+  }
+  /** 选择开始点
+   * @param next 
+   */
+  selectPoint(next) {
+    let currentPoint = null, circle = new THREE.Mesh(new THREE.SphereGeometry(0.05), new THREE.MeshBasicMaterial({ color: 16711935 })), currentLine = null;
+    this.addEventRecord("selectPointStart").add(this.editor.addEventListener("pointerPositionChange", () => {
+      const { point, line, find, mode } = this.editor.renderManager.adsorption();
+      if (find && mode === "point") {
+        this.domElement.style.cursor = "none";
+        circle.position.copy(point);
+        currentLine = line;
+        currentPoint = point.clone();
+        this.container.add(circle);
+      } else {
+        this.domElement.style.cursor = "no-drop";
+        currentPoint = null;
+        circle.removeFromParent();
+      }
+    })).add(this.eventInput.addEventListener("codeChange", () => {
+      if (this.eventInput.isKeyDown("mouse_0") && currentPoint) {
+        this.canceEventRecord("selectPointStart");
+        circle.material.color.set(65280);
+        next({ point: currentPoint, line: currentLine });
+      }
+    }));
+    this.addEventRecord("clear").add(() => circle.removeFromParent());
+  }
+  /** 拖拽点
+   * @description 拖拽点到指定位置
+   * @param next 
+   * @param param1 
+   */
+  drag(next, { point, line }) {
+    this.domElement.style.cursor = "crosshair";
+    const mode = line.start.equal(Point.from(point)) ? "start" : "end", start = mode == "start" ? new THREE.Vector3(line.end.x, line.end.y, 0) : new THREE.Vector3(line.start.x, line.start.y, 0), end = point.clone(), lines = new Lines([start, end], 16711935), circle = new THREE.Mesh(new THREE.SphereGeometry(0.03), new THREE.MeshBasicMaterial({ color: 16711935 }));
+    this.container.add(lines);
+    this.addEventRecord("clear").add(this.editor.addEventListener("pointerPositionChange", () => {
+      let { point: point2, find } = this.editor.renderManager.adsorption(), cursor = "none";
+      if (point2) {
+        if (this.eventInput.isKeyDown("shift")) {
+          const p = line.projectPoint(Point.from(point2), false);
+          point2.set(p?.x ?? point2.x, p?.y ?? point2.y, 0);
+          find = true;
+          cursor = "crosshair";
+        }
+        if (find) {
+          circle.position.copy(point2);
+          this.container.add(circle);
+        } else {
+          circle.removeFromParent();
+          cursor = "crosshair";
+        }
+        end.copy(point2);
+        lines.setPoint(start, end);
+        this.domElement.style.cursor = cursor;
+      }
+    })).add(this.eventInput.addEventListener("codeChange", () => {
+      if (this.eventInput.isKeyDown("mouse_0")) {
+        this.canceEventRecord("selectPointStart");
+        next({ point: end, line, mode });
+      }
+    })).add(() => circle.removeFromParent()).add(() => lines.removeFromParent());
+  }
+  /** 执行完成
+   */
+  completed(data) {
+    const { line, point, mode } = data;
+    this.renderManager.removeLine(line);
+    if (mode === "end") line.end.set(point.x, point.y);
+    else if (mode === "start") line.start.set(point.x, point.y);
+    this.renderManager.addLine(line);
+    this.renderManager.draw();
+  }
+}
+function Editor2(dxfSystem) {
+  dxfSystem.addComponent(new Editor$1());
+  dxfSystem.addComponent(new RenderManager());
+  dxfSystem.addComponent(new Default());
+  dxfSystem.addComponent(new DrawLine());
+  dxfSystem.addComponent(new DrawDoorLine());
+  dxfSystem.addComponent(new DrawWindow());
+  dxfSystem.addComponent(new PointDrag());
+}
+export {
+  Editor2 as Editor
+};