@realsee/dnalogel 3.20.7 → 3.21.1

package/libs/Sculpt/Objects/Polygon/index.js

@@ -0,0 +1,113 @@
+var H = Object.defineProperty, T = Object.defineProperties;
+var j = Object.getOwnPropertyDescriptors;
+var b = Object.getOwnPropertySymbols;
+var A = Object.prototype.hasOwnProperty, D = Object.prototype.propertyIsEnumerable;
+var g = (i, t, e) => t in i ? H(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e, c = (i, t) => {
+  for (var e in t || (t = {}))
+    A.call(t, e) && g(i, e, t[e]);
+  if (b)
+    for (var e of b(t))
+      D.call(t, e) && g(i, e, t[e]);
+  return i;
+}, W = (i, t) => T(i, j(t));
+var m = (i, t, e) => (g(i, typeof t != "symbol" ? t + "" : t, e), e);
+var E = (i, t, e) => new Promise((r, s) => {
+  var d = (o) => {
+    try {
+      l(e.next(o));
+    } catch (a) {
+      s(a);
+    }
+  }, n = (o) => {
+    try {
+      l(e.throw(o));
+    } catch (a) {
+      s(a);
+    }
+  }, l = (o) => o.done ? r(o.value) : Promise.resolve(o.value).then(d, n);
+  l((e = e.apply(i, t)).next());
+});
+import { hotkeys as L } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as O } from "../Base/index.js";
+import { PolylineMesh as x } from "../../Meshes/Polyline.js";
+import { AreaMesh as M } from "../../Meshes/Area.js";
+import { PolygonEditor as U } from "./Editor.js";
+import { vector3ToArray as k } from "../../../shared-utils/three/vector3ToArray.js";
+class K extends O {
+  constructor(e, r) {
+    super(e, r);
+    m(this, "type", "Polygon");
+    m(this, "areaMesh");
+    this.editor = new U(this), e && (this.areaMesh = new M(c(c({}, e.style), e)), this.add(this.areaMesh)), L("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return W(c({}, this.baseData), {
+      points: k(this.applyObjectMatrixWorld(this.areaMesh.points)),
+      style: {
+        color: this.areaMesh.color.getHex(),
+        lineColor: this.areaMesh.lineColor.getHex(),
+        lineWidth: this.areaMesh.lineWidth
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.areaMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.areaMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return E(this, null, function* () {
+      this.children.forEach((s) => {
+        s.parent === this && this.remove(s);
+      }), this.children.length = 0;
+      const r = new M(e);
+      this.areaMesh = r, this.add(this.areaMesh), yield B(this.areaMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function B(i, t) {
+  return new Promise((e, r) => {
+    const s = i.parent;
+    if (!s) {
+      r(new Error("No container"));
+      return;
+    }
+    const d = new x({ dashed: !0, lineColor: i.lineColor, lineWidth: i.lineWidth });
+    s == null || s.add(d);
+    const n = new x({ dashed: !0, lineColor: i.lineColor, lineWidth: i.lineWidth });
+    s == null || s.add(n), t.enable();
+    const l = [];
+    let o, a = !1;
+    const u = (h) => {
+      const p = l.length === 0 ? h.point : o.clone();
+      l.push(p.clone()), i.setPoints(l, !1), a && (y(), e());
+    }, P = (h) => {
+      var v;
+      if (!((v = i.points) != null && v.length) || !h)
+        return;
+      const p = l.at(-1).clone();
+      if (i.points.length <= 2)
+        o = h.point, d.setPoints([p, o]), s != null && s.children.includes(n) && s.remove(n);
+      else {
+        o = i.projectPoint(h.point);
+        const f = i.points[0], C = 0.2;
+        f.distanceTo(o) < C || f.distanceTo(h.point) < C ? (o = f, h.point.copy(f), t.pointSelectorHelper.updateWithIntersect(h, { emitEvent: !1 }), a = !0) : a = !1, n.setPoints([o, h.point]), s != null && s.children.includes(n) || s == null || s.add(n);
+      }
+      d.setPoints([p, o]), l.length >= 2 && i.polygon.setPoints([...l, o]);
+    }, y = () => {
+      t.off("select", u), t.off("intersectionUpdate", P), t.off("disable", w), t.disable(), s == null || s.remove(d, n);
+    }, w = () => {
+      y(), s == null || s.remove(i, n, d), r(new Error("Cancelled"));
+    };
+    t.on("select", u), t.on("intersectionUpdate", P), t.on("disable", w);
+  });
+}
+export {
+  K as Polygon,
+  B as createPolygon
+};

package/libs/Sculpt/Objects/Polyline/Editor.d.ts

@@ -0,0 +1,25 @@
+import { BaseEditor } from '../Base/Editor';
+import type { FiveDomEvent } from '../../../shared-utils/five/FiveDomEvents';
+import type { Polyline } from '.';
+import type * as THREE from 'three';
+import { PointMesh } from '../../Meshes/Point';
+import type { LineWithDotsMesh } from '../../Meshes/LineWithDots';
+export declare abstract class LineEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    protected draggingPoints: PointMesh[];
+    protected get points(): PointMesh[];
+    abstract get lines(): LineWithDotsMesh[];
+    get pointHandles(): PointMesh[];
+    constructor(originObject: OriginObject);
+    enable(): void;
+    disable(): void;
+    protected onDragstart: (event: FiveDomEvent) => void;
+    protected onDragend: (event: FiveDomEvent) => void;
+    protected abstract onDrag(event: FiveDomEvent): void;
+}
+export declare class PolylineEditor extends LineEditor<Polyline> {
+    get lines(): LineWithDotsMesh[];
+    constructor(originObject: Polyline);
+    enable(): void;
+    disable(): void;
+    protected onDrag: (event: FiveDomEvent) => void;
+}

package/libs/Sculpt/Objects/Polyline/Editor.js

@@ -0,0 +1,68 @@
+var a = Object.defineProperty;
+var d = (s, i, t) => i in s ? a(s, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[i] = t;
+var r = (s, i, t) => (d(s, typeof i != "symbol" ? i + "" : i, t), t);
+import { BaseEditor as g } from "../Base/Editor.js";
+import { Sculpt as o } from "../../index.js";
+import { PointMesh as l } from "../../Meshes/Point.js";
+import { getIntersectByRaycaster as p } from "../../../shared-utils/five/getPosition.js";
+import "hammerjs";
+import "three";
+import "@realsee/five";
+import "../../../vendor/@tweenjs/tween/dist/tween.esm.js.js";
+import "../../../CSS3DRenderPlugin/utils/three/CSS3DRender.js";
+import "../../../CSS3DRenderPlugin/utils/generateBehindFiveElement.js";
+import { notNil as h } from "../../../shared-utils/isNil.js";
+class m extends g {
+  constructor(t) {
+    super(t);
+    r(this, "draggingPoints", []);
+    r(this, "onDragstart", (t) => {
+      const e = t.target;
+      this.draggingPoints = this.points.filter((n) => n.position.equals(e.position));
+    });
+    r(this, "onDragend", (t) => {
+      this.draggingPoints = [];
+    });
+  }
+  get points() {
+    return this.children.filter((t) => t instanceof l);
+  }
+  get pointHandles() {
+    return this.children;
+  }
+  enable() {
+    super.enable(), this.lines.flatMap((t) => t.visiblePointMeshes).filter(h).forEach((t) => {
+      const e = t.clone();
+      e.visible = !1, e.draggable = !0, o.modules.fiveDomEvents.addEventListener(e, "drag", this.onDrag), o.modules.fiveDomEvents.addEventListener(e, "dragstart", this.onDragstart), o.modules.fiveDomEvents.addEventListener(e, "dragend", this.onDragend), this.add(e);
+    });
+  }
+  disable() {
+    super.disable(), this.removeChildren();
+  }
+}
+class j extends m {
+  constructor(t) {
+    super(t);
+    r(this, "onDrag", (t) => {
+      if (!this.draggingPoints || this.draggingPoints.length === 0)
+        return;
+      const e = p(o.modules.five, t.raycaster);
+      this.draggingPoints.forEach((n) => n.position.copy(e.point)), this.originObject.polyLineMesh.setPoints(this.points.map((n) => n.position));
+    });
+  }
+  get lines() {
+    return this.originObject.polyLineMesh.lines;
+  }
+  enable() {
+    super.enable();
+  }
+  disable() {
+    super.disable();
+  }
+  // private onDblclick = (event: FiveDomEvent) => {
+  // }
+}
+export {
+  m as LineEditor,
+  j as PolylineEditor
+};

package/libs/Sculpt/Objects/Polyline/index.d.ts

@@ -0,0 +1,31 @@
+import type { Color } from '../../../Object3DHelperPlugin';
+import { PolylineMesh, PolylineWithDotsMesh, type PolylineData, type PolylineStyle } from '../../Meshes/Polyline';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PolylineImportData extends BaseImportData, PolylineData {
+    type: LiteralString<'Polyline'>;
+    style?: Partial<PolylineStyle>;
+}
+export declare class Polyline extends BaseObject<PolylineImportData> {
+    readonly type = "Polyline";
+    polyLineMesh: PolylineWithDotsMesh;
+    get data(): {
+        points: [number, number, number][];
+        style: {
+            lineColor: number;
+            lineWidth: number;
+            dashed: boolean;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PolylineImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: {
+        color?: Color;
+        lineWidth?: number;
+    }): Promise<void>;
+}
+export declare function createPolyline(polyLineMesh: PolylineMesh, pointSelector: PointSelector): Promise<void>;

package/libs/Sculpt/Objects/Polyline/index.js

@@ -0,0 +1,96 @@
+var M = Object.defineProperty, C = Object.defineProperties;
+var L = Object.getOwnPropertyDescriptors;
+var m = Object.getOwnPropertySymbols;
+var v = Object.prototype.hasOwnProperty, b = Object.prototype.propertyIsEnumerable;
+var d = (i, t, e) => t in i ? M(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e, p = (i, t) => {
+  for (var e in t || (t = {}))
+    v.call(t, e) && d(i, e, t[e]);
+  if (m)
+    for (var e of m(t))
+      b.call(t, e) && d(i, e, t[e]);
+  return i;
+}, g = (i, t) => C(i, L(t));
+var y = (i, t, e) => (d(i, typeof t != "symbol" ? t + "" : t, e), e);
+var u = (i, t, e) => new Promise((n, l) => {
+  var a = (o) => {
+    try {
+      h(e.next(o));
+    } catch (s) {
+      l(s);
+    }
+  }, r = (o) => {
+    try {
+      h(e.throw(o));
+    } catch (s) {
+      l(s);
+    }
+  }, h = (o) => o.done ? n(o.value) : Promise.resolve(o.value).then(a, r);
+  h((e = e.apply(i, t)).next());
+});
+import { hotkeys as W } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { PolylineWithDotsMesh as P, PolylineMesh as x } from "../../Meshes/Polyline.js";
+import { BaseObject as E } from "../Base/index.js";
+import * as j from "three";
+import { PolylineEditor as D } from "./Editor.js";
+import { vector3ToArray as H } from "../../../shared-utils/three/vector3ToArray.js";
+class q extends E {
+  constructor(e, n) {
+    super(e, n);
+    y(this, "type", "Polyline");
+    y(this, "polyLineMesh");
+    e && (this.polyLineMesh = new P(p(p({}, e.style), e)), this.add(this.polyLineMesh)), this.editor = new D(this), W("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return g(p({}, this.baseData), {
+      points: H(this.applyObjectMatrixWorld(this.polyLineMesh.points)),
+      style: {
+        lineColor: new j.Color(this.polyLineMesh.lineColor).getHex(),
+        lineWidth: this.polyLineMesh.lineWidth,
+        dashed: this.polyLineMesh.dashed
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.polyLineMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.polyLineMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return u(this, null, function* () {
+      this.removeChildren();
+      const n = new P(e);
+      this.polyLineMesh = n, this.add(this.polyLineMesh), yield O(n, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function O(i, t) {
+  const e = i.parent;
+  if (!e)
+    return;
+  const n = new x({ dashed: !0, lineColor: i.lineColor, lineWidth: i.lineWidth });
+  return e.add(n), t.enable(), new Promise((l, a) => {
+    const r = [], h = (s) => {
+      const c = s.point;
+      r.push(c.clone()), i.setPoints(r);
+    }, o = (s) => {
+      var f;
+      if (!((f = i.points) != null && f.length) || !s)
+        return;
+      const c = r.at(-1).clone(), w = s.point;
+      n.setPoints([c, w]);
+    };
+    t.on("select", h), t.on("intersectionUpdate", o), t.on("disable", () => {
+      if (t.off("select", h), t.off("intersectionUpdate", o), e.remove(n), r.length < 2)
+        return e.remove(i), a(new Error("Cancelled"));
+      l();
+    });
+  });
+}
+export {
+  q as Polyline
+};

package/libs/Sculpt/Objects/Prism/Editor.d.ts

@@ -0,0 +1,5 @@
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+import type { Prism } from '.';
+export declare class PrismEditor extends BaseEditorWithObjectHelper<Prism> {
+    constructor(originObject: Prism);
+}

package/libs/Sculpt/Objects/Prism/Editor.js

@@ -0,0 +1,44 @@
+import { BaseEditorWithObjectHelper as l } from "../Base/Editor.js";
+import * as m from "three";
+class P extends l {
+  constructor(t) {
+    super(t, () => {
+      const i = () => {
+        var n, e;
+        const o = (n = t.prismMesh.topPolygon.getGeometryInfo()) == null ? void 0 : n.center, s = (e = t.prismMesh.bottomPolygon.getGeometryInfo()) == null ? void 0 : e.center, r = new m.Vector3().lerpVectors(o, s, 0.5);
+        return { topCenter: o, bottomCenter: s, boxCenter: r };
+      };
+      return {
+        positionFrom: () => i().boxCenter.clone().applyMatrix4(t.matrixWorld),
+        yAxis: t.prismMesh.up,
+        scaleHelper: {
+          enable: !0,
+          positions: () => {
+            const o = i();
+            return [
+              {
+                id: "top",
+                handlePosition: o.topCenter,
+                basePosition: o.bottomCenter
+              },
+              {
+                id: "bottom",
+                handlePosition: o.bottomCenter,
+                basePosition: o.topCenter
+              }
+            ];
+          },
+          scaleCallback: (o) => {
+            const { intersectPoint: s, scalePosition: r } = o, { id: n } = r, { prismMesh: e } = t;
+            n === "top" ? e.setPoints({ heightPoint: s }) : n === "bottom" && e.setPoints({
+              points: e.topPolygon.points.map((p) => p.clone().add(s.clone().sub(r.basePosition)))
+            });
+          }
+        }
+      };
+    });
+  }
+}
+export {
+  P as PrismEditor
+};

package/libs/Sculpt/Objects/Prism/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import { PrismMesh, type PrismData, type PrismStyle } from '../../Meshes/Prism';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PrismImportData extends BaseImportData, PrismData {
+    type: LiteralString<'Prism'>;
+    style?: Partial<PrismStyle>;
+}
+export declare class Prism extends BaseObject<PrismImportData> {
+    readonly type = "Prism";
+    prismMesh: PrismMesh;
+    get data(): {
+        readonly points: [number, number, number][];
+        readonly heightPoint: [number, number, number];
+        readonly style: {
+            readonly color: number;
+            readonly lineWidth: number;
+            readonly lineColor: number;
+        };
+        readonly id: string;
+        readonly type: string;
+    };
+    constructor(data?: PrismImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<PrismStyle>): Promise<void>;
+}
+export declare function createPrism(prismMesh: PrismMesh, pointSelector: PointSelector): Promise<void>;

package/libs/Sculpt/Objects/Prism/index.js

@@ -0,0 +1,105 @@
+var v = Object.defineProperty, E = Object.defineProperties;
+var L = Object.getOwnPropertyDescriptors;
+var M = Object.getOwnPropertySymbols;
+var O = Object.prototype.hasOwnProperty, C = Object.prototype.propertyIsEnumerable;
+var p = (e, i, t) => i in e ? v(e, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[i] = t, c = (e, i) => {
+  for (var t in i || (i = {}))
+    O.call(i, t) && p(e, t, i[t]);
+  if (M)
+    for (var t of M(i))
+      C.call(i, t) && p(e, t, i[t]);
+  return e;
+}, w = (e, i) => E(e, L(i));
+var d = (e, i, t) => (p(e, typeof i != "symbol" ? i + "" : i, t), t);
+var f = (e, i, t) => new Promise((s, n) => {
+  var m = (o) => {
+    try {
+      r(t.next(o));
+    } catch (h) {
+      n(h);
+    }
+  }, l = (o) => {
+    try {
+      r(t.throw(o));
+    } catch (h) {
+      n(h);
+    }
+  }, r = (o) => o.done ? s(o.value) : Promise.resolve(o.value).then(m, l);
+  r((t = t.apply(e, i)).next());
+});
+import { BaseObject as W } from "../Base/index.js";
+import * as j from "three";
+import { createPolygon as T } from "../Polygon/index.js";
+import { PrismMesh as x } from "../../Meshes/Prism.js";
+import { Sculpt as U } from "../../index.js";
+import { LineMesh as k } from "../../Meshes/Line.js";
+import { PrismEditor as z } from "./Editor.js";
+import { hotkeys as A } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { rayOnLine as B } from "../../utils/three/rayOnLine.js";
+import { getNormal as D } from "../../../shared-utils/three/getNormal.js";
+import { vector3ToArray as H } from "../../../shared-utils/three/vector3ToArray.js";
+class Z extends W {
+  constructor(t, s) {
+    super(t, s);
+    d(this, "type", "Prism");
+    d(this, "prismMesh");
+    this.editor = new z(this), t && (this.prismMesh = new x(c(c({}, t.style), t)), this.add(this.prismMesh)), A("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return w(c({}, this.baseData), {
+      points: H(this.applyObjectMatrixWorld(this.prismMesh.bottomPolygon.points)),
+      heightPoint: H(this.applyObjectMatrixWorld(this.prismMesh.heightPoint)),
+      style: {
+        color: this.prismMesh.color.getHex(),
+        lineWidth: this.prismMesh.lineWidth,
+        lineColor: this.prismMesh.lineColor.getHex()
+      }
+    });
+  }
+  highlight() {
+    var t;
+    (t = this.prismMesh) == null || t.highlight();
+  }
+  unhighlight() {
+    var t;
+    (t = this.prismMesh) == null || t.unhighlight();
+  }
+  create(t) {
+    return f(this, null, function* () {
+      this.prismMesh = new x(t), this.add(this.prismMesh), yield N(this.prismMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function N(e, i) {
+  return f(this, null, function* () {
+    const t = e.parent;
+    yield T(e.bottomPolygon, i);
+    const s = new k();
+    s.name = "LineHelper", t.add(s);
+    const n = e.bottomPolygon.points.at(-1), m = D(e.bottomPolygon.points).normalize(), l = n.clone().add(m.clone().multiplyScalar(10)), r = n.clone().sub(m.clone().multiplyScalar(10));
+    return s.setPoints([l, r]), i.enable(), new Promise((o, h) => {
+      const g = (a) => {
+        P(), o();
+      }, y = (a) => {
+        if (!(a != null && a.raycaster))
+          return;
+        const u = B(
+          U.modules.five.camera.position,
+          a.raycaster.ray,
+          new j.Line3(l, r)
+        );
+        u && e.setPoints({ heightPoint: u });
+      }, P = () => {
+        i.off("select", g), i.off("intersectionUpdate", y), i.off("disable", b), t.remove(s), i.disable();
+      }, b = () => {
+        P(), t.remove(e), h(new Error("Cancelled"));
+      };
+      i.on("select", g), i.on("intersectionUpdate", y), i.on("disable", b);
+    });
+  });
+}
+export {
+  Z as Prism
+};

package/libs/Sculpt/Objects/Rectangle/Editor.d.ts

@@ -0,0 +1,5 @@
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+import type { Rectangle } from '.';
+export declare class RectangleEditor extends BaseEditorWithObjectHelper<Rectangle> {
+    constructor(originObject: Rectangle);
+}

package/libs/Sculpt/Objects/Rectangle/Editor.js

@@ -0,0 +1,9 @@
+import { BaseEditorWithObjectHelper as t } from "../Base/Editor.js";
+class o extends t {
+  constructor(e) {
+    super(e, () => ({ yAxis: e.rectangleMesh.up }));
+  }
+}
+export {
+  o as RectangleEditor
+};

package/libs/Sculpt/Objects/Rectangle/index.d.ts

@@ -0,0 +1,29 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { ArrayPosition } from '../../../PanoTagPlugin';
+import type { RectangleData, RectangleMesh } from '../../Meshes/Rectangle';
+import { RectangleWithEdgeMesh, type RectangleWithEdgeMeshStyle } from '../../Meshes/RectangleWithEdge';
+import type { LiteralString } from '../../typings/utils.type';
+export interface RectangleImportData extends BaseImportData, RectangleData {
+    type: LiteralString<'Rectangle'>;
+    style?: Partial<RectangleWithEdgeMeshStyle>;
+}
+export declare class Rectangle extends BaseObject<RectangleImportData> {
+    readonly type = "Rectangle";
+    rectangleMesh: RectangleWithEdgeMesh;
+    get data(): {
+        points: [ArrayPosition, ArrayPosition, ArrayPosition];
+        style: {
+            color: number;
+            lineWidth: number;
+            lineColor: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: RectangleImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<RectangleWithEdgeMeshStyle>): Promise<void>;
+}
+export declare function createRectangle(rectangleMesh: RectangleMesh, pointSelector: PointSelector): Promise<void>;

package/libs/Sculpt/Objects/Rectangle/index.js

@@ -0,0 +1,105 @@
+var D = Object.defineProperty, L = Object.defineProperties;
+var N = Object.getOwnPropertyDescriptors;
+var M = Object.getOwnPropertySymbols;
+var O = Object.prototype.hasOwnProperty, T = Object.prototype.propertyIsEnumerable;
+var f = (n, t, e) => t in n ? D(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, d = (n, t) => {
+  for (var e in t || (t = {}))
+    O.call(t, e) && f(n, e, t[e]);
+  if (M)
+    for (var e of M(t))
+      T.call(t, e) && f(n, e, t[e]);
+  return n;
+}, E = (n, t) => L(n, N(t));
+var m = (n, t, e) => (f(n, typeof t != "symbol" ? t + "" : t, e), e);
+var V = (n, t, e) => new Promise((l, r) => {
+  var h = (o) => {
+    try {
+      s(e.next(o));
+    } catch (a) {
+      r(a);
+    }
+  }, g = (o) => {
+    try {
+      s(e.throw(o));
+    } catch (a) {
+      r(a);
+    }
+  }, s = (o) => o.done ? l(o.value) : Promise.resolve(o.value).then(h, g);
+  s((e = e.apply(n, t)).next());
+});
+import { hotkeys as U } from "../../../vendor/hotkeys-js/dist/hotkeys.esm.js";
+import { BaseObject as k } from "../Base/index.js";
+import * as c from "three";
+import { PolylineWithDotsMesh as v } from "../../Meshes/Polyline.js";
+import { RectangleEditor as z } from "./Editor.js";
+import { RectangleWithEdgeMesh as R } from "../../Meshes/RectangleWithEdge.js";
+class K extends k {
+  constructor(e, l) {
+    super(e, l);
+    m(this, "type", "Rectangle");
+    m(this, "rectangleMesh");
+    this.config.canEdit && (this.editor = new z(this)), e && (this.rectangleMesh = new R(d(d({}, e.style), e)), this.add(this.rectangleMesh)), U("esc", () => {
+      this.stopCreating();
+    });
+  }
+  get data() {
+    return E(d({}, this.baseData), {
+      points: this.rectangleMesh.builtPoints.map((e) => e.toArray()),
+      style: {
+        color: this.rectangleMesh.color.getHex(),
+        lineWidth: this.rectangleMesh.lineWidth,
+        lineColor: this.rectangleMesh.lineColor.getHex()
+      }
+    });
+  }
+  highlight() {
+    var e;
+    (e = this.rectangleMesh) == null || e.highlight();
+  }
+  unhighlight() {
+    var e;
+    (e = this.rectangleMesh) == null || e.unhighlight();
+  }
+  create(e) {
+    return V(this, null, function* () {
+      this.removeChildren();
+      const l = new R(e);
+      this.rectangleMesh = l, this.add(this.rectangleMesh), yield B(this.rectangleMesh, this.pointSelector), this.editor.enable();
+    });
+  }
+}
+function B(n, t) {
+  return new Promise((e, l) => {
+    var P, C;
+    const r = n.parent;
+    if (!r) {
+      l(new Error("No container"));
+      return;
+    }
+    const h = new v({ dashed: !0, lineColor: (P = n.lineColor) != null ? P : n.color }), g = new v({ dashed: !1, lineColor: (C = n.lineColor) != null ? C : n.color });
+    r.add(h, g), t.enable();
+    const s = [], o = new c.Vector3(), a = new c.Plane(), p = (i) => {
+      s.push(o.clone()), s.length !== 1 && (s.length === 2 ? g.setPoints([s[0], s[1]]) : s.length === 3 && (u(), e()));
+    }, w = (i) => {
+      if (i != null && i.raycaster) {
+        if (s.length === 0)
+          o.copy(i.point), a.setFromNormalAndCoplanarPoint(i.face.normal, i.point.clone());
+        else if (s.length === 1)
+          i.raycaster.ray.intersectPlane(a, o), h.setPoints([s.at(-1), o]);
+        else if (s.length === 2) {
+          const x = i.raycaster.ray.intersectPlane(a, new c.Vector3()), W = s[0].distanceTo(s[1]) / 2, b = new c.Vector3().lerpVectors(s[0], s[1], 0.5), A = new c.Vector3().subVectors(x, b).normalize(), H = new c.Vector3().addVectors(b, A.multiplyScalar(W));
+          o.copy(H), r.remove(h), n.setPoints([...s, o]);
+        }
+      }
+    }, u = () => {
+      t.off("select", p), t.off("intersectionUpdate", w), t.off("disable", y), t.disable(), r == null || r.remove(h, g);
+    }, y = () => {
+      u(), r == null || r.remove(n), l(new Error("Cancelled"));
+    };
+    t.on("select", p), t.on("intersectionUpdate", w), t.on("disable", y);
+  });
+}
+export {
+  K as Rectangle,
+  B as createRectangle
+};