@mlightcad/cad-simple-viewer 1.0.0

package/dist/index.js

@@ -0,0 +1,2422 @@
+import { AcCmEventManager as m, AcGePoint2d as u, AcGeBox2d as N, AcCmColor as k, AcGeBox3d as $, AcDbDatabase as J, AcDbFileType as G, acdbHostApplicationServices as W, AcDbViewport as K, AcDbRasterImage as Z, AcDbRay as Q, AcDbXline as tt, AcDbHatch as j, AcGePolyline2d as et, AcDbLine as st, AcDbTextStyleTableRecord as it, AcDbMText as nt, AcGiMTextAttachmentPoint as ot, AcGePoint3d as rt, AcGeLoop2d as at, AcGeCircArc2d as ct, AcGeMathUtil as T, AcGeLine2d as ht, AcDbArc as lt, AcGeLine3d as M } from "@mlightcad/data-model";
+import { AcSvgRenderer as dt } from "@mlightcad/svg-renderer";
+import { find as ut, findIndex as mt, defaults as _t } from "lodash-es";
+import { AcTrBaseView as wt, AcTrBatchedGroup as pt, AcTrRenderer as ft, AcTrViewportView as yt } from "@mlightcad/three-renderer";
+import * as f from "three";
+import vt from "three/examples/jsm/libs/stats.module";
+import { AxesGizmo as gt, ObjectPosition as xt } from "@mlightcad/three-viewcube";
+class bt {
+  /**
+   * Construct one context to bind one drawing database with its viewer
+   * @param view Input the view used to show the specified drawing
+   * @param doc Input the document associated with the drawing database
+   */
+  constructor(t, e) {
+    this._view = t, this._doc = e, e.database.events.entityAppended.addEventListener((s) => {
+      this.view.addEntity(s.entity);
+    }), e.database.events.entityModified.addEventListener((s) => {
+      this.view.updateEntity(s.entity);
+    }), e.database.events.layerModified.addEventListener((s) => {
+      this._view.setLayerVisibility(s.layer.name, !s.layer.isOff);
+    }), e.database.events.headerSysVarChanged.addEventListener((s) => {
+      s.name == "pdmode" && this._view.rerenderPoints(s.database.pdmode);
+    }), t.selectionSet.events.selectionAdded.addEventListener((s) => {
+      t.highlight(s.ids);
+    }), t.selectionSet.events.selectionRemoved.addEventListener((s) => {
+      t.unhighlight(s.ids);
+    });
+  }
+  get view() {
+    return this._view;
+  }
+  get doc() {
+    return this._doc;
+  }
+}
+class x {
+  constructor() {
+    this.events = {
+      commandWillStart: new m(),
+      commandEnded: new m()
+    }, this._globalName = "", this._localName = "";
+  }
+  /**
+   * The global or untranslated name associated with the command.
+   */
+  get globalName() {
+    return this._globalName;
+  }
+  set globalName(t) {
+    this._globalName = t;
+  }
+  /**
+   * The local or translated name associated with the command.
+   */
+  get localName() {
+    return this._localName;
+  }
+  set localName(t) {
+    this._localName = t;
+  }
+  /**
+   * Trigger this command. The children class should not override this method to keep event notification
+   * work correctly.
+   * @param context Input current context to execute this command.
+   */
+  tirgger(t) {
+    this.events.commandWillStart.dispatch({ command: this }), this.execute(t), this.events.commandEnded.dispatch({ command: this });
+  }
+  /**
+   * Execute this command. The children class should override this method to add business logic of this command.
+   * @param _context Input current context to execute this command.
+   */
+  execute(t) {
+  }
+}
+class St {
+  constructor(t) {
+    this._index = 0, this._commands = [], t.forEach((e) => {
+      const s = e.groupName;
+      e.commandsByGlobalName.forEach((n) => {
+        this._commands.push({
+          command: n,
+          commandGroup: s
+        });
+      });
+    });
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  /**
+   * Return command object the iterator currently points to. If the iterator is at the beginning, then the
+   * first object is returned. If the iterator has already gone past the last entry, then null is returned.
+   */
+  get command() {
+    return this._index < this._commands.length ? this._commands[this._index].command : null;
+  }
+  /**
+   * Return the name of the command object the iterator currently points to. If the iterator is at the
+   * beginning, then the first object is returned. If the iterator has already gone past the last entry,
+   * then null is returned.
+   */
+  get commandGroup() {
+    return this._index < this._commands.length ? this._commands[this._index].commandGroup : null;
+  }
+  /**
+   * Increment the iterator to the next entry.
+   * @returns Return the next entry
+   */
+  next() {
+    for (; this._index < this._commands.length; ) {
+      const t = this._commands[this._index];
+      return this._index += 1, { value: t, done: !1 };
+    }
+    return { value: null, done: !0 };
+  }
+}
+const p = class p {
+  constructor() {
+    this._commandsByGroup = [], this._systemCommandGroup = {
+      groupName: p.SYSTEMT_COMMAND_GROUP_NAME,
+      commandsByGlobalName: /* @__PURE__ */ new Map(),
+      commandsByLocalName: /* @__PURE__ */ new Map()
+    }, this._defaultCommandGroup = {
+      groupName: p.DEFAUT_COMMAND_GROUP_NAME,
+      commandsByGlobalName: /* @__PURE__ */ new Map(),
+      commandsByLocalName: /* @__PURE__ */ new Map()
+    }, this._commandsByGroup.push(this._systemCommandGroup), this._commandsByGroup.push(this._defaultCommandGroup);
+  }
+  static get instance() {
+    return p._instance || (p._instance = new p()), p._instance;
+  }
+  addCommand(t, e, s, n) {
+    if (!e)
+      throw new Error(
+        "[AcEdCommandStack] The global name of the command is required!"
+      );
+    s || (s = e);
+    let o = this._defaultCommandGroup;
+    if (t) {
+      const r = this._commandsByGroup.find(
+        (a) => a.groupName == t
+      );
+      r ? o = r : o = {
+        groupName: t,
+        commandsByGlobalName: /* @__PURE__ */ new Map(),
+        commandsByLocalName: /* @__PURE__ */ new Map()
+      };
+    }
+    if (o.commandsByGlobalName.has(e))
+      throw new Error(
+        `[AcEdCommandStack] The command with global name '${e}' already exists!`
+      );
+    if (o.commandsByLocalName.has(s))
+      throw new Error(
+        `[AcEdCommandStack] The command with local name '${s}' already exists!`
+      );
+    o.commandsByGlobalName.set(e, n), o.commandsByLocalName.set(s, n), n.globalName = e, n.localName = s;
+  }
+  /**
+   * Return an iterator that can be used to traverse all of command objects in this command stack
+   * (that is, the iterator iterates through all commands in all groups).
+   * @returns Return an iterator that can be used to traverse all of command objects in this command
+   * stack.
+   */
+  iterator() {
+    return new St(this._commandsByGroup);
+  }
+  /**
+   * Search through all of the global and untranslated names in all of the command groups in the command
+   * stack starting at the top of the stack trying to find a match with cmdName. If a match is found, the
+   * matched AcEdCommand object is returned. Otherwise undefined is returned to indicate that the command
+   * could not be found. If more than one command of the same name is present in the command stack (that
+   * is, in separate command groups), then the first one found is used.
+   * @param cmdName Input the command name to search for
+   * @returns Return the matched AcEdCommand object if a match is found. Otherwise, return undefined.
+   */
+  lookupGlobalCmd(t) {
+    let e;
+    for (const s of this._commandsByGroup)
+      if (e = s.commandsByGlobalName.get(t), e) break;
+    return e;
+  }
+  /**
+   * Search through all of the local and translated names in all of the command groups in the command stack
+   * starting at the top of the stack trying to find a match with cmdName. If a match is found, the matched
+   * AcEdCommand object is returned. Otherwise undefined is returned to indicate that the command could not
+   * be found. If more than one command of the same name is present in the command stack (that is, in
+   * separate command groups), then the first one found is used.
+   * @param cmdName Input the command name to search for
+   * @returns Return the matched AcEdCommand object if a match is found. Otherwise, return undefined.
+   */
+  lookupLocalCmd(t) {
+    let e;
+    for (const s of this._commandsByGroup)
+      if (e = s.commandsByLocalName.get(t), e) break;
+    return e;
+  }
+  /**
+   * Remove the command with the global and untranslated name `cmdGlobalName` from the `cmdGroupName`
+   * command group. Return true if successful. Return false if no command with the global and untranslated
+   * name `cmdGlobalName` is found in the `cmdGroupName` command group.
+   * @param cmdGroupName Input the name of the command group containing the command to be removed
+   * @param cmdGlobalName Input the command name which is to be removed from cmdGroupName
+   * @returns Return true if successful. Return false if no command with the global and untranslated
+   * name `cmdGlobalName` is found in the `cmdGroupName` command group.
+   */
+  removeCmd(t, e) {
+    for (const s of this._commandsByGroup)
+      if (s.groupName == t)
+        return s.commandsByGlobalName.delete(e);
+    return !1;
+  }
+  /**
+   * Remove the command group with the name `GroupName` from the command stack and delete the command group
+   * dictionary object and all the AcEdCommand objects stored within it.
+   * @param groupName Input the name of the command group to be removed from the command stack.
+   * @returns Return true if successful. Return false if no command group is found with the name `GroupName`.
+   */
+  removeGroup(t) {
+    let e = -1;
+    return this._commandsByGroup.some((s, n) => (e = n, s.groupName == t)), e >= 0 ? (this._commandsByGroup.splice(e, 1), !0) : !1;
+  }
+};
+p.SYSTEMT_COMMAND_GROUP_NAME = "ACAD", p.DEFAUT_COMMAND_GROUP_NAME = "USER";
+let _ = p;
+function Bt(i) {
+  return { all: i = i || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var s = i.get(t);
+    s ? s.push(e) : i.set(t, [e]);
+  }, off: function(t, e) {
+    var s = i.get(t);
+    s && (e ? s.splice(s.indexOf(e) >>> 0, 1) : i.set(t, []));
+  }, emit: function(t, e) {
+    var s = i.get(t);
+    s && s.slice().map(function(n) {
+      n(e);
+    }), (s = i.get("*")) && s.slice().map(function(n) {
+      n(t, e);
+    });
+  } };
+}
+const v = Bt();
+function ve(i) {
+  v.emit("message", {
+    message: i,
+    type: "warning"
+  });
+}
+var C = /* @__PURE__ */ ((i) => (i[i.NoSpecialCursor = -1] = "NoSpecialCursor", i[i.Crosshair = 0] = "Crosshair", i[i.RectCursor = 1] = "RectCursor", i[i.RubberBand = 2] = "RubberBand", i[i.NotRotated = 3] = "NotRotated", i[i.TargetBox = 4] = "TargetBox", i[i.RotatedCrosshair = 5] = "RotatedCrosshair", i[i.CrosshairNoRotate = 6] = "CrosshairNoRotate", i[i.Invisible = 7] = "Invisible", i[i.EntitySelect = 8] = "EntitySelect", i[i.Parallelogram = 9] = "Parallelogram", i[i.EntitySelectNoPersp = 10] = "EntitySelectNoPersp", i[i.PkfirstOrGrips = 11] = "PkfirstOrGrips", i[i.CrosshairDashed = 12] = "CrosshairDashed", i[i.Grab = 13] = "Grab", i))(C || {});
+class Mt {
+  constructor() {
+    this._cursorMap = /* @__PURE__ */ new Map(), this._cursorMap.set(
+      0,
+      this.createRectCrossIcon(10, 10)
+    );
+  }
+  setCursor(t, e) {
+    if (t <= -1)
+      e.style.cursor = "default";
+    else if (t == 13)
+      e.style.cursor = "grab";
+    else {
+      const s = this._cursorMap.get(t);
+      s && (e.style.cursor = s);
+    }
+  }
+  /**
+   * Encode SVG string to one cursor defined using url() in CSS
+   * @param svgString Input svg string
+   * @param xOffset Input x offset for cursor hotspot
+   * @param yOffset Input y offset for cursor hotspot
+   * @returns
+   */
+  encodeSvg(t, e = 0, s = 0) {
+    return `url('data:image/svg+xml;base64,${btoa(t)}') ${e} ${s}, auto`;
+  }
+  /**
+   * Create one svg icon with one rectangle plus two cross lines
+   * @param rectSize Input the width and height of rectangle
+   * @param crossLineLength Input the length of one cross line
+   * @param lineColor Input line color
+   * @returns Return svg string of the icon
+   */
+  createRectCrossIcon(t, e, s = "white") {
+    const n = t / 2, o = t + 2 * e, r = `
+      <svg xmlns="http://www.w3.org/2000/svg" width="${o}" height="${o}" viewBox="0 0 ${o} ${o}">
+        <rect x="${e}" y="${e}" width="${t}" height="${t}" fill="none" stroke="${s}" />
+        <line x1="${n + e}" y1="0" x2="${n + e}" y2="${e}" stroke="${s}" />
+        <line x1="${t + e}" y1="${n + e}" x2="${t + 2 * e}" y2="${n + e}" stroke="${s}" />
+        <line x1="${n + e}" y1="${t + e}" x2="${n + e}" y2="${t + 2 * e}" stroke="${s}" />
+        <line x1="0" y1="${n + e}" x2="${e}" y2="${n + e}" stroke="${s}" />
+      </svg>
+    `;
+    return this.encodeSvg(r, n + e, n + e);
+  }
+}
+class V {
+  constructor(t) {
+    this.active = !1, this.isResolvedOrRejected = !1, this.onKeyDown = (e) => {
+      e.code === "Escape" && this.reject("Canceled by user!");
+    }, this.view = t;
+  }
+  get isActive() {
+    return this.active;
+  }
+  activate() {
+    this.isActive && console.warn("Something wrong here!"), this.active = !0, this.view.canvas.addEventListener("keydown", this.onKeyDown);
+  }
+  deactivate() {
+    this.active = !1, this.view.canvas.removeEventListener("keydown", this.onKeyDown);
+  }
+  resolve(t) {
+    this.deactivate(), this._resolve && !this.isResolvedOrRejected && (this._resolve(t), this.isResolvedOrRejected = !0);
+  }
+  reject(t) {
+    this.deactivate(), this._reject && !this.isResolvedOrRejected && (this._reject(t), this.isResolvedOrRejected = !0);
+  }
+  /**
+   * Start inputting
+   */
+  async start() {
+    return this.isResolvedOrRejected = !1, new Promise((t, e) => {
+      this._resolve = t, this._reject = e, this.activate();
+    });
+  }
+}
+class Et extends V {
+  constructor(t) {
+    super(t), this.events = {
+      update: new m()
+    }, this.onMouseMove = (e) => {
+      this.curPos.set(e.clientX, e.clientY), this.events.update.dispatch();
+    }, this.curPos = new u();
+  }
+  activate() {
+    super.activate(), this.view.canvas.addEventListener("mousemove", this.onMouseMove);
+  }
+  deactivate() {
+    super.deactivate(), this.view.canvas.removeEventListener("mousemove", this.onMouseMove);
+  }
+}
+class Lt {
+  constructor(t) {
+    this.onUpdate = () => {
+      this.update();
+    }, this._view = t, this._jigLoop = new Et(t), this._jigLoop.events.update.addEventListener(this.onUpdate);
+  }
+  get view() {
+    return this._view;
+  }
+  resolve(t) {
+    this._jigLoop.events.update.removeEventListener(this.onUpdate), this._jigLoop.resolve(t);
+  }
+  reject(t) {
+    this._jigLoop.events.update.removeEventListener(this.onUpdate), this._jigLoop.reject(t);
+  }
+  async drag() {
+    const t = this._jigLoop.start(), e = this.sampler();
+    await Promise.allSettled([t, e]);
+  }
+  async sampler() {
+  }
+  update() {
+  }
+}
+const Dt = 16777215, It = "1px";
+class Ct extends V {
+  constructor(t) {
+    super(t), this.mouseDown = !1, this.mouseMove = !1, this.mouseDownPositionX = -1, this.mouseDownPositionY = -1, this.mousedown = (e) => {
+      if (e.button === 0) {
+        this.mouseDown = !0;
+        const s = new u(e.x, e.y);
+        this.mouseDownPositionX = s.x, this.mouseDownPositionY = s.y;
+      }
+    }, this.mousemove = (e) => {
+      if (!this.mouseDown)
+        return;
+      const s = new u(e.x, e.y);
+      if (this.mouseDownPositionX >= 0 && this.mouseDownPositionY >= 0 && (Math.abs(s.x - this.mouseDownPositionX) >= 5 || Math.abs(s.y - this.mouseDownPositionY) >= 5)) {
+        this.mouseMove = !0;
+        const o = new u(
+          Math.min(this.mouseDownPositionX, s.x),
+          Math.min(this.mouseDownPositionY, s.y)
+        ), r = new u(
+          Math.max(this.mouseDownPositionX, s.x),
+          Math.max(this.mouseDownPositionY, s.y)
+        );
+        this.drawRect(o, r);
+      }
+    }, this.mouseup = (e) => {
+      if (this.mouseDown && this.mouseMove) {
+        const s = new u(e.x, e.y), n = new u(
+          Math.min(this.mouseDownPositionX, s.x),
+          Math.min(this.mouseDownPositionY, s.y)
+        ), o = new u(
+          Math.max(this.mouseDownPositionX, s.x),
+          Math.max(this.mouseDownPositionY, s.y)
+        ), r = new N(n, o);
+        this.resolve(this.toWcs(r));
+      }
+      this.mouseDown = !1, this.mouseMove = !1, this.mouseDownPositionX = -1, this.mouseDownPositionY = -1;
+    }, this.container = t.canvas, this.color = Dt;
+  }
+  activate() {
+    super.activate(), this.active = !0, this.container.addEventListener("pointerdown", this.mousedown), this.container.addEventListener("pointermove", this.mousemove), this.container.addEventListener("pointerup", this.mouseup);
+  }
+  deactivate() {
+    super.deactivate(), this.container.removeEventListener("pointerdown", this.mousedown), this.container.removeEventListener("pointermove", this.mousemove), this.container.removeEventListener("pointerup", this.mouseup), this.setRectDomVisible(!1);
+  }
+  reject(t) {
+    var e;
+    super.reject(t), (e = this.boxDom) == null || e.remove(), this.boxDom = void 0;
+  }
+  drawRect(t, e) {
+    if (!this.boxDom) {
+      const o = new k();
+      o.color = this.color, this.boxDom = document.createElement("div"), this.boxDom.style.cssText = `position: absolute;border: ${It} solid ${o.cssColor};`, document.body.appendChild(this.boxDom);
+    }
+    this.setRectDomVisible(!0), t.x <= 0 && (t.x = 0), t.y <= 0 && (t.y = 0), e.x >= this.container.clientWidth - 2 && (e.x = this.container.clientWidth - 2), e.y >= this.container.clientHeight - 2 && (e.y = this.container.clientHeight - 2), this.boxDom.style.left = `${t.x}px`, this.boxDom.style.top = `${t.y}px`;
+    const s = Math.abs(e.x - t.x), n = Math.abs(e.y - t.y);
+    this.boxDom.style.width = `${s}px`, this.boxDom.style.height = `${n}px`;
+  }
+  setRectDomVisible(t) {
+    this.boxDom && (this.boxDom.style.display = t ? "inline-block" : "none");
+  }
+  toWcs(t) {
+    const e = new N(), s = new u(t.min.x, t.min.y), n = new u(t.max.x, t.max.y);
+    return e.expandByPoint(this.view.cwcs2Wcs(s)), e.expandByPoint(this.view.cwcs2Wcs(n)), e;
+  }
+}
+class Tt extends V {
+  constructor(t) {
+    super(t), this.onClick = (e) => {
+      this.resolve(this.view.cwcs2Wcs({ x: e.clientX, y: e.clientY }));
+    };
+  }
+  activate() {
+    super.activate(), this.view.canvas.addEventListener("click", this.onClick);
+  }
+  deactivate() {
+    super.deactivate(), this.view.canvas.removeEventListener("click", this.onClick);
+  }
+}
+class At {
+  constructor(t) {
+    this._view = t, this._cursorManager = new Mt();
+  }
+  get currentCursor() {
+    return this._currentCursor;
+  }
+  restoreCursor() {
+    this._previousCursor != null && this.setCursor(this._previousCursor);
+  }
+  setCursor(t) {
+    this._cursorManager.setCursor(t, this._view.canvas), this._previousCursor = this._currentCursor, this._currentCursor = t;
+  }
+  /**
+   * Get user input for a point.
+   */
+  async getPoint() {
+    return await new Tt(this._view).start();
+  }
+  /**
+   * Get the selection set obtained.
+   */
+  async getSelection() {
+    return await new Ct(this._view).start();
+  }
+}
+class Ot {
+  constructor(t = []) {
+    this.events = {
+      selectionAdded: new m(),
+      selectionRemoved: new m()
+    }, this._ids = new Set(t);
+  }
+  get ids() {
+    return Array.from(this._ids);
+  }
+  get count() {
+    return this._ids.size;
+  }
+  add(t) {
+    Array.isArray(t) ? (t.forEach((e) => this._ids.add(e)), this.events.selectionAdded.dispatch({ ids: t })) : (this._ids.add(t), this.events.selectionAdded.dispatch({ ids: [t] }));
+  }
+  delete(t) {
+    Array.isArray(t) ? (t.forEach((e) => this._ids.delete(e)), this.events.selectionRemoved.dispatch({ ids: t })) : (this._ids.delete(t), this.events.selectionRemoved.dispatch({ ids: [t] }));
+  }
+  has(t) {
+    return this._ids.has(t);
+  }
+  clear() {
+    if (this._ids.size > 0) {
+      const t = Array.from(this._ids);
+      this._ids.clear(), this.events.selectionRemoved.dispatch({ ids: t });
+    }
+  }
+}
+var y = /* @__PURE__ */ ((i) => (i[i.SELECTION = 0] = "SELECTION", i[i.PAN = 1] = "PAN", i))(y || {});
+class Nt {
+  constructor(t) {
+    this.events = {
+      mouseMove: new m(),
+      viewResize: new m(),
+      hover: new m(),
+      unhover: new m()
+    }, this._canvas = t;
+    const e = t.getBoundingClientRect();
+    this._bbox = new $(), this._width = e.width, this._height = e.height, this._curPos = new u(), this._curScreenPos = new u(), this._selectionSet = new Ot(), this._editor = new At(this), this._canvas.addEventListener("mousemove", (s) => this.onMouseMove(s)), this._canvas.addEventListener("mousedown", (s) => {
+      s.button === 1 && this._editor.setCursor(C.Grab);
+    }), this._canvas.addEventListener("mouseup", (s) => {
+      s.button === 1 && this._editor.restoreCursor();
+    }), window.addEventListener("resize", this.onWindowResize.bind(this)), this._selectionBoxSize = 4, this._hoverTimer = null, this._pauseTimer = null, this._hoveredObjectId = null;
+  }
+  /**
+   * The input manager
+   */
+  get editor() {
+    return this._editor;
+  }
+  /**
+   * The size of selection box in pixel unit
+   */
+  get selectionBoxSize() {
+    return this._selectionBoxSize;
+  }
+  set selectionBoxSize(t) {
+    this._selectionBoxSize = t;
+  }
+  /**
+   * Set cursor type of this view
+   * @param cursorType Input cursor type
+   */
+  setCursor(t) {
+    this._editor.setCursor(t);
+  }
+  /**
+   * Set callback function used to calculate size of canvas when window resized
+   * @param value Input callback function
+   */
+  setCalculateSizeCallback(t) {
+    this._calculateSizeCallback = t;
+  }
+  /**
+   * Width of canvas (not width of window) in pixel
+   */
+  get width() {
+    return this._width;
+  }
+  set width(t) {
+    this._width = t;
+  }
+  /**
+   * Height of canvas (not height of window) in pixel
+   */
+  get height() {
+    return this._height;
+  }
+  set height(t) {
+    this._height = t;
+  }
+  /**
+   * The bounding box to include all entities in this viewer
+   */
+  get bbox() {
+    return this._bbox;
+  }
+  /**
+   * The canvas HTML element used by this view
+   */
+  get canvas() {
+    return this._canvas;
+  }
+  get aspect() {
+    return this._width / this._height;
+  }
+  /**
+   * Postion of current mouse in world coordinate system
+   */
+  get curPos() {
+    return this._curPos;
+  }
+  /**
+   * Postion of current mouse in screen coordinate system
+   */
+  get curScreenPos() {
+    return this._curScreenPos;
+  }
+  /**
+   * The selection set in current view.
+   */
+  get selectionSet() {
+    return this._selectionSet;
+  }
+  onWindowResize() {
+    if (this._calculateSizeCallback) {
+      const { width: t, height: e } = this._calculateSizeCallback();
+      this._width = t, this._height = e;
+    } else
+      this._width = this._canvas.clientWidth, this._height = this._canvas.clientHeight;
+    this.events.viewResize.dispatch({
+      width: this._width,
+      height: this._height
+    });
+  }
+  /**
+   * Mouse move event handler.
+   * @param event Input mouse event argument
+   */
+  onMouseMove(t) {
+    this._curScreenPos = new u(t.clientX, t.clientY);
+    const e = this.cwcs2Wcs(this._curScreenPos);
+    this._curPos.copy(e), this.events.mouseMove.dispatch({ x: e.x, y: e.y }), this.mode == 0 && this.startHoverTimer(e.x, e.y);
+  }
+  setHoveredObjectId(t) {
+    this._hoveredObjectId && (this.events.unhover.dispatch({
+      id: this._hoveredObjectId,
+      x: this.curScreenPos.x,
+      y: this.curScreenPos.y
+    }), this.onUnhover(this._hoveredObjectId)), this._hoveredObjectId = t, t && (this.startPauseTimer(t), this.onHover(t));
+  }
+  hoverAt(t, e) {
+    const s = this.pick({ x: t, y: e });
+    s.length > 0 ? this.setHoveredObjectId(s[0]) : (this.setHoveredObjectId(null), this.clearPauseTimer());
+  }
+  clearHoverTimer() {
+    this._hoverTimer && clearTimeout(this._hoverTimer);
+  }
+  clearPauseTimer() {
+    this._pauseTimer && clearTimeout(this._pauseTimer);
+  }
+  startHoverTimer(t, e) {
+    this.clearHoverTimer(), this._hoverTimer = setTimeout(() => {
+      this.hoverAt(t, e);
+    }, 50);
+  }
+  startPauseTimer(t) {
+    this._pauseTimer = setTimeout(() => {
+      this.events.hover.dispatch({
+        id: t,
+        x: this.curScreenPos.x,
+        y: this.curScreenPos.y
+      });
+    }, 500);
+  }
+}
+class Pt {
+  constructor() {
+    this._fileName = "", this._docTitle = "", this._isReadOnly = !0, this._database = new J(), this.docTitle = "Untitled";
+  }
+  async openUri(t, e) {
+    this._uri = t, this._isReadOnly = e && e.readOnly || !1, this._fileName = this.getFileNameFromUri(t);
+    let s = !0;
+    try {
+      await this._database.openUri(t, e), this.docTitle = this._fileName;
+    } catch {
+      s = !1, v.emit("failed-to-open-file", { fileName: t });
+    }
+    return s;
+  }
+  async openDocument(t, e, s) {
+    var o;
+    let n = !0;
+    this._fileName = t;
+    try {
+      const r = (o = t.split(".").pop()) == null ? void 0 : o.toLocaleLowerCase();
+      await this._database.read(
+        e,
+        s,
+        r == "dwg" ? G.DWG : G.DXF
+      ), this.docTitle = this._fileName;
+    } catch (r) {
+      n = !1, v.emit("failed-to-open-file", { fileName: t }), console.error(r);
+    }
+    return n;
+  }
+  get uri() {
+    return this._uri;
+  }
+  /**
+   * The database object being used by this document instance.
+   */
+  get database() {
+    return this._database;
+  }
+  /**
+   * The window title of the document
+   */
+  get docTitle() {
+    return this._docTitle;
+  }
+  set docTitle(t) {
+    this._docTitle = t, typeof document < "u" && (document.title = t);
+  }
+  /**
+   * Return true if the document is read only; otherwise, returns false.
+   */
+  get isReadOnly() {
+    return this._isReadOnly;
+  }
+  getFileNameFromUri(t) {
+    try {
+      const s = new URL(t).pathname.split("/");
+      return s[s.length - 1] || "";
+    } catch (e) {
+      return console.error("Invalid URI:", e), "";
+    }
+  }
+}
+class Rt {
+  convert() {
+    const t = w.instance.curDocument.database.tables.blockTable.modelSpace.newIterator(), e = new dt();
+    for (const s of t)
+      s.draw(e);
+    this.createFileAndDownloadIt(e.export());
+  }
+  createFileAndDownloadIt(t) {
+    const e = new Blob([t], {
+      type: "image/svg+xml;charset=utf-8"
+    }), s = URL.createObjectURL(e), n = document.createElement("a");
+    n.href = s, n.download = "example.svg", document.body.appendChild(n), n.click();
+  }
+}
+class zt extends x {
+  execute(t) {
+    new Rt().convert();
+  }
+}
+class Vt extends x {
+  execute(t) {
+    v.emit("open-file", {});
+  }
+}
+class Gt extends x {
+  execute(t) {
+    w.instance.openUrl("https://cdn.jsdelivr.net/gh/mlight-lee/cad-data/templates/" + "acadiso.dxf");
+  }
+}
+class jt extends x {
+  execute(t) {
+    t.view.mode = y.SELECTION, t.view.setCursor(C.Crosshair);
+  }
+}
+class Yt extends x {
+  execute(t) {
+    t.view.zoomToFit();
+  }
+}
+class Xt extends Lt {
+  constructor(t) {
+    super(t);
+  }
+  async sampler() {
+    await w.instance.editor.getSelection().then((t) => this.view.zoomTo(t, 1));
+  }
+}
+class Ft extends x {
+  async execute(t) {
+    await new Xt(t.view).drag();
+  }
+}
+class Ut extends x {
+  execute(t) {
+    t.view.mode = y.PAN, t.view.setCursor(C.Grab);
+  }
+}
+const kt = (i) => new $(i.min, i.max), $t = (i) => new f.Box3(
+  i.min,
+  i.max
+), Wt = (i) => new N(i.min, i.max), Ht = (i) => new f.Box2(
+  i.min,
+  i.max
+), qt = (i) => new N(i.min, i.max), Jt = (i) => {
+  const t = new f.Box3();
+  return t.min.set(i.min.x, i.min.y, 0), t.max.set(i.max.x, i.max.y, 0), t;
+}, Kt = {
+  threeBo2dToGeBox2d: Wt,
+  goBox2dToThreeBox2d: Ht,
+  threeBox3dToGeBox3d: kt,
+  goBox3dToThreeBox3d: $t,
+  threeBox3dToGeBox2d: qt,
+  goBox2dToThreeBox3d: Jt
+};
+class Zt extends wt {
+  /**
+   * Construct one instance of this class
+   * @param layoutBtrId Input the id of the block table record associated the layout
+   * @param renderer Input renderer
+   * @param width Input width of this view
+   * @param height Input height of this view
+   */
+  constructor(t, e, s, n) {
+    super(t, s, n), this._layoutBtrId = e, this._mode = y.SELECTION, this._axesGizmo = this.createAxesGizmo(), this._viewportViews = /* @__PURE__ */ new Map();
+  }
+  get layoutBtrId() {
+    return this._layoutBtrId;
+  }
+  /**
+   * The view mode of the current layout view
+   */
+  get mode() {
+    return this._mode;
+  }
+  set mode(t) {
+    t == y.SELECTION ? this._cameraControls.mouseButtons = {
+      MIDDLE: f.MOUSE.PAN
+    } : t == y.PAN && (this._cameraControls.mouseButtons = {
+      LEFT: f.MOUSE.PAN
+    }), this._cameraControls.update(), this._mode = t;
+  }
+  /**
+   * The number of viewports in this layout view
+   */
+  get viewportCount() {
+    return this._viewportViews.size;
+  }
+  /**
+   * Add one viewport view instance to this layout view
+   * @param viewportView Input one viewport instance
+   */
+  addViewport(t) {
+    this._viewportViews.set(t.viewport.id, t);
+  }
+  /**
+   * Remove the specified viewport view by its id from this layout view
+   * @param id Input the id of one viewport instance
+   */
+  removeViewport(t) {
+    this._viewportViews.delete(t);
+  }
+  /**
+   * Resize this layout view
+   * @param width Input new width of the layout view
+   * @param height Input new height of the layout view
+   */
+  resize(t, e) {
+    this._height = e, this._width = t, this.updateCameraFrustum(), this._viewportViews.forEach((s) => {
+      s.update();
+    });
+  }
+  render(t) {
+    var s;
+    this._renderer.clear(), this._renderer.render(t.internalScene, this._camera);
+    const e = t.modelSpaceLayout;
+    e && this.drawViewports(e.internalObject), (s = this._axesGizmo) == null || s.update();
+  }
+  createAxesGizmo() {
+    return new gt(
+      this._camera.internalCamera,
+      this._renderer.internalRenderer,
+      {
+        hasZAxis: !1,
+        pos: xt.LEFT_BOTTOM
+      }
+    );
+  }
+  /**
+   * Draw viewports
+   * @param scene Input the scene to draw
+   */
+  drawViewports(t) {
+    if (this._viewportViews.size > 0) {
+      const e = this._renderer.autoClear;
+      this._renderer.autoClear = !1;
+      const s = new f.Vector4();
+      this._renderer.getViewport(s), this._renderer.clearDepth();
+      const n = t.visible;
+      t.visible = !0, this._viewportViews.forEach((o) => {
+        o.render(t);
+      }), t.visible = n, this._renderer.setViewport(
+        s.x,
+        s.y,
+        s.z,
+        s.w
+      ), this._renderer.autoClear = e;
+    }
+  }
+}
+class Qt {
+  constructor() {
+    this._activeLayoutBtrId = "", this._layoutViews = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The block table record id associated with the active layout
+   */
+  get activeLayoutBtrId() {
+    return this._activeLayoutBtrId;
+  }
+  set activeLayoutBtrId(t) {
+    this._activeLayoutBtrId = t, this._layoutViews.forEach((e) => {
+      e.enabled = e.layoutBtrId == t;
+    });
+  }
+  /**
+   * The active layout view.
+   */
+  get activeLayoutView() {
+    return this._layoutViews.get(this._activeLayoutBtrId);
+  }
+  /**
+   * Return true if the layout view manager contains one layout view associated with the sepcified block
+   * table record id. Otherwise it returns false.
+   * @param name Input the block table record id associated with the layout view
+   * @returns Return true if the layout view manager contains one layout view associated with the sepcified
+   * block table record id. Otherwise it returns false.
+   */
+  has(t) {
+    return this._layoutViews.has(t);
+  }
+  /**
+   * Get the layout view by the block table record id associated with the layout
+   * @param layoutBtrId Input the id of the block table record associated the layout
+   * @returns Return the layout view by the block table record id associated with the layout
+   */
+  getAt(t) {
+    return this._layoutViews.get(t);
+  }
+  /**
+   * Resize all of layout views managed by layout view manager
+   * @param width Input new width of the layout view
+   * @param height Input new height of the layout view
+   */
+  resize(t, e) {
+    this._layoutViews.forEach((s) => {
+      s.resize(t, e);
+    });
+  }
+  add(t) {
+    this._layoutViews.set(t.layoutBtrId, t);
+  }
+  /**
+   * Render the specified scene in the current layout view
+   * @param scene Input the scene to render
+   */
+  render(t) {
+    var e;
+    (e = this.activeLayoutView) == null || e.render(t);
+  }
+}
+function H(i, t, e = 0, s = i.length - 1, n = te) {
+  for (; s > e; ) {
+    if (s - e > 600) {
+      const c = s - e + 1, l = t - e + 1, h = Math.log(c), d = 0.5 * Math.exp(2 * h / 3), g = 0.5 * Math.sqrt(h * d * (c - d) / c) * (l - c / 2 < 0 ? -1 : 1), P = Math.max(e, Math.floor(t - l * d / c + g)), q = Math.min(s, Math.floor(t + (c - l) * d / c + g));
+      H(i, t, P, q, n);
+    }
+    const o = i[t];
+    let r = e, a = s;
+    for (E(i, e, t), n(i[s], o) > 0 && E(i, e, s); r < a; ) {
+      for (E(i, r, a), r++, a--; n(i[r], o) < 0; ) r++;
+      for (; n(i[a], o) > 0; ) a--;
+    }
+    n(i[e], o) === 0 ? E(i, e, a) : (a++, E(i, a, s)), a <= t && (e = a + 1), t <= a && (s = a - 1);
+  }
+}
+function E(i, t, e) {
+  const s = i[t];
+  i[t] = i[e], i[e] = s;
+}
+function te(i, t) {
+  return i < t ? -1 : i > t ? 1 : 0;
+}
+class ee {
+  constructor(t = 9) {
+    this._maxEntries = Math.max(4, t), this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)), this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(t) {
+    let e = this.data;
+    const s = [];
+    if (!O(t, e)) return s;
+    const n = this.toBBox, o = [];
+    for (; e; ) {
+      for (let r = 0; r < e.children.length; r++) {
+        const a = e.children[r], c = e.leaf ? n(a) : a;
+        O(t, c) && (e.leaf ? s.push(a) : z(t, c) ? this._all(a, s) : o.push(a));
+      }
+      e = o.pop();
+    }
+    return s;
+  }
+  collides(t) {
+    let e = this.data;
+    if (!O(t, e)) return !1;
+    const s = [];
+    for (; e; ) {
+      for (let n = 0; n < e.children.length; n++) {
+        const o = e.children[n], r = e.leaf ? this.toBBox(o) : o;
+        if (O(t, r)) {
+          if (e.leaf || z(t, r)) return !0;
+          s.push(o);
+        }
+      }
+      e = s.pop();
+    }
+    return !1;
+  }
+  load(t) {
+    if (!(t && t.length)) return this;
+    if (t.length < this._minEntries) {
+      for (let s = 0; s < t.length; s++)
+        this.insert(t[s]);
+      return this;
+    }
+    let e = this._build(t.slice(), 0, t.length - 1, 0);
+    if (!this.data.children.length)
+      this.data = e;
+    else if (this.data.height === e.height)
+      this._splitRoot(this.data, e);
+    else {
+      if (this.data.height < e.height) {
+        const s = this.data;
+        this.data = e, e = s;
+      }
+      this._insert(e, this.data.height - e.height - 1, !0);
+    }
+    return this;
+  }
+  insert(t) {
+    return t && this._insert(t, this.data.height - 1), this;
+  }
+  clear() {
+    return this.data = S([]), this;
+  }
+  remove(t, e) {
+    if (!t) return this;
+    let s = this.data;
+    const n = this.toBBox(t), o = [], r = [];
+    let a, c, l;
+    for (; s || o.length; ) {
+      if (s || (s = o.pop(), c = o[o.length - 1], a = r.pop(), l = !0), s.leaf) {
+        const h = se(t, s.children, e);
+        if (h !== -1)
+          return s.children.splice(h, 1), o.push(s), this._condense(o), this;
+      }
+      !l && !s.leaf && z(s, n) ? (o.push(s), r.push(a), a = 0, c = s, s = s.children[0]) : c ? (a++, s = c.children[a], l = !1) : s = null;
+    }
+    return this;
+  }
+  toBBox(t) {
+    return t;
+  }
+  compareMinX(t, e) {
+    return t.minX - e.minX;
+  }
+  compareMinY(t, e) {
+    return t.minY - e.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(t) {
+    return this.data = t, this;
+  }
+  _all(t, e) {
+    const s = [];
+    for (; t; )
+      t.leaf ? e.push(...t.children) : s.push(...t.children), t = s.pop();
+    return e;
+  }
+  _build(t, e, s, n) {
+    const o = s - e + 1;
+    let r = this._maxEntries, a;
+    if (o <= r)
+      return a = S(t.slice(e, s + 1)), b(a, this.toBBox), a;
+    n || (n = Math.ceil(Math.log(o) / Math.log(r)), r = Math.ceil(o / Math.pow(r, n - 1))), a = S([]), a.leaf = !1, a.height = n;
+    const c = Math.ceil(o / r), l = c * Math.ceil(Math.sqrt(r));
+    Y(t, e, s, l, this.compareMinX);
+    for (let h = e; h <= s; h += l) {
+      const d = Math.min(h + l - 1, s);
+      Y(t, h, d, c, this.compareMinY);
+      for (let g = h; g <= d; g += c) {
+        const P = Math.min(g + c - 1, d);
+        a.children.push(this._build(t, g, P, n - 1));
+      }
+    }
+    return b(a, this.toBBox), a;
+  }
+  _chooseSubtree(t, e, s, n) {
+    for (; n.push(e), !(e.leaf || n.length - 1 === s); ) {
+      let o = 1 / 0, r = 1 / 0, a;
+      for (let c = 0; c < e.children.length; c++) {
+        const l = e.children[c], h = R(l), d = oe(t, l) - h;
+        d < r ? (r = d, o = h < o ? h : o, a = l) : d === r && h < o && (o = h, a = l);
+      }
+      e = a || e.children[0];
+    }
+    return e;
+  }
+  _insert(t, e, s) {
+    const n = s ? t : this.toBBox(t), o = [], r = this._chooseSubtree(n, this.data, e, o);
+    for (r.children.push(t), D(r, n); e >= 0 && o[e].children.length > this._maxEntries; )
+      this._split(o, e), e--;
+    this._adjustParentBBoxes(n, o, e);
+  }
+  // split overflowed node into two
+  _split(t, e) {
+    const s = t[e], n = s.children.length, o = this._minEntries;
+    this._chooseSplitAxis(s, o, n);
+    const r = this._chooseSplitIndex(s, o, n), a = S(s.children.splice(r, s.children.length - r));
+    a.height = s.height, a.leaf = s.leaf, b(s, this.toBBox), b(a, this.toBBox), e ? t[e - 1].children.push(a) : this._splitRoot(s, a);
+  }
+  _splitRoot(t, e) {
+    this.data = S([t, e]), this.data.height = t.height + 1, this.data.leaf = !1, b(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(t, e, s) {
+    let n, o = 1 / 0, r = 1 / 0;
+    for (let a = e; a <= s - e; a++) {
+      const c = L(t, 0, a, this.toBBox), l = L(t, a, s, this.toBBox), h = re(c, l), d = R(c) + R(l);
+      h < o ? (o = h, n = a, r = d < r ? d : r) : h === o && d < r && (r = d, n = a);
+    }
+    return n || s - e;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(t, e, s) {
+    const n = t.leaf ? this.compareMinX : ie, o = t.leaf ? this.compareMinY : ne, r = this._allDistMargin(t, e, s, n), a = this._allDistMargin(t, e, s, o);
+    r < a && t.children.sort(n);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(t, e, s, n) {
+    t.children.sort(n);
+    const o = this.toBBox, r = L(t, 0, e, o), a = L(t, s - e, s, o);
+    let c = A(r) + A(a);
+    for (let l = e; l < s - e; l++) {
+      const h = t.children[l];
+      D(r, t.leaf ? o(h) : h), c += A(r);
+    }
+    for (let l = s - e - 1; l >= e; l--) {
+      const h = t.children[l];
+      D(a, t.leaf ? o(h) : h), c += A(a);
+    }
+    return c;
+  }
+  _adjustParentBBoxes(t, e, s) {
+    for (let n = s; n >= 0; n--)
+      D(e[n], t);
+  }
+  _condense(t) {
+    for (let e = t.length - 1, s; e >= 0; e--)
+      t[e].children.length === 0 ? e > 0 ? (s = t[e - 1].children, s.splice(s.indexOf(t[e]), 1)) : this.clear() : b(t[e], this.toBBox);
+  }
+}
+function se(i, t, e) {
+  if (!e) return t.indexOf(i);
+  for (let s = 0; s < t.length; s++)
+    if (e(i, t[s])) return s;
+  return -1;
+}
+function b(i, t) {
+  L(i, 0, i.children.length, t, i);
+}
+function L(i, t, e, s, n) {
+  n || (n = S(null)), n.minX = 1 / 0, n.minY = 1 / 0, n.maxX = -1 / 0, n.maxY = -1 / 0;
+  for (let o = t; o < e; o++) {
+    const r = i.children[o];
+    D(n, i.leaf ? s(r) : r);
+  }
+  return n;
+}
+function D(i, t) {
+  return i.minX = Math.min(i.minX, t.minX), i.minY = Math.min(i.minY, t.minY), i.maxX = Math.max(i.maxX, t.maxX), i.maxY = Math.max(i.maxY, t.maxY), i;
+}
+function ie(i, t) {
+  return i.minX - t.minX;
+}
+function ne(i, t) {
+  return i.minY - t.minY;
+}
+function R(i) {
+  return (i.maxX - i.minX) * (i.maxY - i.minY);
+}
+function A(i) {
+  return i.maxX - i.minX + (i.maxY - i.minY);
+}
+function oe(i, t) {
+  return (Math.max(t.maxX, i.maxX) - Math.min(t.minX, i.minX)) * (Math.max(t.maxY, i.maxY) - Math.min(t.minY, i.minY));
+}
+function re(i, t) {
+  const e = Math.max(i.minX, t.minX), s = Math.max(i.minY, t.minY), n = Math.min(i.maxX, t.maxX), o = Math.min(i.maxY, t.maxY);
+  return Math.max(0, n - e) * Math.max(0, o - s);
+}
+function z(i, t) {
+  return i.minX <= t.minX && i.minY <= t.minY && t.maxX <= i.maxX && t.maxY <= i.maxY;
+}
+function O(i, t) {
+  return t.minX <= i.maxX && t.minY <= i.maxY && t.maxX >= i.minX && t.maxY >= i.minY;
+}
+function S(i) {
+  return {
+    children: i,
+    height: 1,
+    leaf: !0,
+    minX: 1 / 0,
+    minY: 1 / 0,
+    maxX: -1 / 0,
+    maxY: -1 / 0
+  };
+}
+function Y(i, t, e, s, n) {
+  const o = [t, e];
+  for (; o.length; ) {
+    if (e = o.pop(), t = o.pop(), e - t <= s) continue;
+    const r = t + Math.ceil((e - t) / s / 2) * s;
+    H(i, r, t, e, n), o.push(t, r, r, e);
+  }
+}
+class ae {
+  /**
+   * Construct one instance of this class
+   * @param name Input layer name
+   */
+  constructor(t) {
+    this._group = new pt(), this._name = t;
+  }
+  /**
+   * Layer name
+   */
+  get name() {
+    return this._name;
+  }
+  set name(t) {
+    this._name = t;
+  }
+  get visible() {
+    return this._group.visible;
+  }
+  set visible(t) {
+    this._group.visible = t;
+  }
+  get internalObject() {
+    return this._group;
+  }
+  /**
+   * The statistics of this layer
+   */
+  get stats() {
+    const t = this._group.stats;
+    return {
+      name: this._name,
+      ...t
+    };
+  }
+  /**
+   * The number of entities stored in this layer
+   */
+  get entityCount() {
+    return this._group.entityCount;
+  }
+  /**
+   * Re-render points with latest point style settings
+   * @param displayMode Input display mode of points
+   */
+  rerenderPoints(t) {
+    this._group.rerenderPoints(t);
+  }
+  /**
+   * Return true if this layer contains the entity with the specified object id. Otherwise, return false.
+   * @param objectId Input the object id of one entity
+   * @returns Return true if this layer contains the entity with the specified object id. Otherwise,
+   * return false.
+   */
+  hasEntity(t) {
+    return this._group.hasEntity(t);
+  }
+  /**
+   * Add one AutoCAD entity into this layer.
+   * @param entity Input AutoCAD entity to be added into this layer.
+   */
+  addEntity(t) {
+    this._group.addEntity(t);
+  }
+  /**
+   * Return true if the object with the specified object id is intersected with the ray by using raycast.
+   * @param objectId  Input object id of object to check for intersection with the ray.
+   * @param raycaster Input raycaster to check intersection
+   */
+  isIntersectWith(t, e) {
+    return this._group.isIntersectWith(t, e);
+  }
+  /**
+   * Remove the specified entity from this layer.
+   * @param objectId Input the object id of the entity to remove
+   * @returns Return true if remove the specified entity successfully. Otherwise, return false.
+   */
+  remove(t) {
+    throw new Error("Not implemented yet!");
+  }
+  /**
+   * Update the specified entity in this layer.
+   * @param entity Input the entity to update
+   * @returns Return true if update the specified entity successfully. Otherwise, return false.
+   */
+  update(t) {
+    return this._group.add(t), !0;
+  }
+  /**
+   * Hover the specified entities
+   */
+  hover(t) {
+    t.forEach((e) => {
+      this._group.hover(e);
+    });
+  }
+  /**
+   * Unhover the specified entities
+   */
+  unhover(t) {
+    t.forEach((e) => {
+      this._group.unhover(e);
+    });
+  }
+  /**
+   * Select the specified entities
+   */
+  select(t) {
+    t.forEach((e) => {
+      this._group.select(e);
+    });
+  }
+  /**
+   * Unselect the specified entities
+   */
+  unselect(t) {
+    t.forEach((e) => {
+      this._group.unselect(e);
+    });
+  }
+}
+class ce {
+  constructor() {
+    this._group = new f.Group(), this._indexTree = new ee(), this._box = new f.Box3(), this._layers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The internal THREE.js object to use by scene. This is internally used only. Try to avoid using it.
+   * @internal
+   */
+  get internalObject() {
+    return this._group;
+  }
+  get layers() {
+    return this._layers;
+  }
+  get box() {
+    return this._box;
+  }
+  /**
+   * The visibility of this layout
+   */
+  get visible() {
+    return this._group.visible;
+  }
+  set visible(t) {
+    this._group.visible = t;
+  }
+  /**
+   * The number of entities stored in this layer
+   */
+  get entityCount() {
+    let t = 0;
+    return this._layers.forEach((e) => t += e.entityCount), t;
+  }
+  /**
+   * The statistics of this layout
+   */
+  get stats() {
+    const t = [];
+    let e = 0, s = 0, n = 0, o = 0, r = 0;
+    return this._layers.forEach((a) => {
+      const c = a.stats;
+      t.push(c), n += c.line.indexed.geometrySize + c.line.nonIndexed.geometrySize, o += c.mesh.indexed.geometrySize + c.mesh.nonIndexed.geometrySize, r += c.point.indexed.geometrySize + c.point.nonIndexed.geometrySize, e += c.summary.totalGeometrySize, s += c.summary.totalMappingSize;
+    }), {
+      layers: t,
+      summary: {
+        entityCount: this.entityCount,
+        totalSize: {
+          line: n,
+          mesh: o,
+          point: r,
+          geometry: e,
+          mapping: s
+        }
+      }
+    };
+  }
+  clear() {
+    return this._layers.forEach((t) => {
+      this._group.remove(t.internalObject);
+    }), this._layers.clear(), this._box.makeEmpty(), this._indexTree.clear(), this;
+  }
+  /**
+   * Re-render points with latest point style settings
+   * @param displayMode Input display mode of points
+   */
+  rerenderPoints(t) {
+    this._layers.forEach((e) => {
+      e.rerenderPoints(t);
+    });
+  }
+  /**
+   * Return true if the object with the specified object id is intersected with the ray by using raycast.
+   * @param objectId  Input object id of object to check for intersection with the ray.
+   * @param raycaster Input raycaster to check intersection
+   */
+  isIntersectWith(t, e) {
+    const s = this.getLayerByObjectId(t);
+    return s && s.isIntersectWith(t, e);
+  }
+  /**
+   * Add one AutoCAD entity into this layout. If layer group referenced by the entity doesn't exist, create one
+   * layer group and add this entity this group.
+   * @param entity Input AutoCAD entity to be added into this layout.
+   * @param extendBbox Input the flag whether to extend the bounding box of the scene by union the bounding box
+   * of the specified entity.
+   */
+  addEntity(t, e = !0) {
+    if (!t.objectId)
+      throw new Error("[AcTrEntity] Object id is required to add one entity!");
+    if (!t.layerName)
+      throw new Error("[AcTrEntity] Layer name is required to add one entity!");
+    const s = this.getLayer(t.layerName, !0);
+    if (s) {
+      s.addEntity(t);
+      const n = t.box;
+      e && this._box.union(n), this._indexTree.insert({
+        minX: n.min.x,
+        minY: n.min.y,
+        maxX: n.max.x,
+        maxY: n.max.y,
+        id: t.objectId
+      });
+    }
+    return this;
+  }
+  /**
+   * Remove the specified entity from this layout.
+   * @param objectId Input the object id of the entity to remove
+   * @returns Return true if remove the specified entity successfully. Otherwise, return false.
+   */
+  remove(t) {
+    for (const [e, s] of this._layers)
+      if (s.remove(t)) return !0;
+    return !1;
+  }
+  /**
+   * Update the specified entity in this layout.
+   * @param objectId Input the entity to update
+   * @returns Return true if update the specified entity successfully. Otherwise, return false.
+   */
+  update(t) {
+    for (const [e, s] of this._layers)
+      if (s.update(t)) return !0;
+    return !1;
+  }
+  /**
+   * Hover the specified entities
+   */
+  hover(t) {
+    t.forEach((e) => {
+      const s = this.getLayerByObjectId(e);
+      s && s.hover([e]);
+    });
+  }
+  /**
+   * Unhover the specified entities
+   */
+  unhover(t) {
+    t.forEach((e) => {
+      const s = this.getLayerByObjectId(e);
+      s && s.unhover([e]);
+    });
+  }
+  /**
+   * Select the specified entities
+   */
+  select(t) {
+    t.forEach((e) => {
+      const s = this.getLayerByObjectId(e);
+      s && s.select([e]);
+    });
+  }
+  /**
+   * Unselect the specified entities
+   */
+  unselect(t) {
+    t.forEach((e) => {
+      const s = this.getLayerByObjectId(e);
+      s && s.unselect([e]);
+    });
+  }
+  setSnapObject(t) {
+    this._snapPointsObject && this._group.remove(this._snapPointsObject), this._snapPointsObject = t, this._group.add(t);
+  }
+  /**
+   * Search entities intersected or contained in the specified bounding box.
+   * @param box Input the query bounding box
+   * @returns Return query results
+   */
+  search(t) {
+    return this._indexTree.search({
+      minX: t.min.x,
+      minY: t.min.y,
+      maxX: t.max.x,
+      maxY: t.max.y
+    });
+  }
+  getLayerByObjectId(t) {
+    for (const [e, s] of this._layers)
+      if (s.hasEntity(t)) return s;
+  }
+  /**
+   * Get layer group by name. If the layer doesn't exist, create one layer group into this layout.
+   * @param name Input layer name
+   * @param createIfNotExist Input one flag to indicate whether to create layer group if it doesn't exist in
+   * this layout.
+   * @returns Return matched layer
+   */
+  getLayer(t, e = !0) {
+    let s = this._layers.get(t);
+    return s === void 0 && e && (s = new ae(t), this._layers.set(t, s), this._group.add(s.internalObject)), s;
+  }
+}
+class he {
+  constructor() {
+    this._scene = new f.Scene(), this._layouts = /* @__PURE__ */ new Map(), this._activeLayoutBtrId = "", this._modelSpaceBtrId = "";
+  }
+  /**
+   * The layouts in this scene
+   */
+  get layouts() {
+    return this._layouts;
+  }
+  /**
+   * The bounding box of the visibile objects in this secene
+   */
+  get box() {
+    var t;
+    return (t = this.activeLayout) == null ? void 0 : t.box;
+  }
+  /**
+   * The scene object of THREE.js. This is internally used only. Try to avoid using it.
+   */
+  get internalScene() {
+    return this._scene;
+  }
+  /**
+   * The block table record id of the model space
+   */
+  get modelSpaceBtrId() {
+    return this._modelSpaceBtrId;
+  }
+  set modelSpaceBtrId(t) {
+    if (this._modelSpaceBtrId = t, !this._layouts.has(t))
+      throw new Error(
+        `[AcTrScene] No layout assiciated with the specified block table record id '${t}'!`
+      );
+  }
+  /**
+   * The block table record id associated with the current active layout
+   */
+  get activeLayoutBtrId() {
+    return this._activeLayoutBtrId;
+  }
+  set activeLayoutBtrId(t) {
+    this._activeLayoutBtrId = t, this._layouts.forEach((e, s) => {
+      e.visible = t == s;
+    });
+  }
+  /**
+   * Get active layout
+   */
+  get activeLayout() {
+    if (this._activeLayoutBtrId && this._layouts.has(this._activeLayoutBtrId))
+      return this._layouts.get(this._activeLayoutBtrId);
+  }
+  /**
+   * Get the layout of the model space
+   */
+  get modelSpaceLayout() {
+    if (this._modelSpaceBtrId && this._layouts.has(this._modelSpaceBtrId))
+      return this._layouts.get(this._modelSpaceBtrId);
+  }
+  /**
+   * The statistics of this scene
+   */
+  get stats() {
+    const t = [];
+    return this._layouts.forEach((e) => t.push(e.stats)), {
+      layouts: t
+    };
+  }
+  /**
+   * Add one empty layout with the specified block table record id as the its key
+   * @param ownerId Input the block table record id associated with this layout
+   * @returns Return the newly created empty layout
+   */
+  addEmptyLayout(t) {
+    const e = new ce();
+    return this._layouts.set(t, e), this._scene.add(e.internalObject), e.visible = t == this._activeLayoutBtrId, e;
+  }
+  /**
+   * Clear scene
+   * @returns Return this scene
+   */
+  clear() {
+    return this._layouts.forEach((t) => {
+      this._scene.remove(t.internalObject), t.clear();
+    }), this._layouts.clear(), this._scene.clear(), this;
+  }
+  /**
+   * Set layer's visibility
+   * @param layerName Input layer name
+   * @param visible Input visibility of the layer
+   */
+  setLayerVisibility(t, e) {
+    var n;
+    let s = !1;
+    return (n = this.activeLayout) == null || n.layers.forEach((o) => {
+      o.name === t && (o.visible = e, s = !0);
+    }), s;
+  }
+  /**
+   * Hover the specified entities
+   */
+  hover(t) {
+    return this.activeLayout ? (this.activeLayout.hover(t), !0) : !1;
+  }
+  /**
+   * Unhover the specified entities
+   */
+  unhover(t) {
+    return this.activeLayout ? (this.activeLayout.unhover(t), !0) : !1;
+  }
+  /**
+   * Select the specified entities
+   */
+  select(t) {
+    return this.activeLayout ? (this.activeLayout.select(t), !0) : !1;
+  }
+  /**
+   * Unselect the specified entities
+   */
+  unselect(t) {
+    return this.activeLayout ? (this.activeLayout.unselect(t), !0) : !1;
+  }
+  /**
+   * Search entities intersected or contained in the specified bounding box.
+   * @param box Input the query bounding box
+   * @returns Return query results
+   */
+  search(t) {
+    const e = this.activeLayout;
+    return e ? e == null ? void 0 : e.search(t) : [];
+  }
+  /**
+   * Add one AutoCAD entity into this scene. If the layout associated with this entity doesn't exist,
+   * then create one layout, add this layout into this scene, and add the entity into the layout.
+   * @param entity Input AutoCAD entity to be added into scene.
+   * @param extendBbox Input the flag whether to extend the bounding box of this scene by union the bounding box
+   * of the specified entity.
+   * @returns Return this scene
+   */
+  addEntity(t, e = !0) {
+    const s = t.ownerId;
+    if (s) {
+      let n = this._layouts.get(s);
+      n || (n = this.addEmptyLayout(s)), n.addEntity(t, e);
+    } else
+      console.warn("[AcTrSecene] The owner id of one entity cannot be empty!");
+    return this;
+  }
+  /**
+   * Remove the specified entity from this scene.
+   * @param objectId Input the object id of the entity to remove
+   * @returns Return true if remove the specified entity successfully. Otherwise, return false.
+   */
+  remove(t) {
+    for (const [e, s] of this._layouts)
+      if (s.remove(t)) return !0;
+    return !1;
+  }
+  /**
+   * Update the specified entity in this scene.
+   * @param objectId Input the entity to update
+   * @returns Return true if update the specified entity successfully. Otherwise, return false.
+   */
+  update(t) {
+    for (const [e, s] of this._layouts)
+      if (s.update(t)) return !0;
+    return !1;
+  }
+  setSnapObject(t) {
+    return this._layouts.forEach((e) => {
+      e.setSnapObject(t);
+    }), this;
+  }
+}
+const X = {
+  background: 0
+};
+class le extends Nt {
+  constructor(t = X) {
+    const e = {
+      ...X,
+      ...t
+    }, s = new f.WebGLRenderer({
+      antialias: !0,
+      alpha: !0,
+      canvas: t.canvas
+    });
+    e.canvas == null && (e.canvas = s.domElement), super(e.canvas), t.calculateSizeCallback && this.setCalculateSizeCallback(t.calculateSizeCallback), s.setPixelRatio(Math.min(window.devicePixelRatio, 2)), s.setSize(this.width, this.height), s.setClearColor(e.background || 0), this._renderer = new ft(s);
+    const n = I.instance.fontMapping;
+    this._renderer.setFontMapping(n), this._renderer.events.fontNotFound.addEventListener((o) => {
+      v.emit("font-not-found", {
+        fontName: o.fontName,
+        count: o.count ?? 0
+      });
+    }), this._scene = this.createScene(), this._stats = this.createStats(I.instance.isShowStats), I.instance.events.modified.addEventListener((o) => {
+      o.key == "isShowStats" && this.toggleStatsVisibility(this._stats, o.value);
+    }), this.canvas.addEventListener("click", () => {
+      this.mode == y.SELECTION && this.select();
+    }), document.addEventListener("keydown", (o) => {
+      o.code === "Escape" && this.selectionSet.clear();
+    }), W().layoutManager.events.layoutSwitched.addEventListener(
+      (o) => {
+        this.activeLayoutBtrId = o.newLayout.blockTableRecordId;
+      }
+    ), this._missedImages = /* @__PURE__ */ new Map(), this._layoutViewManager = new Qt(), this.initialize(), this.onWindowResize(), this.animate(), this._isDirty = !0;
+  }
+  initialize() {
+    this.setCursor(C.Crosshair);
+  }
+  /**
+   * @inheritdoc
+   */
+  get mode() {
+    const t = this.activeLayoutView;
+    return t ? t.mode : y.SELECTION;
+  }
+  set mode(t) {
+    this.activeLayoutView.mode = t, this.editor.getPoint();
+  }
+  get renderer() {
+    return this._renderer;
+  }
+  get isDirty() {
+    return this._isDirty;
+  }
+  set isDirty(t) {
+    this._isDirty = t;
+  }
+  get missedData() {
+    return {
+      fonts: this._renderer.missedFonts,
+      images: this._missedImages
+    };
+  }
+  get center() {
+    return this.activeLayoutView.center;
+  }
+  set center(t) {
+    this.activeLayoutView.center = t;
+  }
+  /**
+   * The block table record id of the model space
+   */
+  get modelSpaceBtrId() {
+    return this._scene.modelSpaceBtrId;
+  }
+  set modelSpaceBtrId(t) {
+    this._scene.modelSpaceBtrId = t;
+  }
+  /**
+   * The block table record id associated with the active layout
+   */
+  get activeLayoutBtrId() {
+    return this._scene.activeLayoutBtrId;
+  }
+  set activeLayoutBtrId(t) {
+    this._layoutViewManager.activeLayoutBtrId = t, this._scene.activeLayoutBtrId = t, this._isDirty = !0;
+  }
+  /**
+   * The active layout view
+   */
+  get activeLayoutView() {
+    return this._layoutViewManager.activeLayoutView;
+  }
+  /**
+   * The statistics of the current scene
+   */
+  get stats() {
+    return this._scene.stats;
+  }
+  animate() {
+    var t;
+    requestAnimationFrame(this.animate.bind(this)), this._isDirty && (this._layoutViewManager.render(this._scene), (t = this._stats) == null || t.update(), this._isDirty = !1);
+  }
+  /**
+   * @inheritdoc
+   */
+  cwcs2Wcs(t) {
+    const e = this.activeLayoutView;
+    return e ? e.cwcs2Wcs(t) : new u(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  wcs2Cwcs(t) {
+    const e = this.activeLayoutView;
+    return e ? e.wcs2Cwcs(t) : new u(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  zoomTo(t, e = 1.1) {
+    this.activeLayoutView.zoomTo(t, e), this._isDirty = !0;
+  }
+  /**
+   * Re-render points with latest point style settings
+   * @param displayMode Input display mode of points
+   */
+  rerenderPoints(t) {
+    const e = this._scene.activeLayout;
+    e && (e.rerenderPoints(t), this._isDirty = !0);
+  }
+  /**
+   * @inheritdoc
+   */
+  zoomToFit() {
+    if (this._scene.box) {
+      const t = Kt.threeBox3dToGeBox2d(this._scene.box);
+      this.zoomTo(t), this._isDirty = !0;
+    }
+  }
+  /**
+   * @inheritdoc
+   */
+  pick(t) {
+    t == null && (t = this.curPos);
+    const e = [], s = this._scene.activeLayout;
+    if (s) {
+      const n = this.activeLayoutView, o = n.pointToBox(t, this.selectionBoxSize), r = this._scene.search(o), a = Math.max(o.size.width / 2, o.size.height / 2), c = n.resetRaycaster(t, a);
+      r.forEach((l) => {
+        const h = l.id;
+        s.isIntersectWith(h, c) && e.push(h);
+      });
+    }
+    return e;
+  }
+  /**
+   * @inheritdoc
+   */
+  search(t) {
+    return this._scene.search(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  select(t) {
+    const e = [];
+    this.pick(t).forEach((n) => e.push(n)), e.length > 0 && this.selectionSet.add(e);
+  }
+  /**
+   * @inheritdoc
+   */
+  selectByBox(t) {
+    const e = [];
+    this._scene.search(t).forEach((n) => e.push(n.id)), this.selectionSet.add(e);
+  }
+  /**
+   * @inheritdoc
+   */
+  addEntity(t) {
+    const e = this.createLayoutViewIfNeeded(t.ownerId);
+    let s = t.draw(
+      this._renderer
+    );
+    if (s) {
+      s.objectId = t.objectId, s.ownerId = t.ownerId, s.layerName = t.layer, s.visible = t.visibility;
+      const n = !(t instanceof Q || t instanceof tt);
+      this._scene.addEntity(s, n), this._isDirty = !0, s.dispose(), s = null;
+    }
+    if (t instanceof K) {
+      if (t.number > 1) {
+        const n = new yt(
+          e,
+          t.toGiViewport(),
+          this._renderer
+        );
+        e.addViewport(n);
+      }
+    } else if (t instanceof Z) {
+      const n = t.imageFileName;
+      n && this._missedImages.set(t.objectId, n);
+    }
+  }
+  /**
+   * Remove the specified entity from this view.
+   * @param objectId Input the object id of the entity to remove
+   */
+  removeEntity(t) {
+    this._scene.remove(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  updateEntity(t) {
+    const e = t.draw(this._renderer);
+    return e && (e.objectId = t.objectId, e.ownerId = t.ownerId, e.layerName = t.layer, e.visible = t.visibility, this._scene.update(e), this._isDirty = !0, setTimeout(() => {
+      this._isDirty = !0;
+    }, 100)), e;
+  }
+  /**
+   * @inheritdoc
+   */
+  clear() {
+    this._scene.clear(), this._isDirty = !0, this._missedImages.clear(), this._renderer.clearMissedFonts();
+  }
+  /**
+   * @inheritdoc
+   */
+  highlight(t) {
+    this._isDirty = this._scene.select(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  unhighlight(t) {
+    this._isDirty = this._scene.unselect(t);
+  }
+  /**
+   * @inheritdoc
+   */
+  setLayerVisibility(t, e) {
+    this._isDirty = this._scene.setLayerVisibility(t, e);
+  }
+  /**
+   * @inheritdoc
+   */
+  onHover(t) {
+    this._isDirty = this._scene.hover([t]);
+  }
+  /**
+   * @inheritdoc
+   */
+  onUnhover(t) {
+    this._isDirty = this._scene.unhover([t]);
+  }
+  createScene() {
+    const t = new he();
+    return t.layouts.forEach((e) => {
+      e.setSnapObject(this.renderer.createObject());
+    }), t;
+  }
+  createStats(t) {
+    const e = new vt();
+    document.body.appendChild(e.dom);
+    const s = e.dom;
+    return s.style.position = "fixed", s.style.inset = "unset", s.style.bottom = "30px", s.style.right = "0px", this.toggleStatsVisibility(e, t), e;
+  }
+  onWindowResize() {
+    super.onWindowResize(), this._renderer.setSize(this.width, this.height), this._layoutViewManager.resize(this.width, this.height), this._isDirty = !0;
+  }
+  /**
+   * Create the layout view with the specified block table record id.
+   * @param layoutBtrId Input the block table record id associated with the layout view.
+   */
+  createLayoutViewIfNeeded(t) {
+    let e = this._layoutViewManager.getAt(t);
+    return e == null && (e = new Zt(
+      this._renderer,
+      t,
+      this.width,
+      this.height
+    ), e.events.viewChanged.addEventListener(() => {
+      this._isDirty = !0;
+    }), this._layoutViewManager.add(e)), e;
+  }
+  /**
+   * Show or hide stats component
+   * @param show If it is true, show stats component. Otherwise, hide stats component.
+   * Default value is false.
+   */
+  toggleStatsVisibility(t, e) {
+    e ? t.dom.style.display = "block" : t.dom.style.display = "none";
+  }
+}
+const F = "simsun";
+class B {
+  static get instance() {
+    return B._instance || (B._instance = new B()), B._instance;
+  }
+  createExampleDoc1(t) {
+    for (let n = 0; n < 2; ++n)
+      for (let o = 0; o < 2; ++o) {
+        const r = new j(), a = new et();
+        a.addVertexAt(0, { x: o * 100, y: n * 100, bulge: 1 }), a.addVertexAt(1, { x: o * 100 + 100, y: n * 100, bulge: 1 }), a.closed = !0, r.add(a), t.tables.blockTable.modelSpace.appendEntity(r);
+      }
+  }
+  createExampleDoc2(t) {
+    const e = t.tables.blockTable.modelSpace;
+    e.appendEntity(this.createArc()), this.createLines().forEach((n) => {
+      t.tables.blockTable.modelSpace.appendEntity(
+        new st(n.startPoint, n.endPoint)
+      );
+    }), e.appendEntity(this.createHatch()), t.tables.textStyleTable.add(this.createTextStyle()), e.appendEntity(this.createMText());
+  }
+  createTextStyle() {
+    const t = {
+      bigFont: "",
+      color: 16777215,
+      extendedFont: F,
+      fixedTextHeight: 0,
+      font: F,
+      lastHeight: 0.2,
+      name: "Standard",
+      obliqueAngle: 0,
+      standardFlag: 0,
+      textGenerationFlag: 0,
+      widthFactor: 0.667
+    };
+    return new it(t);
+  }
+  createMText() {
+    const t = new nt();
+    return t.attachmentPoint = ot.MiddleLeft, t.color = new k().setColorName("red"), t.layer = "0", t.location = new rt(9850, 86773, 0), t.contents = "{\\W0.667;\\T1.1;智慧8081}", t.height = 200, t.width = 1e3, t.styleName = "Standard", t;
+  }
+  createHatch() {
+    const t = this.createLines(), e = new j(), s = new at();
+    return s.add(
+      new ct(
+        { x: 20241.23355899991, y: 174118.6312674369 },
+        89258.30757455899,
+        T.degToRad(262.2471115358437),
+        T.degToRad(264.444541053754),
+        !1
+      )
+    ), t.forEach((n) => {
+      s.add(new ht(n.startPoint, n.endPoint));
+    }), e.add(s), e;
+  }
+  createArc() {
+    return new lt(
+      { x: 20241.23355899991, y: 174118.6312674369, z: 0 },
+      89258.30757455899,
+      T.degToRad(262.2471115358437),
+      T.degToRad(264.444541053754)
+    );
+  }
+  createLines() {
+    const t = [];
+    return t.push(
+      new M(
+        {
+          x: 11600.20888122753,
+          y: 85279.57362051727,
+          z: 0
+        },
+        {
+          x: 11600.20890652924,
+          y: 86546.03982284805,
+          z: 0
+        }
+      )
+    ), t.push(
+      new M(
+        {
+          x: 11600.20890652924,
+          y: 86546.03982284805,
+          z: 0
+        },
+        {
+          x: 10850.20885583921,
+          y: 86546.03980174381,
+          z: 0
+        }
+      )
+    ), t.push(
+      new M(
+        {
+          x: 10850.2088602169,
+          y: 86546.03967292747,
+          z: 0
+        },
+        {
+          x: 9050.208860216895,
+          y: 86546.039672927,
+          z: 0
+        }
+      )
+    ), t.push(
+      new M(
+        {
+          x: 9050.208855839213,
+          y: 86546.0397510943,
+          z: 0
+        },
+        {
+          x: 8200.209067034302,
+          y: 86546.039727177,
+          z: 0
+        }
+      )
+    ), t.push(
+      new M(
+        {
+          x: 8200.209067034302,
+          y: 86546.039727177,
+          z: 0
+        },
+        {
+          x: 8200.209067033837,
+          y: 85676.22514764359,
+          z: 0
+        }
+      )
+    ), t;
+  }
+}
+class de {
+  constructor(t) {
+    this._cadRenderer = t, this._avaiableFonts = [];
+  }
+  /**
+   * Avaiable fonts to load.
+   */
+  get avaiableFonts() {
+    return this._avaiableFonts;
+  }
+  /**
+   * @inheritdoc
+   */
+  async getAvaiableFonts() {
+    if (this._avaiableFonts.length == 0) {
+      const t = "https://cdn.jsdelivr.net/gh/mlight-lee/cad-data/fonts/", e = t + "fonts.json";
+      try {
+        const s = await fetch(e);
+        this._avaiableFonts = await s.json();
+      } catch {
+        v.emit("failed-to-get-avaiable-fonts", {
+          url: e
+        });
+      }
+      this._avaiableFonts.forEach((s) => {
+        s.url = t + s.file;
+      });
+    }
+    return this._avaiableFonts;
+  }
+  /**
+   * @inheritdoc
+   */
+  async load(t) {
+    await this.getAvaiableFonts();
+    const e = [];
+    t.forEach((n) => {
+      const o = n.toLowerCase(), r = ut(this._avaiableFonts, (a) => mt(a.name, (c) => c.toLowerCase() == o) >= 0);
+      r && e.push(r.url);
+    }), (await this._cadRenderer.loadFonts(e)).forEach((n) => {
+      n.status || v.emit("font-not-loaded", {
+        fontName: n.fontName,
+        url: n.url
+      });
+    });
+  }
+}
+class w {
+  constructor(t) {
+    this.events = {
+      documentCreated: new m(),
+      documentActivated: new m()
+    };
+    const e = new Pt();
+    e.database.events.openProgress.addEventListener((o) => {
+      v.emit("open-file-progress", {
+        percentage: o.percentage,
+        stage: o.stage,
+        stageStatus: o.stageStatus
+      });
+    });
+    const s = () => ({
+      width: window.innerWidth,
+      height: window.innerHeight - 30
+    }), n = new le({ canvas: t, calculateSizeCallback: s });
+    this._context = new bt(n, e), this._fontLoader = new de(n.renderer), W().workingDatabase = e.database, this.registerCommands(), this.createExampleDoc();
+  }
+  static createInstance(t) {
+    return w._instance == null && (w._instance = new w(t)), this._instance;
+  }
+  static get instance() {
+    return w._instance || (w._instance = new w()), w._instance;
+  }
+  /**
+   * Current context
+   */
+  get context() {
+    return this._context;
+  }
+  /**
+   * Current open drawing
+   */
+  get curDocument() {
+    return this._context.doc;
+  }
+  /**
+   * For now, it is same as property `curDocument`.
+   */
+  get mdiActiveDocument() {
+    return this._context.doc;
+  }
+  /**
+   * Current view used to show current drawing
+   */
+  get curView() {
+    return this._context.view;
+  }
+  get editor() {
+    return this._context.view.editor;
+  }
+  /**
+   * Avaiable fonts to load. It means those fonts are avaiable to load. However, it
+   * doesn't mean those fonts are already loaded and avaiable to use.
+   */
+  get avaiableFonts() {
+    return this._fontLoader.avaiableFonts;
+  }
+  /**
+   * Load the specified fonts
+   * @param fonts Input one list of font names
+   */
+  async loadFonts(t) {
+    await this._fontLoader.load(t);
+  }
+  /**
+   * Load default fonts
+   */
+  async loadDefaultFonts() {
+    const t = ["simkai"];
+    await this._fontLoader.load(t);
+  }
+  createExampleDoc() {
+    setTimeout(async () => {
+      await this.loadDefaultFonts(), B.instance.createExampleDoc2(this.curDocument.database), this.setLayoutInfo(), this.curView.zoomToFit();
+    });
+  }
+  async openUrl(t, e) {
+    this.onBeforeOpenDocument(), e = this.setOptions(e);
+    const s = await this.context.doc.openUri(t, e);
+    this.onAfterOpenDocument(s);
+  }
+  async openDocument(t, e, s) {
+    this.onBeforeOpenDocument(), s = this.setOptions(s);
+    const n = await this.context.doc.openDocument(
+      t,
+      e,
+      s
+    );
+    this.onAfterOpenDocument(n);
+  }
+  registerCommands() {
+    const t = _.instance;
+    t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "pan",
+      "pan",
+      new Ut()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "select",
+      "select",
+      new jt()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "zoom",
+      "zoom",
+      new Yt()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "zoomw",
+      "zoomw",
+      new Ft()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "csvg",
+      "csvg",
+      new zt()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "qnew",
+      "qnew",
+      new Gt()
+    ), t.addCommand(
+      _.SYSTEMT_COMMAND_GROUP_NAME,
+      "open",
+      "open",
+      new Vt()
+    );
+  }
+  sendStringToExecute(t) {
+    const s = _.instance.lookupGlobalCmd(t);
+    s == null || s.execute(this.context);
+  }
+  onBeforeOpenDocument() {
+    this.curView.clear();
+  }
+  onAfterOpenDocument(t) {
+    t && (this.events.documentActivated.dispatch({
+      doc: this.context.doc
+    }), this.setLayoutInfo(), this.curView.zoomToFit());
+  }
+  setOptions(t) {
+    return t == null ? t = { fontLoader: this._fontLoader } : t.fontLoader == null && (t.fontLoader = this._fontLoader), t;
+  }
+  setLayoutInfo() {
+    const t = this.curView;
+    t.activeLayoutBtrId = this.curDocument.database.currentSpaceId, t.modelSpaceBtrId = this.curDocument.database.currentSpaceId;
+  }
+}
+const ue = {
+  isDebug: !1,
+  isShowCommandLine: !0,
+  isShowCoordinate: !0,
+  isShowToolbar: !0,
+  isShowStats: !1,
+  fontMapping: {}
+}, U = "settings";
+class I {
+  constructor() {
+    this.events = {
+      modified: new m()
+    };
+  }
+  static get instance() {
+    return this._instance || (this._instance = new I()), this._instance;
+  }
+  set(t, e) {
+    const s = this.settings;
+    s[t] = e, localStorage.setItem(U, JSON.stringify(s)), this.events.modified.dispatch({
+      key: t,
+      value: e
+    });
+  }
+  get(t) {
+    return this.settings[t];
+  }
+  toggle(t) {
+    const e = this.get(t);
+    this.set(t, !e);
+  }
+  get isDebug() {
+    return this.get("isDebug");
+  }
+  set isDebug(t) {
+    this.set("isDebug", t);
+  }
+  get isShowCommandLine() {
+    return this.get("isShowCommandLine");
+  }
+  set isShowCommandLine(t) {
+    this.set("isShowCommandLine", t);
+  }
+  get isShowCoordinate() {
+    return this.get("isShowCoordinate");
+  }
+  set isShowCoordinate(t) {
+    this.set("isShowCoordinate", t);
+  }
+  get isShowToolbar() {
+    return this.get("isShowToolbar");
+  }
+  set isShowToolbar(t) {
+    this.set("isShowToolbar", t);
+  }
+  get isShowStats() {
+    return this.get("isShowStats");
+  }
+  set isShowStats(t) {
+    this.set("isShowStats", t);
+  }
+  get fontMapping() {
+    return this.get("fontMapping");
+  }
+  set fontMapping(t) {
+    this.set("fontMapping", t);
+  }
+  setFontMapping(t, e) {
+    const s = this.get("fontMapping");
+    s[t] = e, this.set("fontMapping", s);
+  }
+  get settings() {
+    const t = localStorage.getItem(U), e = t == null ? {} : JSON.parse(t);
+    return _t(e, ue);
+  }
+}
+export {
+  bt as AcApContext,
+  zt as AcApConvertToSvgCmd,
+  w as AcApDocManager,
+  Pt as AcApDocument,
+  Vt as AcApOpenCmd,
+  Ut as AcApPanCmd,
+  Gt as AcApQNewCmd,
+  jt as AcApSelectCmd,
+  I as AcApSettingManager,
+  Yt as AcApZoomCmd,
+  Ft as AcApZoomToBoxCmd,
+  Xt as AcApZoomToBoxJig,
+  Nt as AcEdBaseView,
+  x as AcEdCommand,
+  _ as AcEdCommandStack,
+  C as AcEdCorsorType,
+  Mt as AcEdCursorManager,
+  Lt as AcEdJig,
+  Ot as AcEdSelectionSet,
+  y as AcEdViewMode,
+  At as AcEditor,
+  le as AcTrView2d,
+  X as DEFAULT_VIEW_2D_OPTIONS,
+  ve as acedAlert,
+  v as eventBus
+};