@agrotools1/at-components 0.2.3 → 0.2.4

package/dist/GraphicManipulator-84ac0573.js

@@ -0,0 +1,1499 @@
+import { a$ as P, b1 as J, jj as xe, jk as Ke, z as Qe, g as Ye, fZ as ee, cr as te, a9 as be, aa as Xe, aS as Pe, b9 as b, dc as U, gn as ue, x as Z, bz as ae, jl as N, eQ as le, e as o, y as r, c as C, jm as d, i6 as g, S as Q, bn as Re, bm as Je, bp as et, jn as tt, b5 as it, dF as nt, o as G, eK as ot, fG as Oe, g0 as st, bR as rt, jo as Te, jp as at, jq as lt, ga as ie, bo as ht, bc as dt, bf as pt, bd as ct, fq as Se, B as ut, cs as k, eD as mt, i5 as Ce, jr as Ve, b6 as vt, bT as _t, fs as gt } from "./index-f28919b2.js";
+import { h as yt } from "./GraphicsLayer-ee9f874e.js";
+import { e as me, n as ve } from "./projectVectorToVector-add01592.js";
+import { U as wt, w as ft } from "./enums-fa8f05ab.js";
+import { r as xt, o as F, q as ne, P as $e, V as _e, g as ge, e as he, z as ye, A as m, B as ke, C as bt, D as Pt, c as Ot, E as q, F as E, G as Ee, T as Tt, H as St, I as Ct, J as Ge, U as Vt, m as Ht, t as He, K as It, L as oe, N as Mt, O as se, x as re, h as Dt, Z as At, d as Lt, l as Rt } from "./MeasurementWidgetContent-fc0c1569.js";
+import { p as Ze } from "./SnappingOperation-25ff52da.js";
+import { m as $t, u as Ue, g as ze, v as kt, s as Et } from "./elevationInfoUtils-e1edd62e.js";
+import { m as Gt } from "./diffUtils-04a71a59.js";
+import { s as Y, i as Zt, l as Ut } from "./quantityUtils-afe6e5b7.js";
+import { R as zt, L as Ft } from "./quat-22f56b72.js";
+import { e as Ie } from "./quatf64-bec1af25.js";
+import { c as Wt } from "./projectPointToVector-1d9098bc.js";
+import { J as Bt } from "./defaults-e5c5ee75.js";
+import { h as jt } from "./ElevationInfo-5be88917.js";
+import { i as Nt } from "./drapedUtils-2515520d.js";
+let qt = class extends xt {
+  constructor(t) {
+    super(), this._graphicsLayer = t, this._symbolPairingsByType = /* @__PURE__ */ new Map();
+  }
+  visualizeIntersectionPoint(t, i) {
+    return this._visualizeSnappingIndicator(new P({ x: t.intersectionPoint[0], y: t.intersectionPoint[1], spatialReference: i.spatialReference }), this._getOrCreateSymbol("intersectionPoint", i.view.effectiveTheme.accentColor));
+  }
+  visualizePoint(t, i) {
+    return this._visualizeSnappingIndicator(new P({ x: t.point[0], y: t.point[1], spatialReference: i.spatialReference }), this._getOrCreateSymbol("point", i.view.effectiveTheme.accentColor));
+  }
+  visualizeLine(t, i) {
+    return this._visualizeSnappingIndicator(new J({ paths: [[t.lineStart, t.lineEnd]], spatialReference: i.spatialReference }), this._getOrCreateSymbol("line", i.view.effectiveTheme.accentColor));
+  }
+  visualizeParallelSign(t, i) {
+    return this._visualizeSnappingIndicator(new J({ paths: [[t.lineStart, t.lineEnd]], spatialReference: i.spatialReference }), this._getOrCreateSymbol("parallelSign", i.view.effectiveTheme.accentColor));
+  }
+  visualizeRightAngleQuad(t, i) {
+    const n = Pe(), s = Pe(), a = b();
+    xe(n, F(t.centerVertex), F(t.previousVertex)), xe(s, F(t.nextVertex), F(t.previousVertex)), Ke(a, n, s);
+    const p = `rightAngleQuad${a[2] < 0 ? 45 : 225}`;
+    return this._visualizeSnappingIndicator(new J({ paths: [[t.previousVertex, t.centerVertex, t.nextVertex]], spatialReference: i.spatialReference }), this._getOrCreateSymbol(p, i.view.effectiveTheme.accentColor));
+  }
+  _visualizeSnappingIndicator(t, i) {
+    const n = new Qe({ geometry: t, symbol: i });
+    return this._graphicsLayer.add(n), Ye(() => {
+      this._graphicsLayer.remove(n);
+    });
+  }
+  _getOrCreateSymbol(t, i) {
+    var s;
+    const n = this._symbolPairingsByType;
+    return ((s = n.get(t)) == null ? void 0 : s.color) !== i && n.set(t, { color: i, symbol: Kt(t, i) }), n.get(t).symbol;
+  }
+};
+function Kt(e, t) {
+  const i = [...t.toRgb(), 255 * t.a];
+  switch (e) {
+    case "point":
+      return new be({ outline: { width: 0.5, color: [0, 0, 0, 1] }, size: 10, color: t });
+    case "intersectionPoint":
+      return new be({ outline: new Xe({ width: 1.5, color: t }), size: 15, color: [0, 0, 0, 0] });
+    case "line":
+      return new ee({ data: { type: "CIMSymbolReference", symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMSolidStroke", enable: !0, capStyle: wt.Butt, joinStyle: ft.Round, miterLimit: 10, width: te(ne.lineHintWidthTarget), color: i }] } } });
+    case "parallelSign":
+      return new ee({ data: { type: "CIMSymbolReference", symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMVectorMarker", enable: !0, anchorPoint: { x: 0, y: -1, z: 0 }, anchorPointUnits: "Relative", size: 5, markerPlacement: { type: "CIMMarkerPlacementOnLine", placePerPart: !0, angleToLine: !0, relativeTo: "LineMiddle" }, frame: { xmin: -5, ymin: -1.5, xmax: 5, ymax: 1.5 }, markerGraphics: [{ type: "CIMMarkerGraphic", geometry: { rings: [[[7, 0], [-7, 0], [-7, 1.5], [7, 1.5]]] }, symbol: { type: "CIMPolygonSymbol", symbolLayers: [{ type: "CIMSolidFill", enable: !0, color: i }] } }], scaleSymbolsProportionally: !0, respectFrame: !0 }, { type: "CIMVectorMarker", enable: !0, anchorPoint: { x: 0, y: 1, z: 0 }, anchorPointUnits: "Relative", size: 5, markerPlacement: { type: "CIMMarkerPlacementOnLine", placePerPart: !0, angleToLine: !0, relativeTo: "LineMiddle" }, frame: { xmin: -5, ymin: -1.5, xmax: 5, ymax: 1.5 }, markerGraphics: [{ type: "CIMMarkerGraphic", geometry: { rings: [[[7, 0], [-7, 0], [-7, -1.5], [7, -1.5]]] }, symbol: { type: "CIMPolygonSymbol", symbolLayers: [{ type: "CIMSolidFill", enable: !0, color: i }] } }], scaleSymbolsProportionally: !0, respectFrame: !0 }] } } });
+    case "rightAngleQuad45":
+    case "rightAngleQuad225": {
+      const n = e === "rightAngleQuad45" ? 45 : 225;
+      return new ee({ data: { type: "CIMSymbolReference", symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMVectorMarker", enable: !0, anchorPoint: { x: 0.5, y: 0.5, z: 0 }, anchorPointUnits: "Relative", size: te(ne.rightAngleHintSize), rotation: n, markerPlacement: { type: "CIMMarkerPlacementOnVertices", placePerPart: !0, angleToLine: !0, placeOnEndPoints: !1 }, frame: { xmin: -5, ymin: -5, xmax: 5, ymax: 5 }, markerGraphics: [{ type: "CIMMarkerGraphic", geometry: { paths: [[[5, -5], [-5, -5], [-5, 5], [5, 5], [5, -5]]] }, symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMSolidStroke", enable: !0, capStyle: "Butt", joinStyle: "Round", miterLimit: 10, width: te(ne.rightAngleHintOutlineSize), color: i }, { type: "CIMSolidFill", enable: !0, color: [...t.toRgb(), 255 * t.a * 0.4] }] } }], scaleSymbolsProportionally: !0, respectFrame: !0 }] } } });
+    }
+  }
+}
+var de;
+let w = de = class extends U.EventedAccessor {
+  constructor(e) {
+    super(e), this._hasZ = null, this._cursorScreenPoint = null, this._activePointerId = null, this._stagedVertexUnsnapped = null, this._lastVertexUnsnapped = null, this.interactiveUndoDisabled = !1, this.history = [], this.redoHistory = [], this.snapToScene = !1, this.view = null, this.elevationInfo = null, this.defaultZ = 0, this._coordinateHelper = $e(!!e.hasZ, !1, e.view.spatialReference), this._snappingManager = e.snappingManager, this._editGeometryOperations = new _e(new ge(e.editGeometryType ?? "polygon", this._coordinateHelper)), this._snappingGraphicsLayer = new yt({ id: de.SNAPPING_GRAPHICS_LAYER_ID, listMode: "hide", internal: !0 }), this._snappingContext = new he({ editGeometryOperations: this._editGeometryOperations, elevationInfo: { mode: "on-the-ground", offset: 0 }, pointer: "mouse", visualizer: new qt(this._snappingGraphicsLayer) }), this._activeComponent = new ye(e.view.spatialReference, ue.Local), this._editGeometryOperations.data.components.push(this._activeComponent);
+  }
+  normalizeCtorArgs(e) {
+    const t = { ...e };
+    return delete t.editGeometryType, t;
+  }
+  initialize() {
+    this._snappingOperation = new Ze({ view: this.view }), this.view.type === "2d" && this.view.map.layers.add(this._snappingGraphicsLayer);
+  }
+  destroy() {
+    this.view.map.layers.remove(this._snappingGraphicsLayer), this._snappingGraphicsLayer.destroy(), this._snappingManager != null && this._snappingManager.doneSnapping(), this._snappingOperation = Z(this._snappingOperation), this._editGeometryOperations.destroy();
+  }
+  get _committedVertices() {
+    return this._editGeometryOperations.data.components[0].vertices.map((e) => e.pos);
+  }
+  get vertices() {
+    return this._stagedVertex != null ? [...this._committedVertices, this._coordinateHelper.pointToArray(this._stagedVertex)] : this._committedVertices;
+  }
+  get hasZ() {
+    return this._hasZ != null ? this._hasZ : this.view.type === "3d";
+  }
+  set hasZ(e) {
+    this._hasZ = e, this.notifyChange("hasZ");
+  }
+  get _stagedVertex() {
+    return this._snappingOperation.stagedPoint;
+  }
+  set _stagedVertex(e) {
+    this._snappingOperation.stagedPoint = ae(e);
+  }
+  canUndo() {
+    return this._editGeometryOperations.canUndo;
+  }
+  canRedo() {
+    return this._editGeometryOperations.canRedo;
+  }
+  undo() {
+    this.canUndo && this._editGeometryOperations.undo();
+  }
+  redo() {
+    this.canRedo && this._editGeometryOperations.redo();
+  }
+  getCoordsFromScreenPoint(e) {
+    const t = e && this.screenToMap(e);
+    return t == null ? null : t.hasZ ? [t.x, t.y, t.z] : [t.x, t.y];
+  }
+  getCoordsAndPointFromScreenPoint(e) {
+    const t = this.screenToMap(e);
+    return t == null ? null : t.hasZ ? { vertex: [t.x, t.y, t.z], mapPoint: t } : { vertex: [t.x, t.y], mapPoint: t };
+  }
+  screenToMap(e) {
+    let t = null;
+    if (this.view.type === "3d")
+      if (this.hasZ) {
+        const i = this.elevationInfo ?? Qt;
+        t = this.view.sceneIntersectionHelper.intersectElevationFromScreen(N(e.x, e.y), i, this._getGeometryZValue());
+      } else {
+        const i = this.elevationInfo ?? Yt;
+        t = this.view.sceneIntersectionHelper.intersectElevationFromScreen(N(e.x, e.y), i, 0), t != null && (t.z = void 0);
+      }
+    else
+      t = this.view.toMap(e), t != null && (t.z = this.hasZ ? this._getGeometryZValue() : void 0);
+    return t;
+  }
+  _pushCursorVertex(e, t) {
+    const i = me(e[0], e[1], void 0, this.view.spatialReference);
+    this._stagedVertexUnsnapped = i;
+    const n = this._snappingManager;
+    if (n == null)
+      return this._stagedVertex = i, void t();
+    le(this._snappingOperation.snap({ point: i }, n, this._snappingContext)).then(() => {
+      t();
+    });
+  }
+  _popCursorVertex() {
+    this._stagedVertexUnsnapped = null, this._stagedVertex = null;
+  }
+  _getGeometryZValue() {
+    return this.defaultZ;
+  }
+  _abortSnapping() {
+    this._snappingOperation.abort();
+  }
+  _isDuplicateOfLastVertex(e) {
+    var s;
+    const t = (s = this._editGeometryOperations.data.components[0].getLastVertex()) == null ? void 0 : s.pos;
+    if (t && e[0] === t[0] && e[1] === t[1])
+      return !0;
+    const { x: i, y: n } = this._coordinateHelper.vectorToDehydratedPoint(e);
+    return this._lastVertexUnsnapped != null && i === this._lastVertexUnsnapped.x && n === this._lastVertexUnsnapped.y;
+  }
+  _shouldHandlePointerEvent(e) {
+    return this._isPrimaryPointerAction(e) && (this._activePointerId == null || this._activePointerId === e.pointerId);
+  }
+  _vertexAddHandler(e) {
+    const t = this._stagedVertex != null ? this._coordinateHelper.pointToArray(this._stagedVertex) : this.getCoordsFromScreenPoint(this._cursorScreenPoint);
+    t != null && this._addVertex(t, e.native);
+  }
+  _drawCompleteHandler(e) {
+    this._completeDrawing(e.native);
+  }
+  _isPrimaryPointerAction(e) {
+    return e.pointerType !== "mouse" || e.button === 0;
+  }
+};
+w.SNAPPING_GRAPHICS_LAYER_ID = "DrawAction-snapping-graphics-layer", o([r({ readOnly: !0 })], w.prototype, "vertices", null), o([r({ type: Boolean, nonNullable: !0 })], w.prototype, "interactiveUndoDisabled", void 0), o([r({ readOnly: !0 })], w.prototype, "history", void 0), o([r({ readOnly: !0 })], w.prototype, "redoHistory", void 0), o([r()], w.prototype, "snapToScene", void 0), o([r()], w.prototype, "view", void 0), o([r()], w.prototype, "elevationInfo", void 0), o([r({ nonNullable: !0 })], w.prototype, "defaultZ", void 0), o([r()], w.prototype, "hasZ", null), o([r()], w.prototype, "_snappingOperation", void 0), o([r()], w.prototype, "_stagedVertex", null), w = de = o([C("esri.views.draw.DrawAction")], w);
+const Qt = { mode: "absolute-height", offset: 0 }, Yt = { mode: "on-the-ground", offset: 0 }, z = w;
+let T = class {
+  constructor(t, i, n) {
+    this.view = t, this.vertexIndex = i, this.vertices = n, this.defaultPrevented = !1, this.type = "vertex-add";
+  }
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+}, A = class {
+  constructor(t, i, n) {
+    this.view = t, this.vertexIndex = i, this.vertices = n, this.defaultPrevented = !1, this.type = "vertex-remove";
+  }
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+};
+class H {
+  constructor(t, i, n, s = null) {
+    this.view = t, this.vertexIndex = i, this.vertices = n, this.mapPoint = s, this.coordinates = null, this.defaultPrevented = !1, this.type = "cursor-update", this.coordinates = n.length === 1 ? n[0] : null;
+  }
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+}
+class I {
+  constructor(t) {
+    this.vertices = t, this.coordinates = null, this.defaultPrevented = !1, this.type = "draw-complete", this.coordinates = t.length === 1 ? t[0] : null;
+  }
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+}
+const Me = Symbol("view-handles"), De = Symbol("undo-redo-handles");
+let pe = class extends z {
+  constructor(e) {
+    super(e), this._popVertexOnPointerMove = !1, this._addVertexOnPointerUp = !1;
+  }
+  initialize() {
+    this._addViewHandles(), this._addUndoRedoHandles();
+  }
+  destroy() {
+    this._removeViewHandles(), this._removeUndoRedoHandles(), this.emit("destroy");
+  }
+  undo() {
+    super.undo(), this.notifyChange("vertices");
+  }
+  redo() {
+    super.redo(), this.notifyChange("vertices");
+  }
+  complete() {
+    this._completeDrawing();
+  }
+  _addViewHandles() {
+    this._removeViewHandles(), this.addHandles([this.view.on("click", (e) => {
+      e.stopPropagation();
+    }, d.TOOL), this.view.on("pointer-down", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._activePointerId = e.pointerId, this._addVertexOnPointerUp = !0, this._cursorScreenPoint = g(e), e.pointerType === "touch" && this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-move", (e) => {
+      this._popVertexOnPointerMove && (this.undo(), this._popVertexOnPointerMove = !1), this._abortSnapping(), this._cursorScreenPoint = g(e), e.pointerType !== "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-drag", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._addVertexOnPointerUp = !1);
+    }, d.TOOL), this.view.on("pointer-up", (e) => {
+      if (this._shouldHandlePointerEvent(e))
+        if (this._abortSnapping(), this._activePointerId = null, this._addVertexOnPointerUp)
+          this._vertexAddHandler(e);
+        else {
+          const t = e.pointerType === "touch";
+          this._updateCursor(t);
+        }
+    }, d.TOOL), this.view.on("drag", ["Shift"], (e) => {
+      e.stopPropagation();
+    }, d.TOOL), this.view.on("double-click", (e) => {
+      e.stopPropagation(), this._drawCompleteHandler(e);
+    }, d.TOOL), this.view.on("double-click", ["Control"], (e) => {
+      e.stopPropagation(), this._drawCompleteHandler(e);
+    }, d.TOOL), this.view.on("key-down", (e) => {
+      const { key: t, repeat: i } = e;
+      t === m.vertexAdd && !i && this._cursorScreenPoint ? (e.stopPropagation(), this._abortSnapping(), this._vertexAddHandler(e)) : t !== m.complete || i ? t !== m.undo || this.interactiveUndoDisabled || i ? t !== m.redo || this.interactiveUndoDisabled || i ? t !== m.pan || i || e.stopPropagation() : (e.stopPropagation(), this.redo()) : (e.stopPropagation(), this.undo()) : (e.stopPropagation(), this._drawCompleteHandler(e));
+    }, d.TOOL), this.view.on("key-up", (e) => {
+      e.key === m.pan && e.stopPropagation();
+    }, d.TOOL)], Me);
+  }
+  _addUndoRedoHandles() {
+    this._removeUndoRedoHandles(), this.addHandles([this._editGeometryOperations.on("vertex-remove", (e) => {
+      if (this.notifyChange("vertices"), e.operation === "undo") {
+        const t = [...this._committedVertices];
+        this._stagedVertex != null && t.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("undo", new A(this.view, e.vertices[0].index, t));
+      }
+    }), this._editGeometryOperations.on("vertex-add", (e) => {
+      if (this.notifyChange("vertices"), e.operation === "apply") {
+        const t = this._committedVertices.length - 1, i = new T(this.view, t, this.vertices);
+        this.emit("vertex-add", i), i.defaultPrevented && (this._popVertexOnPointerMove = !0);
+      } else if (e.operation === "redo") {
+        const t = [...this._committedVertices];
+        this._stagedVertex != null && t.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("redo", new T(this.view, e.vertices[0].index, t));
+      }
+    })], De);
+  }
+  _removeViewHandles() {
+    this.removeHandles(Me);
+  }
+  _removeUndoRedoHandles() {
+    this.removeHandles(De);
+  }
+  _addVertex(e) {
+    const t = this._coordinateHelper.arrayToVector(e);
+    this._isDuplicateOfLastVertex(t) || this._editGeometryOperations.appendVertex(t);
+  }
+  _updateCursor(e = !1) {
+    if (this._popCursorVertex(), !this._cursorScreenPoint)
+      return;
+    const t = this.getCoordsAndPointFromScreenPoint(this._cursorScreenPoint);
+    t == null || e || this._pushCursorVertex(t.vertex, () => this.emit("cursor-update", new H(this.view, this._activeComponent.vertices.length, this.vertices, this._stagedVertex != null ? new P(this._stagedVertex) : null)));
+  }
+  _completeDrawing() {
+    if (this._activePointerId = null, this._popCursorVertex(), this._abortSnapping(), this._snappingManager != null && this._snappingManager.doneSnapping(), this.vertices.length < 1)
+      return;
+    const e = new I(this.vertices);
+    this.emit("draw-complete", e), e.defaultPrevented || this._removeViewHandles();
+  }
+};
+pe = o([C("esri.views.draw.MultipointDrawAction")], pe);
+const Fe = ["freehand", "hybrid", "click"], X = "click";
+let Xt = class {
+  constructor({ consumesClicks: t, grabbableForEvent: i }) {
+    this.events = new U(), this.interactive = !0, this.selectable = !1, this.cursor = null, this.grabbable = !0, this.consumesClicks = t, this.grabbableForEvent = i;
+  }
+  destroy() {
+  }
+  intersectionDistance(t, i) {
+    return 0;
+  }
+  attach() {
+  }
+  detach() {
+  }
+  onElevationChange() {
+  }
+  onViewChange() {
+  }
+}, W = class extends Q {
+  constructor(e) {
+    super(e), this.enabled = !1;
+  }
+};
+o([r({ type: Boolean, nonNullable: !0 })], W.prototype, "enabled", void 0), W = o([C("esri.views.interactive.sketch.SketchLabelOptions")], W);
+const We = W;
+function Jt(e, t, i) {
+  if (t == null || e == null)
+    return;
+  const n = tt(i.measurementSR);
+  if (n == null)
+    return;
+  const s = fe(e, i);
+  if (s == null)
+    return;
+  const a = Y(t, n);
+  return new Pt(Ot(s), a);
+}
+function ei(e, t, i, n) {
+  if (i == null || e == null)
+    return;
+  const s = fe(e, n);
+  if (s == null)
+    return;
+  const a = q(i), p = 10, l = (u) => {
+    if (u == null)
+      return;
+    const v = b(), f = Ut(u, "degrees", "geographic");
+    return St(v, s, n.measurementSR, p, f, n.mode) ? new Ct(s, v) : void 0;
+  }, h = () => {
+    if (t != null && e != null)
+      return q(Ge(t, e));
+  };
+  switch (n.directionMode) {
+    case E.Absolute:
+      return l(a);
+    case E.Relative: {
+      const u = h();
+      return u == null ? void 0 : l(u + a);
+    }
+    case E.RelativeBilateral: {
+      const u = h();
+      return u == null ? void 0 : Ee([l(u + a), l(u - a)]);
+    }
+  }
+}
+function we(e, t) {
+  const i = si(e, t);
+  return i != null ? new Tt(i) : void 0;
+}
+function Be(e, t, i, n, s, a) {
+  if (i == null && n == null && s == null)
+    return;
+  if (t == null)
+    return we(n, a);
+  const { view: p, elevationInfo: l, measurementSR: h } = a, u = ke(t, p, l);
+  if (!h || !ve(u, t.spatialReference, B, h))
+    return;
+  const v = [B[0], B[1]], f = i != null ? Y(i, "meters") : void 0, x = ri(n, a), S = q(s), V = (O) => {
+    const D = new Vt(v, h, f, x, O);
+    return f == null || O == null || x == null && a.hasZ ? D : new Ht(D.closestTo(u));
+  };
+  if (S == null)
+    return V(void 0);
+  const M = () => {
+    if (e != null && t != null)
+      return q(Ge(e, t));
+  };
+  switch (a.directionMode) {
+    case E.Absolute:
+      return V(S);
+    case E.Relative: {
+      const O = M();
+      return O == null ? void 0 : V(O + S);
+    }
+    case E.RelativeBilateral: {
+      const O = M();
+      return O == null ? void 0 : Ee([V(O + S), V(O - S)]);
+    }
+  }
+}
+function ti(e, t) {
+  return t.mode === "geodesic" ? Be(null, null, null, e, null, t) : we(e, t);
+}
+function ii(e, t, i, n, s, a) {
+  return a.mode === "geodesic" ? Be(t, e, i, s, n, a) : ni([Jt(e, i, a), ei(e, t, n, a), we(s, a)]);
+}
+function ni(e) {
+  let t;
+  for (const i of e)
+    i && (t = (t == null ? void 0 : t.intersect(i)) ?? i);
+  return t;
+}
+function fe(e, t) {
+  const { view: i, elevationInfo: n, measurementSR: s, origin: a, mode: p } = t, l = ke(e, i, n);
+  if (ve(l, e.spatialReference, l, s))
+    return p !== "geodesic" && Re(l, l, a), l;
+}
+function oi(e, t, i) {
+  const { view: n, measurementSR: s, spatialReference: a, origin: p, mode: l } = i, h = B;
+  if (l === "geodesic" ? Je(h, e) : et(h, e, p), ve(h, s, h, a))
+    return bt(h, n, t, i);
+}
+function si(e, t) {
+  var i;
+  return ((i = je(e, t)) == null ? void 0 : i.value) ?? void 0;
+}
+function ri(e, t) {
+  const i = je(e, t);
+  return i != null ? Y(i, "meters") : void 0;
+}
+function je(e, { view: t, origin: i, elevationInfo: n, hasZ: s, measurementSR: a }) {
+  if (e == null || !s)
+    return;
+  const p = it(a);
+  if (p == null)
+    return;
+  const [l, h] = i, u = Y(e, p), v = (t == null ? void 0 : t.type) === "3d" ? $t(t, l, h, u, a, n) : u;
+  return v != null ? Zt(v, p) : void 0;
+}
+const B = b(), ai = "crosshair", li = "progress";
+let c = class extends U.EventedMixin(Q) {
+  constructor(e) {
+    super(e), this._createOperationCompleted = !1, this._hideDefaultCursor = !1, this._pointerDownStates = /* @__PURE__ */ new Set(), this._stagedScreenPoint = null, this._stagedPointerType = null, this._stagedPointerId = null, this._updatingHandles = new nt(), this.constraintsEnabled = !1, this.constraintInfo = void 0, this._getPointConstraint = He(ti), this._getPolylineOrPolygonConstraint = He(ii), this.constraintZ = null, this.defaultZ = null, this.isDraped = !0, this.labelOptions = new We(), this.cursor = null, this.loading = !1, this.snapToSceneEnabled = null, this.firstVertex = null, this.lastVertex = null, this.secondToLastVertex = null, e.elevationInfo == null && (this.elevationInfo = Ue(!!e.hasZ));
+  }
+  initialize() {
+    const { geometryType: e, view: t } = this, i = t.spatialReference, n = "viewingMode" in t.state ? t.state.viewingMode : ue.Local, s = e === "segment" || e === "multipoint" ? "polyline" : e;
+    this.coordinateHelper = $e(this.hasZ, this.hasM, i), this._editGeometryOperations = new _e(new ge(s, this.coordinateHelper)), this._snappingOperation = new Ze({ view: t }), this.addHandles([G(() => ({ stagedPoint: this._snappingOperation.stagedPoint, constraint: this.constraint }), ({ stagedPoint: l, constraint: h }, u) => {
+      var f, x;
+      const { snappingOptions: v } = this;
+      if (v && (v.forceDisabled = h != null && It(h), v.constraintsActive = ((f = this.constraintInfo) == null ? void 0 : f.distance) != null || ((x = this.constraintInfo) == null ? void 0 : x.direction) != null), u != null && l === u.stagedPoint && h !== u.constraint)
+        return this._onKeyboardBasedChange();
+      this._processCursor(l ?? this._screenToMap(this._stagedScreenPoint));
+    }, { sync: !0, equals: (l, h) => l.stagedPoint === h.stagedPoint && ot(l.constraint, h.constraint) }), G(() => this.view.viewpoint, (l, h) => {
+      l && h && Gt(l, h) && this._onKeyboardBasedChange();
+    })]), this._activeComponent = new ye(i, n), this._editGeometryOperations.data.components.push(this._activeComponent);
+    const a = this.segmentLabels;
+    a != null && (a.context = { view: t, editGeometryOperations: this._editGeometryOperations, elevationInfo: this.elevationInfo, labelOptions: this.labelOptions }, this.addHandles(G(() => this.labelOptions.enabled, (l) => {
+      a.visible = l;
+    }, Oe))), this.addHandles(this._editGeometryOperations.on(["vertex-add", "vertex-update", "vertex-remove"], (l) => {
+      var S, V, M, O;
+      const h = l.vertices.map((D) => ({ componentIndex: 0, vertexIndex: D.index, coordinates: this.coordinateHelper.vectorToArray(D.pos) })), u = h.map((D) => D.coordinates), v = this.coordinateHelper.vectorToDehydratedPoint((S = this._activeComponent.getFirstVertex()) == null ? void 0 : S.pos) ?? null;
+      oe(v, this.firstVertex) || (this.firstVertex = v);
+      const f = this.coordinateHelper.vectorToDehydratedPoint((V = this._activeComponent.getLastVertex()) == null ? void 0 : V.pos) ?? null;
+      oe(f, this.lastVertex) || (this.lastVertex = f);
+      const x = this.coordinateHelper.vectorToDehydratedPoint((O = (M = this._activeComponent.edges.at(-1)) == null ? void 0 : M.leftVertex) == null ? void 0 : O.pos) ?? null;
+      switch (oe(x, this.secondToLastVertex) || (this.secondToLastVertex = x), this._processCursor(this.cursorVertex), l.type) {
+        case "vertex-add":
+          this.emit(l.type, { ...l, added: u, vertices: h });
+          break;
+        case "vertex-update":
+          this.emit(l.type, { ...l, updated: u, vertices: h });
+          break;
+        case "vertex-remove":
+          this.emit(l.type, { ...l, removed: u, vertices: h });
+      }
+    }));
+    const p = this._manipulator = new Xt({ consumesClicks: !1, grabbableForEvent: (l) => this.drawingMode !== "click" || l.pointerType === "touch" && this._snappingEnabled && this._pointerDownStates.size === 1 });
+    this.manipulators.add(p), p.grabbable = e !== "point", this.addHandles([this._createManipulatorDragPipeline(p), p.events.on("immediate-click", (l) => this._onImmediateClick(l)), p.events.on("immediate-double-click", (l) => this._onImmediateDoubleClick(l)), G(() => ({ effectiveCursor: this.effectiveCursor }), ({ effectiveCursor: l }) => {
+      p.cursor = l;
+    }, Oe)]), Mt(this, () => {
+      const l = this.view.inputManager.latestPointerType ?? "mouse", h = this._getSnappingContext(l);
+      this.snappingManager != null && this._updatingHandles.addPromise(le(this._snappingOperation.snapAgainNearPreviousMapPoint(this.snappingManager, h)));
+    });
+  }
+  destroy() {
+    Z(this.segmentLabels), Z(this._snappingOperation), this._editGeometryOperations = Z(this._editGeometryOperations), this._updatingHandles.destroy();
+  }
+  get _snappingEnabled() {
+    return this.snappingManager != null && this.snappingManager.options.effectiveEnabled;
+  }
+  get _requiresScenePoint() {
+    const e = this._updateAndGetEffectiveDrawSurface();
+    return this.view.type === "3d" && this.drawSurface !== e;
+  }
+  get canRedo() {
+    return this._editGeometryOperations.canRedo;
+  }
+  get canUndo() {
+    return this._editGeometryOperations.canUndo;
+  }
+  get committedVertices() {
+    return this._activeComponent.vertices.map((e) => this.coordinateHelper.vectorToArray(e.pos));
+  }
+  get constraint() {
+    const { constraintInfo: e, constraintsEnabled: t } = this;
+    if (e && t)
+      switch (this.geometryType) {
+        case "point":
+          return this._getPointConstraint(e.elevation, e.context);
+        case "polygon":
+        case "polyline":
+          return this._getPolylineOrPolygonConstraint(this.lastVertex, this.secondToLastVertex, e.distance, e.direction, e.elevation, e.context);
+      }
+  }
+  set drawingMode(e) {
+    this._set("drawingMode", e ?? X);
+  }
+  get effectiveCursor() {
+    return this.loading ? li : this._hideDefaultCursor ? null : this.cursor || ai;
+  }
+  get interactive() {
+    return this._manipulator.interactive;
+  }
+  set interactive(e) {
+    this._manipulator.interactive = e;
+  }
+  get isCompleted() {
+    return this._createOperationCompleted;
+  }
+  get numCommittedVertices() {
+    return this._activeComponent.vertices.length;
+  }
+  get snappingOptions() {
+    return this.snappingManager != null ? this.snappingManager.options : null;
+  }
+  get cursorVertex() {
+    return this._get("cursorVertex");
+  }
+  get visualizationCursorVertex() {
+    return this._stagedPointerType === "mouse" ? this.cursorVertex : null;
+  }
+  get committableVertex() {
+    const { cursorVertex: e, lastVertex: t, firstVertex: i, geometryType: n } = this;
+    return n === "polygon" && se(e, i) || se(e, t) ? null : e;
+  }
+  get updating() {
+    return this._updatingHandles.updating;
+  }
+  get geometryIncludingUncommittedVertices() {
+    const { committedVertices: e, committableVertex: t, coordinateHelper: i } = this, n = e.slice();
+    return t != null && n.push(i.pointToArray(t)), n;
+  }
+  cancel() {
+    this.complete({ aborted: !0 });
+  }
+  commitStagedVertex() {
+    this._snappingOperation.abort();
+    const { committableVertex: e } = this;
+    e != null && this._editGeometryOperations.appendVertex(this.coordinateHelper.pointToVector(e));
+  }
+  complete(e) {
+    var a;
+    const t = (e == null ? void 0 : e.aborted) || !1;
+    this._snappingOperation.abort(), (a = this.snappingManager) == null || a.doneSnapping();
+    const { geometryType: i, numCommittedVertices: n } = this, s = i === "multipoint" && n === 0 || i === "polyline" && n < 2 || i === "polygon" && n < 3;
+    i !== "segment" && i !== "point" || this.commitStagedVertex(), this._createOperationCompleted = !s, (this.isCompleted || t) && (this._stagedScreenPoint = null, this._stagedPointerId = null, this._stagedPointerType = null, this._processCursor(null), this.emit("complete", { vertices: this.committedVertices.map((p, l) => ({ componentIndex: 0, vertexIndex: l, coordinates: p })), aborted: t, type: "complete" }));
+  }
+  onInputEvent(e) {
+    switch (e.type) {
+      case "pointer-down":
+        this._pointerDownStates.add(e.pointerId);
+        break;
+      case "pointer-up":
+        this._pointerDownStates.delete(e.pointerId);
+    }
+    switch (e.type) {
+      case "pointer-move":
+        return this._onPointerMove(e);
+      case "hold":
+        return this._onHold(e);
+    }
+  }
+  redo() {
+    this._editGeometryOperations.redo();
+  }
+  undo() {
+    this.snappingManager != null && this.snappingManager.doneSnapping(), this._editGeometryOperations.undo();
+  }
+  _processCursor(e) {
+    var p, l;
+    const t = ae(this.cursorVertex), i = ae(e), n = i && (((p = this._updateAndGetEffectiveDrawSurface()) == null ? void 0 : p.constrainZ(i)) ?? i), s = this._snapToClosingVertex(n), a = this._applyConstraints(s);
+    se(t, a) || (this._set("cursorVertex", a), (l = this.segmentLabels) == null || l.set("stagedVertex", a != null ? this.coordinateHelper.pointToVector(a) : null), a == null || this._stagedPointerType !== "mouse" ? this.emit("cursor-remove") : this.emit("cursor-update", { updated: null, vertices: [{ componentIndex: 0, vertexIndex: this._activeComponent.vertices.length, coordinates: this.coordinateHelper.pointToArray(a) }], operation: "apply", type: "vertex-update" }));
+  }
+  _snapToClosingVertex(e) {
+    if (e == null || this.geometryType !== "polygon" || this.numCommittedVertices <= 2)
+      return e;
+    const t = this._mapToScreen(e);
+    if (!t)
+      return e;
+    const i = this._activeComponent;
+    return this._vertexWithinPointerDistance(i.vertices[0].pos, t) ? this.firstVertex : this._vertexWithinPointerDistance(i.vertices.at(-1).pos, t) ? this.lastVertex : e;
+  }
+  _createManipulatorDragPipeline(e) {
+    switch (this.drawingMode) {
+      case "click":
+        return this._createManipulatorDragPipelineClick(e);
+      case "freehand":
+        return this._createManipulatorDragPipelineFreehand(e);
+      case "hybrid":
+        return this._createManipulatorDragPipelineHybrid(e);
+    }
+  }
+  _createManipulatorDragPipelineClick(e) {
+    return re(e, (t, i, n, s) => {
+      const a = s === "touch" && this._snappingEnabled;
+      if (this.isCompleted || !a)
+        return;
+      const { snappingStep: p, cancelSnapping: l } = Dt({ predicate: () => a, snappingManager: this.snappingManager, snappingContext: new he({ editGeometryOperations: this._editGeometryOperations, elevationInfo: this.elevationInfo, feature: this.graphic, pointer: s, visualizer: this.snappingVisualizer }), updatingHandles: this._updatingHandles, useZ: !this._requiresScenePoint });
+      n = n.next((h) => (a && this.snappingManager != null && this.snappingManager.doneSnapping(), h)).next(l), i.next(this._screenToMapDragEventStep()).next((h) => (h.action === "start" && (this._processCursor(h.mapStart), (this.geometryType === "segment" || a && !this.numCommittedVertices) && this.commitStagedVertex()), h)).next(At(this.view, this.elevationInfo)).next(...p).next((h) => (a && (this._processCursor(h.mapEnd), h.action === "end" && this.commitStagedVertex()), h)).next((h) => (h.action === "end" && (this._stagedPointerType !== "mouse" && this._snappingOperation.abort(), this.geometryType !== "segment" && this.geometryType !== "point" || this.complete()), h));
+    });
+  }
+  _createManipulatorDragPipelineFreehand(e) {
+    return re(e, (t, i) => {
+      this.isCompleted || i.next(this._screenToMapDragEventStep()).next((n) => (n.action === "start" && (this._snappingOperation.abort(), this.committableVertex == null && this._processCursor(n.mapStart), this.geometryType === "segment" && this.commitStagedVertex()), n)).next((n) => {
+        switch (n.action) {
+          case "start":
+          case "update":
+            this._processCursor(n.mapEnd), this.geometryType !== "polygon" && this.geometryType !== "polyline" || this.commitStagedVertex();
+            break;
+          case "end":
+            this.complete();
+        }
+        return n;
+      });
+    });
+  }
+  _createManipulatorDragPipelineHybrid(e) {
+    return re(e, (t, i) => {
+      this.isCompleted || i.next(this._screenToMapDragEventStep()).next((n) => (n.action === "start" && (this._snappingOperation.abort(), this._processCursor(n.mapStart), this.commitStagedVertex()), n)).next((n) => {
+        switch (n.action) {
+          case "start":
+          case "update":
+            this._processCursor(n.mapEnd), this.geometryType !== "polygon" && this.geometryType !== "polyline" || this.commitStagedVertex();
+            break;
+          case "end":
+            this._stagedPointerType !== "mouse" && this._snappingOperation.abort(), this.geometryType !== "segment" && this.geometryType !== "point" || this.complete();
+        }
+        return n;
+      });
+    });
+  }
+  get _drawAtFixedElevation() {
+    const { constraintsEnabled: e, constraintZ: t, geometryType: i, numCommittedVertices: n } = this;
+    return e ? t != null || i === "segment" && n > 0 : (i === "segment" || i === "polygon") && n > 0;
+  }
+  _updateAndGetEffectiveDrawSurface() {
+    var h;
+    const { constraintsEnabled: e, coordinateHelper: t, drawSurface: i, elevationDrawSurface: n, snapToSceneEnabled: s } = this;
+    if (n == null)
+      return i;
+    if (!this.hasZ)
+      return n.defaultZ = null, n;
+    const a = (h = this.elevationInfo) == null ? void 0 : h.mode;
+    let p = this.defaultZ, l = e || a === "absolute-height";
+    return s != null && (l = s), a === "on-the-ground" && (l = !1), this._drawAtFixedElevation && (p = (e ? this.constraintZ : null) ?? t.getZ(this._activeComponent.vertices[0].pos), l = !1), l ? i : (n.defaultZ = p, n);
+  }
+  _mapToScreen(e) {
+    var t;
+    return (t = this._updateAndGetEffectiveDrawSurface()) == null ? void 0 : t.mapToScreen(e);
+  }
+  _onHold(e) {
+    this._snappingOperation.abort(), this.drawingMode === "click" && e.pointerType === "touch" && this._snappingEnabled && this._processCursor(e.mapPoint), e.stopPropagation();
+  }
+  _onImmediateClick(e) {
+    if (!(e.pointerType === "mouse" && e.button === 2 || this._manipulator.dragging))
+      try {
+        const { drawingMode: t, geometryType: i } = this;
+        this._stagedPointerType = e.pointerType, this._stagedScreenPoint = e.screenPoint;
+        const n = this._screenToMap(e.screenPoint);
+        if (n == null || n == null || t === "freehand" && i !== "point")
+          return;
+        if (this._snappingEnabled && this.cursorVertex != null || this._processCursor(n), this.committableVertex == null)
+          return void this.complete();
+        this.commitStagedVertex(), e.pointerType !== "mouse" && this._processCursor(null), (t === "freehand" || i === "point" || i === "segment" && this.numCommittedVertices === 2 || i === "segment" && t === "hybrid" && this.numCommittedVertices === 1) && this.complete();
+      } finally {
+        e.stopPropagation();
+      }
+  }
+  _onImmediateDoubleClick(e) {
+    this._manipulator.dragging || this.geometryType === "point" || (this.complete(), e.stopPropagation());
+  }
+  _onPointerMove(e) {
+    const t = st(e.x, e.y);
+    this._stagedScreenPoint = t, this._stagedPointerType = e.pointerType, this._stagedPointerId = e.pointerId;
+    const i = this._snappingOperation, n = this._manipulator;
+    this._pointerDownStates.has(e.pointerId) || n.grabbing || !n.interactive ? i.abort() : (e.stopPropagation(), this._processCursorMovementRelativeToSurface(t, e.pointerType));
+  }
+  _onKeyboardBasedChange() {
+    const e = this._manipulator;
+    this._stagedPointerType === "mouse" && this._stagedScreenPoint && this._stagedPointerId != null && !this._pointerDownStates.has(this._stagedPointerId) && !e.grabbing && e.interactive ? this._processCursorMovementRelativeToSurface(this._stagedScreenPoint, this._stagedPointerType) : this._snappingOperation.abort();
+  }
+  _processCursorMovementRelativeToSurface(e, t) {
+    var l;
+    const i = this._snappingOperation, n = this._screenToMap(e), s = this._requiresScenePoint ? (l = this.drawSurface) == null ? void 0 : l.screenToMap(e) : null;
+    if (n == null)
+      return this._hideDefaultCursor = !0, this._processCursor(null), void i.abort();
+    this._hideDefaultCursor = !1;
+    const a = this.snappingManager;
+    if (a == null)
+      return this._processCursor(n), void i.abort();
+    const p = this._getSnappingContext(t);
+    this._updatingHandles.addPromise(le(i.snap({ point: n, scenePoint: s }, a, p)));
+  }
+  _applyConstraints(e) {
+    const { constraint: t, constraintInfo: i } = this;
+    if (!e || !i || !t)
+      return e;
+    const { context: n } = i, s = fe(e, n), a = s ? t.closestTo(s) : void 0;
+    if (!a)
+      return e;
+    const p = oi(a, e, n);
+    return p != null && n.elevationInfo.mode !== "absolute-height" && this.constraintZ != null && this.hasZ && (p.z = this.constraintZ), p;
+  }
+  _screenToMap(e) {
+    var t;
+    return e ? (t = this._updateAndGetEffectiveDrawSurface()) == null ? void 0 : t.screenToMap(e) : null;
+  }
+  _screenToMapDragEventStep() {
+    let e = null;
+    return (t) => {
+      if (t.action === "start" && (e = this._screenToMap(t.screenStart)), e == null)
+        return null;
+      const i = this._screenToMap(t.screenEnd);
+      return i != null ? { ...t, mapStart: e, mapEnd: i } : null;
+    };
+  }
+  _vertexWithinPointerDistance(e, t) {
+    const n = this._mapToScreen(this.coordinateHelper.vectorToDehydratedPoint(e));
+    return n != null && hi(n, t, 25);
+  }
+  _getSnappingContext(e) {
+    var i;
+    const t = this._drawAtFixedElevation ? (i = this.elevationDrawSurface) == null ? void 0 : i.defaultZ : null;
+    return new he({ editGeometryOperations: this._editGeometryOperations, elevationInfo: this.elevationInfo, pointer: e, feature: this.graphic, visualizer: this.snappingVisualizer, selfSnappingZ: t != null ? { value: t, elevationInfo: this.elevationInfo } : null });
+  }
+};
+function hi(e, t, i) {
+  const n = e.x - t.x, s = e.y - t.y;
+  return n * n + s * s <= i;
+}
+o([r()], c.prototype, "_hideDefaultCursor", void 0), o([r()], c.prototype, "_snappingOperation", void 0), o([r()], c.prototype, "_snappingEnabled", null), o([r({ constructOnly: !0 })], c.prototype, "graphic", void 0), o([r()], c.prototype, "constraintsEnabled", void 0), o([r()], c.prototype, "constraintInfo", void 0), o([r()], c.prototype, "constraint", null), o([r()], c.prototype, "constraintZ", void 0), o([r()], c.prototype, "defaultZ", void 0), o([r()], c.prototype, "isDraped", void 0), o([r({ value: X })], c.prototype, "drawingMode", null), o([r({ constructOnly: !0 })], c.prototype, "elevationDrawSurface", void 0), o([r({ constructOnly: !0 })], c.prototype, "elevationInfo", void 0), o([r({ constructOnly: !0, type: We })], c.prototype, "labelOptions", void 0), o([r({ constructOnly: !0 })], c.prototype, "geometryType", void 0), o([r({ constructOnly: !0 })], c.prototype, "hasM", void 0), o([r({ constructOnly: !0 })], c.prototype, "hasZ", void 0), o([r()], c.prototype, "cursor", void 0), o([r()], c.prototype, "effectiveCursor", null), o([r()], c.prototype, "loading", void 0), o([r({ constructOnly: !0 })], c.prototype, "manipulators", void 0), o([r({ constructOnly: !0 })], c.prototype, "drawSurface", void 0), o([r({ constructOnly: !0 })], c.prototype, "segmentLabels", void 0), o([r({ constructOnly: !0 })], c.prototype, "snappingManager", void 0), o([r({ constructOnly: !0 })], c.prototype, "snappingVisualizer", void 0), o([r()], c.prototype, "snapToSceneEnabled", void 0), o([r({ readOnly: !0 })], c.prototype, "cursorVertex", null), o([r({ readOnly: !0 })], c.prototype, "visualizationCursorVertex", null), o([r()], c.prototype, "committableVertex", null), o([r()], c.prototype, "firstVertex", void 0), o([r()], c.prototype, "lastVertex", void 0), o([r()], c.prototype, "secondToLastVertex", void 0), o([r()], c.prototype, "updating", null), o([r({ constructOnly: !0 })], c.prototype, "view", void 0), c = o([C("esri.views.draw.DrawOperation")], c);
+class di {
+  constructor(t, i, n, s = null) {
+    this._elevationInfo = t, this.defaultZ = i, this._view = n, this._excludeGraphics = s;
+  }
+  screenToMap(t) {
+    const { defaultZ: i, _view: n } = this, s = n.sceneIntersectionHelper.intersectElevationFromScreen(N(t.x, t.y), this._elevationInfo, i ?? 0, this._excludeGraphics);
+    return i == null && s != null && (s.z = void 0), s;
+  }
+  mapToScreen(t) {
+    const i = me(t.x, t.y, ze(this._view, t, this._elevationInfo), t.spatialReference);
+    return this._view.toScreen(i);
+  }
+  constrainZ(t) {
+    const { defaultZ: i } = this;
+    return i != null && t.z !== i && ((t = Lt(t)).z = i), t;
+  }
+}
+let pi = class {
+  constructor(t, i, n = []) {
+    this.view = t, this.elevationInfo = i, this.exclude = n;
+  }
+  screenToMap(t) {
+    const i = this.view.toMap(t, { exclude: this.exclude, excludeHud: !0 });
+    return i != null && (i.z = kt(i, this.view, this.elevationInfo)), i;
+  }
+  mapToScreen(t) {
+    let i = t;
+    return this.elevationInfo != null && (i = me(t.x, t.y, ze(this.view, t, this.elevationInfo), t.spatialReference)), this.view.toScreen(i);
+  }
+  constrainZ(t) {
+    return t;
+  }
+};
+new rt();
+let _ = class extends U.EventedMixin(Rt) {
+  constructor(t) {
+    super(t), this.defaultZ = 0, this.elevationInfo = null, this.hasZ = !0, this.mode = null, this.snapToScene = null, this.type = "draw-3d";
+  }
+  initialize() {
+    const t = this.view, i = Ue(this.hasZ, this.elevationInfo);
+    this.drawOperation = new c({ view: t, manipulators: this.manipulators, geometryType: this.geometryType, drawingMode: this.mode, hasZ: this.hasZ, defaultZ: this.defaultZ, snapToSceneEnabled: this.snapToScene, drawSurface: t.type === "3d" ? new pi(t, i) : null, elevationDrawSurface: t.type === "3d" ? new di(i, this.defaultZ, t) : null, hasM: !1, elevationInfo: i }), this.addHandles([this.drawOperation.on("vertex-add", (n) => this.onVertexAdd(n)), this.drawOperation.on("vertex-remove", (n) => this.onVertexRemove(n)), this.drawOperation.on("vertex-update", (n) => this.onVertexUpdate(n)), this.drawOperation.on("cursor-update", (n) => this.onCursorUpdate(n)), this.drawOperation.on("complete", (n) => this.onComplete(n))]), this.finishToolCreation();
+  }
+  destroy() {
+    this.drawOperation = Z(this.drawOperation), this._set("view", null);
+  }
+  set enabled(t) {
+    this.drawOperation.interactive = t, this._set("enabled", t);
+  }
+  get updating() {
+    var t;
+    return ((t = this.drawOperation) == null ? void 0 : t.updating) ?? !1;
+  }
+  completeCreateOperation() {
+    this.drawOperation.complete();
+  }
+  onDeactivate() {
+    this.drawOperation.isCompleted || this.drawOperation.cancel();
+  }
+  getVertexCoords() {
+    return this.drawOperation.geometryIncludingUncommittedVertices;
+  }
+  onInputEvent(t) {
+    this.drawOperation.onInputEvent(t);
+  }
+  canRedo() {
+    return this.drawOperation.canRedo;
+  }
+  canUndo() {
+    return this.drawOperation.canUndo;
+  }
+  redo() {
+    this.drawOperation.redo();
+  }
+  reset() {
+  }
+  undo() {
+    this.drawOperation.undo();
+  }
+  onComplete(t) {
+    this.emit("complete", t);
+  }
+  onCursorUpdate(t) {
+    this.emit("cursor-update", t);
+  }
+  onVertexAdd(t) {
+    this.emit("vertex-add", t);
+  }
+  onVertexRemove(t) {
+    this.emit("vertex-remove", t);
+  }
+  onVertexUpdate(t) {
+    this.emit("vertex-update", t);
+  }
+};
+o([r({ constructOnly: !0, nonNullable: !0 })], _.prototype, "defaultZ", void 0), o([r()], _.prototype, "drawOperation", void 0), o([r({ constructOnly: !0 })], _.prototype, "elevationInfo", void 0), o([r({ value: !0 })], _.prototype, "enabled", null), o([r({ constructOnly: !0 })], _.prototype, "geometryType", void 0), o([r({ constructOnly: !0 })], _.prototype, "hasZ", void 0), o([r({ constructOnly: !0 })], _.prototype, "mode", void 0), o([r()], _.prototype, "snapToScene", void 0), o([r({ readOnly: !0 })], _.prototype, "type", void 0), o([r({ readOnly: !0 })], _.prototype, "updating", null), o([r({ constructOnly: !0, nonNullable: !0 })], _.prototype, "view", void 0), _ = o([C("esri.views.draw.DrawTool")], _);
+let ce = class extends z {
+  constructor(e) {
+    super(e), this._addVertexOnPointerUp = !1, this._drawTool = null;
+  }
+  initialize() {
+    this._addViewHandles(), this.view.type === "3d" && this._addDrawTool();
+  }
+  destroy() {
+    this._removeDrawTool(), this.emit("destroy");
+  }
+  complete() {
+    this._completeDrawing();
+  }
+  _addViewHandles() {
+    this._addViewHandles2DOnly(), this.addHandles([this.view.on("key-down", (e) => {
+      e.key === m.complete && (this._drawTool ? this.complete() : (this._abortSnapping(), this._vertexAddHandler(e)));
+    }, d.TOOL)]);
+  }
+  _addViewHandles2DOnly() {
+    this.view.type === "2d" && this.addHandles([this.view.on("pointer-down", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._activePointerId = e.pointerId, this._addVertexOnPointerUp = !0, this._cursorScreenPoint = g(e), e.pointerType === "touch" && this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-move", (e) => {
+      this._abortSnapping(), this._cursorScreenPoint = g(e), e.pointerType !== "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-drag", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._addVertexOnPointerUp = !1);
+    }, d.TOOL), this.view.on("pointer-up", (e) => {
+      if (this._shouldHandlePointerEvent(e))
+        if (this._abortSnapping(), this._activePointerId = null, this._addVertexOnPointerUp)
+          e.stopPropagation(), this._vertexAddHandler(e);
+        else {
+          const t = e.pointerType === "touch";
+          this._updateCursor(t);
+        }
+    }, d.TOOL), this.view.on("drag", ["Shift"], (e) => {
+      e.stopPropagation();
+    }, d.TOOL)]);
+  }
+  _addDrawTool() {
+    const e = new _({ view: this.view, elevationInfo: this.elevationInfo, hasZ: this.hasZ, geometryType: "point", mode: "click" });
+    this._drawTool = e, this.view.addAndActivateTool(e), this.addHandles([e.on("cursor-update", (t) => {
+      t.vertices.length === 1 && this.emit("cursor-update", new H(this.view, t.vertices[0].vertexIndex, e.getVertexCoords()));
+    }), e.on("complete", (t) => {
+      this.emit("draw-complete", new I(e.getVertexCoords())), this._removeDrawTool(), this.removeAllHandles();
+    })]);
+  }
+  _removeDrawTool() {
+    this._drawTool && (this.view.tools.remove(this._drawTool), this._drawTool = null);
+  }
+  _addVertex(e) {
+    const t = this._coordinateHelper.arrayToVector(e);
+    this._isDuplicateOfLastVertex(t) || (this._lastVertexUnsnapped = this._stagedVertexUnsnapped, this._popCursorVertex(), this._editGeometryOperations.appendVertex(t), this.notifyChange("vertices"), this._completeDrawing());
+  }
+  _updateCursor(e = !1) {
+    if (this._popCursorVertex(), !this._cursorScreenPoint)
+      return;
+    const t = this.getCoordsAndPointFromScreenPoint(this._cursorScreenPoint);
+    t == null || e || this._pushCursorVertex(t.vertex, () => this.emit("cursor-update", new H(this.view, this._activeComponent.vertices.length, this.vertices, this._stagedVertex != null ? new P(this._stagedVertex) : null)));
+  }
+  _completeDrawing() {
+    if (this._drawTool)
+      return void this._drawTool.completeCreateOperation();
+    this._activePointerId = null, this._popCursorVertex(), this._abortSnapping(), this._snappingManager != null && this._snappingManager.doneSnapping();
+    const e = new I(this.vertices);
+    this.emit("draw-complete", e), e.defaultPrevented || this.removeAllHandles();
+  }
+};
+ce = o([C("esri.views.draw.PointDrawAction")], ce);
+let L = class extends z {
+  constructor(t) {
+    super(t), this._panEnabled = !1, this._popVertexOnPointerMove = !1, this._addVertexOnPointerUp = !1, this._drawTool = null, this.mode = X;
+  }
+  initialize() {
+    this._addViewHandles(), this.view.type === "3d" && this._addDrawTool();
+  }
+  destroy() {
+    this._removeDrawTool(), this.emit("destroy");
+  }
+  get _dragEnabled() {
+    return this.mode === "freehand" || this.mode === "hybrid";
+  }
+  get _clickEnabled() {
+    return this.mode === "click" || this.mode === "hybrid";
+  }
+  undo() {
+    this._drawTool ? this._drawTool.undo() : (super.undo(), this.notifyChange("vertices"));
+  }
+  redo() {
+    this._drawTool ? this._drawTool.redo() : (super.redo(), this.notifyChange("vertices"));
+  }
+  canUndo() {
+    var t;
+    return ((t = this._drawTool) == null ? void 0 : t.canUndo()) ?? super.canUndo();
+  }
+  canRedo() {
+    var t;
+    return ((t = this._drawTool) == null ? void 0 : t.canRedo()) ?? super.canRedo();
+  }
+  complete() {
+    this._completeDrawing();
+  }
+  _getGeometryZValue() {
+    return this.hasZ && this.vertices.length > 0 ? this.vertices[0][2] : this.defaultZ;
+  }
+  _addViewHandles() {
+    this._addViewHandles2DOnly(), this.addHandles(this.view.on("key-down", (t) => {
+      const { key: i, repeat: n } = t;
+      i !== m.vertexAdd || n ? i !== m.complete || n ? i !== m.undo || this.interactiveUndoDisabled || n ? i !== m.redo || this.interactiveUndoDisabled || n || (t.stopPropagation(), this.redo()) : (t.stopPropagation(), this.undo()) : (t.stopPropagation(), this._drawCompleteHandler(t)) : (t.stopPropagation(), this._handleVertexAddKey(t));
+    }, d.TOOL));
+  }
+  _addViewHandles2DOnly() {
+    this.view.type === "2d" && (this.addHandles([this.view.on("click", (t) => {
+      t.stopPropagation();
+    }, d.TOOL), this.view.on("pointer-down", (t) => {
+      this._shouldHandlePointerEvent(t) && (this._abortSnapping(), this._activePointerId = t.pointerId, this._addVertexOnPointerUp = !0, this._cursorScreenPoint = g(t), t.pointerType === "touch" && this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-move", (t) => {
+      this._abortSnapping(), this._popVertexOnPointerMove && (this.undo(), this._popVertexOnPointerMove = !1), this._cursorScreenPoint = g(t), t.pointerType !== "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-drag", (t) => {
+      this._shouldHandlePointerEvent(t) && (this._abortSnapping(), this._cursorScreenPoint = g(t), this._dragEnabled && !this._panEnabled ? this._vertexAddHandler(t) : this._addVertexOnPointerUp = !1);
+    }, d.TOOL), this.view.on("pointer-up", (t) => {
+      if (this._shouldHandlePointerEvent(t))
+        if (this._abortSnapping(), this._activePointerId = null, this._addVertexOnPointerUp) {
+          if (!this._clickEnabled)
+            return this.vertices.length === 1 && this.vertices.pop(), void this._drawCompleteHandler(t);
+          this._vertexAddHandler(t);
+        } else {
+          const i = t.pointerType === "touch";
+          this._updateCursor(i);
+        }
+    }, d.TOOL), this.view.on("drag", (t) => {
+      this._dragEnabled && this._activePointerId != null && !this._panEnabled && t.stopPropagation();
+    }, d.TOOL), this.view.on("drag", ["Shift"], (t) => {
+      t.stopPropagation();
+    }, d.TOOL), this.view.on("double-click", (t) => {
+      t.stopPropagation(), this._drawCompleteHandler(t);
+    }, d.TOOL), this.view.on("double-click", ["Control"], (t) => {
+      t.stopPropagation(), this._drawCompleteHandler(t);
+    }, d.TOOL), this.view.on("key-down", (t) => {
+      const { key: i, repeat: n } = t;
+      i !== m.pan || n || (t.stopPropagation(), this._panEnabled = !0);
+    }, d.TOOL), this.view.on("key-up", (t) => {
+      t.key === m.pan && (t.stopPropagation(), this._panEnabled = !1);
+    }, d.TOOL)]), this._addUndoRedoHandles());
+  }
+  _handleVertexAddKey(t) {
+    this._drawTool ? this._drawTool.drawOperation.commitStagedVertex() : this._cursorScreenPoint && (this._abortSnapping(), this._vertexAddHandler(t));
+  }
+  _addUndoRedoHandles() {
+    this.addHandles([this._editGeometryOperations.on("vertex-remove", (t) => {
+      if (this.notifyChange("vertices"), t.operation === "undo") {
+        const i = [...this._committedVertices];
+        this._stagedVertex != null && i.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("undo", new A(this.view, t.vertices[0].index, i));
+      }
+    }), this._editGeometryOperations.on("vertex-add", (t) => {
+      if (this.notifyChange("vertices"), t.operation === "apply") {
+        const i = this._committedVertices.length - 1, n = new T(this.view, i, this.vertices);
+        this.emit("vertex-add", n), n.defaultPrevented && (this._popVertexOnPointerMove = !0);
+      } else if (t.operation === "redo") {
+        const i = [...this._committedVertices];
+        this._stagedVertex != null && i.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("redo", new T(this.view, t.vertices[0].index, i));
+      }
+    })]);
+  }
+  _addDrawTool() {
+    const t = new _({ view: this.view, elevationInfo: this.elevationInfo, hasZ: this.hasZ, geometryType: "polygon", mode: this.mode });
+    this._drawTool = t, this.view.addAndActivateTool(t), t.on("vertex-add", (i) => {
+      if (i.vertices.length === 1) {
+        const { view: n } = this, s = i.vertices[0].vertexIndex, a = t.getVertexCoords();
+        this.emit("vertex-add", new T(n, s, a)), i.operation !== "undo" && i.operation !== "redo" || this.emit(i.operation, new T(n, s, a));
+      }
+    }), t.on("vertex-remove", (i) => {
+      if (i.vertices.length === 1) {
+        const { view: n } = this, s = i.vertices[0].vertexIndex, a = t.getVertexCoords();
+        this.emit("vertex-remove", new A(n, s, a)), i.operation !== "undo" && i.operation !== "redo" || this.emit(i.operation, new A(n, s, a));
+      }
+    }), t.on("cursor-update", (i) => {
+      i.vertices.length === 1 && this.emit("cursor-update", new H(this.view, i.vertices[0].vertexIndex, t.getVertexCoords()));
+    }), t.on("complete", (i) => {
+      this.emit("draw-complete", new I(t.getVertexCoords())), this._removeDrawTool(), this.removeAllHandles();
+    });
+  }
+  _removeDrawTool() {
+    this._drawTool && (this.view.tools.remove(this._drawTool), this._drawTool = null);
+  }
+  _addVertex(t) {
+    const i = this._coordinateHelper.arrayToVector(t);
+    this._isDuplicateOfLastVertex(i) || (this._lastVertexUnsnapped = this._stagedVertexUnsnapped, this._popCursorVertex(), this._editGeometryOperations.appendVertex(i));
+  }
+  _updateCursor(t = !1) {
+    if (this._popCursorVertex(), !this._cursorScreenPoint)
+      return;
+    const i = this.getCoordsAndPointFromScreenPoint(this._cursorScreenPoint);
+    i == null || t || this._pushCursorVertex(i.vertex, () => this.emit("cursor-update", new H(this.view, this._activeComponent.vertices.length, this.vertices, this._stagedVertex != null ? new P(this._stagedVertex) : null)));
+  }
+  _completeDrawing() {
+    if (this._drawTool)
+      return void this._drawTool.completeCreateOperation();
+    if (this._activePointerId = null, this._popCursorVertex(), this._committedVertices.length < 3)
+      return;
+    this._abortSnapping(), this._snappingManager != null && this._snappingManager.doneSnapping();
+    const t = new I(this.vertices);
+    this.emit("draw-complete", t), t.defaultPrevented || this.removeAllHandles();
+  }
+};
+o([r()], L.prototype, "_dragEnabled", null), o([r()], L.prototype, "_clickEnabled", null), o([r({ type: Fe })], L.prototype, "mode", void 0), L = o([C("esri.views.draw.PolygonDrawAction")], L);
+let R = class extends z {
+  constructor(e) {
+    super(e), this._panEnabled = !1, this._popVertexOnPointerMove = !1, this._addVertexOnPointerUp = !1, this._drawTool = null, this.mode = X;
+  }
+  initialize() {
+    this._addViewHandles(), this.view.type === "3d" && this._addDrawTool();
+  }
+  destroy() {
+    this._removeDrawTool(), this.emit("destroy");
+  }
+  get _clickEnabled() {
+    return this.mode === "click" || this.mode === "hybrid";
+  }
+  get _dragEnabled() {
+    return this.mode === "freehand" || this.mode === "hybrid";
+  }
+  undo() {
+    this._drawTool ? this._drawTool.undo() : (super.undo(), this.notifyChange("vertices"));
+  }
+  redo() {
+    this._drawTool ? this._drawTool.redo() : (super.redo(), this.notifyChange("vertices"));
+  }
+  canUndo() {
+    var e;
+    return ((e = this._drawTool) == null ? void 0 : e.canUndo()) ?? super.canUndo();
+  }
+  canRedo() {
+    var e;
+    return ((e = this._drawTool) == null ? void 0 : e.canRedo()) ?? super.canRedo();
+  }
+  complete() {
+    this._completeDrawing();
+  }
+  _addViewHandles() {
+    this._addViewHandles2DOnly(), this.addHandles([this.view.on("key-down", (e) => {
+      const { key: t, repeat: i } = e;
+      t !== m.vertexAdd || i ? t !== m.complete || i ? t !== m.undo || this.interactiveUndoDisabled || i ? t !== m.redo || this.interactiveUndoDisabled || i || (e.stopPropagation(), this.redo()) : (e.stopPropagation(), this.undo()) : (e.stopPropagation(), this._drawCompleteHandler(e)) : (e.stopPropagation(), this._handleVertexAddKey(e));
+    }, d.TOOL)]);
+  }
+  _addViewHandles2DOnly() {
+    this.view.type === "2d" && (this.addHandles([this.view.on("click", (e) => {
+      e.stopPropagation();
+    }, d.TOOL), this.view.on("pointer-down", (e) => {
+      this._shouldHandlePointerEvent(e) && !this._panEnabled && (this._abortSnapping(), this._activePointerId = e.pointerId, this._addVertexOnPointerUp = !0, this._cursorScreenPoint = g(e), e.pointerType === "touch" && this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-move", (e) => {
+      this._popVertexOnPointerMove && (this.undo(), this._popVertexOnPointerMove = !1), this._abortSnapping(), this._cursorScreenPoint = g(e), e.pointerType !== "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-drag", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._cursorScreenPoint = g(e), this._dragEnabled && !this._panEnabled ? this._vertexAddHandler(e) : this._addVertexOnPointerUp = !1);
+    }, d.TOOL), this.view.on("pointer-up", (e) => {
+      if (this._shouldHandlePointerEvent(e))
+        if (this._abortSnapping(), this._activePointerId = null, this._addVertexOnPointerUp) {
+          if (!this._clickEnabled)
+            return this.vertices.length === 1 && this.vertices.pop(), void this._drawCompleteHandler(e);
+          this._vertexAddHandler(e);
+        } else {
+          const t = e.pointerType === "touch";
+          this._updateCursor(t);
+        }
+    }, d.TOOL), this.view.on("drag", (e) => {
+      this._dragEnabled && this._activePointerId != null && !this._panEnabled && e.stopPropagation();
+    }, d.TOOL), this.view.on("drag", ["Shift"], (e) => {
+      e.stopPropagation();
+    }, d.TOOL), this.view.on("double-click", (e) => {
+      e.stopPropagation(), this._drawCompleteHandler(e);
+    }, d.TOOL), this.view.on("double-click", ["Control"], (e) => {
+      e.stopPropagation(), this._drawCompleteHandler(e);
+    }, d.TOOL), this.view.on("key-down", (e) => {
+      const { key: t, repeat: i } = e;
+      t !== m.pan || i || (e.stopPropagation(), this._panEnabled = !0);
+    }, d.TOOL), this.view.on("key-up", (e) => {
+      e.key === m.pan && (e.stopPropagation(), this._panEnabled = !1);
+    }, d.TOOL)]), this._addUndoRedoHandles());
+  }
+  _handleVertexAddKey(e) {
+    this._drawTool ? this._drawTool.drawOperation.commitStagedVertex() : this._cursorScreenPoint && (this._abortSnapping(), this._vertexAddHandler(e));
+  }
+  _addUndoRedoHandles() {
+    this.addHandles([this._editGeometryOperations.on("vertex-remove", (e) => {
+      if (this.notifyChange("vertices"), e.operation === "undo") {
+        const t = [...this._committedVertices];
+        this._stagedVertex != null && t.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("undo", new A(this.view, e.vertices[0].index, t));
+      }
+    }), this._editGeometryOperations.on("vertex-add", (e) => {
+      if (this.notifyChange("vertices"), e.operation === "apply") {
+        const t = this._committedVertices.length - 1, i = new T(this.view, t, this.vertices);
+        this.emit("vertex-add", i), i.defaultPrevented && (this._popVertexOnPointerMove = !0);
+      } else if (e.operation === "redo") {
+        const t = [...this._committedVertices];
+        this._stagedVertex != null && t.push(this._coordinateHelper.pointToArray(this._stagedVertex)), this.emit("redo", new T(this.view, e.vertices[0].index, t));
+      }
+    })]);
+  }
+  _addDrawTool() {
+    const e = new _({ view: this.view, elevationInfo: this.elevationInfo, hasZ: this.hasZ, geometryType: "polyline", mode: this.mode });
+    this._drawTool = e, this.view.addAndActivateTool(e), this.addHandles([e.on("vertex-add", (t) => {
+      if (t.vertices.length !== 1)
+        return;
+      const { view: i } = this, n = t.vertices[0].vertexIndex, s = e.getVertexCoords();
+      this.emit("vertex-add", new T(i, n, s)), t.operation !== "undo" && t.operation !== "redo" || this.emit(t.operation, new T(i, n, s));
+    }), e.on("vertex-remove", (t) => {
+      if (t.vertices.length !== 1)
+        return;
+      const { view: i } = this, n = t.vertices[0].vertexIndex, s = e.getVertexCoords();
+      this.emit("vertex-remove", new A(i, n, s)), t.operation !== "undo" && t.operation !== "redo" || this.emit(t.operation, new A(i, n, s));
+    }), e.on("cursor-update", (t) => {
+      t.vertices.length === 1 && this.emit("cursor-update", new H(this.view, t.vertices[0].vertexIndex, e.getVertexCoords()));
+    }), e.on("complete", (t) => {
+      this.emit("draw-complete", new I(e.getVertexCoords())), this._removeDrawTool(), this.removeAllHandles();
+    })]);
+  }
+  _removeDrawTool() {
+    this._drawTool && (this.view.tools.remove(this._drawTool), this._drawTool = null);
+  }
+  _addVertex(e) {
+    const t = this._coordinateHelper.arrayToVector(e);
+    this._isDuplicateOfLastVertex(t) || (this._lastVertexUnsnapped = this._stagedVertexUnsnapped, this._popCursorVertex(), this._editGeometryOperations.appendVertex(t));
+  }
+  _updateCursor(e = !1) {
+    if (this._popCursorVertex(), !this._cursorScreenPoint)
+      return;
+    const t = this.getCoordsAndPointFromScreenPoint(this._cursorScreenPoint);
+    t == null || e || this._pushCursorVertex(t.vertex, () => this.emit("cursor-update", new H(this.view, this._activeComponent.vertices.length, this.vertices, this._stagedVertex != null ? new P(this._stagedVertex) : null)));
+  }
+  _completeDrawing() {
+    if (this._drawTool)
+      return void this._drawTool.completeCreateOperation();
+    if (this._activePointerId = null, this._popCursorVertex(), this._committedVertices.length < 2)
+      return;
+    this._abortSnapping(), this._snappingManager != null && this._snappingManager.doneSnapping();
+    const e = new I(this.vertices);
+    this.emit("draw-complete", e), e.defaultPrevented || this.removeAllHandles();
+  }
+};
+o([r()], R.prototype, "_clickEnabled", null), o([r()], R.prototype, "_dragEnabled", null), o([r({ type: Fe })], R.prototype, "mode", void 0), R = o([C("esri.views.draw.PolylineDrawAction")], R);
+function K(e, t, i = null) {
+  return i != null ? [e, t, i] : [e, t];
+}
+function Ne(e, t, i = null) {
+  return i != null ? { x: e, y: t, z: i } : { x: e, y: t };
+}
+class qe {
+  constructor(t) {
+    this.spatialReference = t;
+  }
+  mapToLocalMultiple(t) {
+    return t.map((i) => this.mapToLocal(i)).filter(ut);
+  }
+  get doUnnormalization() {
+    return !1;
+  }
+}
+class ci extends qe {
+  constructor(t, i, n = null) {
+    super(i), this._defaultZ = n, this.transform = Te(), this.transformInv = Te(), this.transform = at(t), lt(this.transformInv, this.transform);
+  }
+  makeMapPoint(t, i) {
+    return K(t, i, this._defaultZ);
+  }
+  mapToLocal(t) {
+    return Ne(this.transform[0] * t[0] + this.transform[2] * t[1] + this.transform[4], this.transform[1] * t[0] + this.transform[3] * t[1] + this.transform[5]);
+  }
+  localToMap(t) {
+    return K(this.transformInv[0] * t.x + this.transformInv[2] * t.y + this.transformInv[4], this.transformInv[1] * t.x + this.transformInv[3] * t.y + this.transformInv[5], this._defaultZ);
+  }
+}
+class ui extends qe {
+  constructor(t, i) {
+    super(t.spatialReference), this.view = t, this.defaultZ = null, this.pWS = b(), this.tangentFrameUpWS = b(), this.tangentFrameRightWS = b(), this.tangentFrameForwardWS = b(), this.localFrameRightWS = b(), this.localFrameUpWS = b(), this.worldToLocalTransform = Ie(), this.localToWorldTransform = Ie(), this.scale = 1, this.scale = t.resolution, this.referenceMapPoint = i, this.defaultZ = i.hasZ ? i.z : null;
+    const n = t.state.camera.viewRight;
+    this.view.renderCoordsHelper.toRenderCoords(this.referenceMapPoint, this.pWS), this.view.renderCoordsHelper.worldBasisAtPosition(this.pWS, ie.X, this.tangentFrameRightWS), this.view.renderCoordsHelper.worldBasisAtPosition(this.pWS, ie.Y, this.tangentFrameUpWS), this.view.renderCoordsHelper.worldBasisAtPosition(this.pWS, ie.Z, this.tangentFrameForwardWS);
+    const s = b();
+    ht(s, this.tangentFrameForwardWS, dt(n, this.tangentFrameForwardWS)), Re(this.localFrameRightWS, n, s), pt(this.localFrameRightWS, this.localFrameRightWS), ct(this.localFrameUpWS, this.tangentFrameForwardWS, this.localFrameRightWS), zt(this.worldToLocalTransform, this.localFrameRightWS, this.tangentFrameRightWS), Ft(this.localToWorldTransform, this.worldToLocalTransform);
+  }
+  get doUnnormalization() {
+    return this.view.viewingMode === "global";
+  }
+  makeMapPoint(t, i) {
+    return K(t, i, this.defaultZ);
+  }
+  mapToLocal(t) {
+    const i = b();
+    this.view.renderCoordsHelper.toRenderCoords(new P({ x: t[0], y: t[1], spatialReference: this.spatialReference }), i), Se(i, i, this.worldToLocalTransform);
+    const n = this.view.renderCoordsHelper.fromRenderCoords(i, new P({ spatialReference: this.view.spatialReference }));
+    return n != null ? Ne(n.x / this.scale, n.y / this.scale) : null;
+  }
+  localToMap(t) {
+    const i = b();
+    this.view.renderCoordsHelper.toRenderCoords(new P({ x: t.x * this.scale, y: t.y * this.scale, spatialReference: this.spatialReference }), i), Se(i, i, this.localToWorldTransform);
+    const n = this.view.renderCoordsHelper.fromRenderCoords(i, new P({ spatialReference: this.view.spatialReference }));
+    return n != null ? K(n.x, n.y, this.defaultZ) : null;
+  }
+}
+function mi(e, t) {
+  if (e.type === "2d")
+    return new ci(e.state.transform, e.spatialReference, t.length > 2 ? t[2] : null);
+  if (e.type === "3d") {
+    const i = t.length > 2 ? new P({ x: t[0], y: t[1], z: t[2], spatialReference: e.spatialReference }) : new P({ x: t[0], y: t[1], spatialReference: e.spatialReference });
+    return new ui(e, i);
+  }
+  return null;
+}
+const vi = ["freehand", "click"];
+let j = class extends z {
+  constructor(e) {
+    super(e), this._isDragging = !1, this._panEnabled = !1, this._addVertexOnPointerUp = !1, this._drawTool = null, this.viewAlignedCoordinateSystem = null, this.mode = "freehand";
+  }
+  initialize() {
+    this.view.type === "2d" ? this._addViewHandles() : this._addDrawTool();
+  }
+  destroy() {
+    this._removeDrawTool(), this.emit("destroy");
+  }
+  complete() {
+    this._completeDrawing();
+  }
+  _getGeometryZValue() {
+    return this.hasZ && this.vertices.length > 0 ? this.vertices[0][2] : this.defaultZ;
+  }
+  _addViewHandles() {
+    this.mode === "click" ? this.addHandles(this._getClickModeViewHandles()) : this.addHandles(this._getDragModeViewHandles());
+  }
+  _getDragModeViewHandles() {
+    return [this.view.on("immediate-click", (e) => {
+      e.stopPropagation(), e.mapPoint && !this._panEnabled && this.getCoordsFromScreenPoint(g(e)) != null && (this._vertexAddHandler(e), this._drawCompleteHandler(e));
+    }, d.TOOL), this.view.on("pointer-down", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._panEnabled || (this._resetGeometry(), this._addVertexOnPointerUp = !0, this._cursorScreenPoint = g(e), this._activePointerId = e.pointerId, this._vertexAddHandler(e), this._isDragging = !1, e.pointerType === "touch" && this._updateCursor()));
+    }, d.TOOL), this.view.on("pointer-move", (e) => {
+      this._abortSnapping(), this._activePointerId == null && e.pointerType !== "touch" && (this._cursorScreenPoint = g(e), this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-drag", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._isDragging = !0, this._cursorScreenPoint = g(e), this._updateCursor());
+    }, d.TOOL), this.view.on("pointer-up", (e) => {
+      this._shouldHandlePointerEvent(e) && this._addVertexOnPointerUp && (this._abortSnapping(), this._activePointerId = null, this._isDragging && this._vertexAddHandler(e), this._committedVertices.length === 2 && this._drawCompleteHandler(e), this._isDragging = !1);
+    }, d.TOOL), this.view.on("key-down", (e) => {
+      e.key === m.complete && this._cursorScreenPoint ? (this._abortSnapping(), this._vertexAddHandler(e), this._drawCompleteHandler(e)) : e.key === m.pan && (this._panEnabled = !0);
+    }, d.TOOL), this.view.on("key-up", (e) => {
+      e.key === m.pan && (this._panEnabled = !1);
+    }, d.TOOL), this.view.on("drag", (e) => {
+      this._activePointerId != null && e.stopPropagation();
+    }, d.TOOL), this.view.on("drag", ["Shift"], (e) => {
+      e.stopPropagation();
+    }, d.TOOL)];
+  }
+  _getClickModeViewHandles() {
+    return [this.view.on("pointer-down", (e) => {
+      this._abortSnapping(), this._cursorScreenPoint = g(e), this._activePointerId = e.pointerId, this._isDragging = !1, e.pointerType === "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-move", (e) => {
+      this._abortSnapping(), this._cursorScreenPoint = g(e), this._activePointerId == null && e.pointerType !== "touch" && this._updateCursor();
+    }, d.TOOL), this.view.on("pointer-drag", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._isDragging = !0);
+    }, d.TOOL), this.view.on("pointer-up", (e) => {
+      this._shouldHandlePointerEvent(e) && (this._abortSnapping(), this._activePointerId = null, e.stopPropagation(), this._isDragging || this._vertexAddHandler(e), this.vertices.length !== 2 || this._isDragging || this._drawCompleteHandler(e), this._isDragging = !1);
+    }, d.TOOL), this.view.on("key-down", (e) => {
+      e.key === m.vertexAdd && this._cursorScreenPoint && (this._vertexAddHandler(e), this.vertices.length === 2 && this._drawCompleteHandler(e)), e.key === m.complete && this._cursorScreenPoint && this.vertices.length === 2 && (this._vertexAddHandler(e), this._drawCompleteHandler(e));
+    }, d.TOOL)];
+  }
+  _addDrawTool() {
+    const e = new _({ view: this.view, elevationInfo: this.elevationInfo, hasZ: this.hasZ, geometryType: "segment", mode: this.mode });
+    this._drawTool = e, this.view.addAndActivateTool(e), this.addHandles([e.on("vertex-add", (t) => {
+      t.vertices.length === 1 && this.emit("vertex-add", new T(this.view, t.vertices[0].vertexIndex, e.getVertexCoords()));
+    }), e.on("cursor-update", (t) => {
+      t.vertices.length === 1 && this.emit("cursor-update", new H(this.view, t.vertices[0].vertexIndex, e.getVertexCoords()));
+    }), e.on("complete", (t) => {
+      this.emit("draw-complete", new I(e.getVertexCoords())), this._removeDrawTool();
+    }), this.view.on("key-down", (t) => {
+      t.key !== m.vertexAdd || t.repeat || this.mode !== "click" ? t.key !== m.complete || t.repeat || e.completeCreateOperation() : e.drawOperation.numCommittedVertices > 0 ? e.completeCreateOperation() : e.drawOperation.commitStagedVertex();
+    }, d.TOOL)]);
+  }
+  _removeDrawTool() {
+    this._drawTool && (this.view.tools.remove(this._drawTool), this._drawTool = null);
+  }
+  _addVertex(e) {
+    const t = this._coordinateHelper.arrayToVector(e);
+    if (this._isDuplicateOfLastVertex(t))
+      return;
+    this._lastVertexUnsnapped = this._stagedVertexUnsnapped, this._popCursorVertex(), this._editGeometryOperations.appendVertex(t), this._committedVertices.length === 1 && (this.viewAlignedCoordinateSystem = mi(this.view, this._committedVertices[0]));
+    const i = this._committedVertices.length - 1, n = new T(this.view, i, this.vertices);
+    this.emit("vertex-add", n);
+  }
+  _updateCursor() {
+    if (this._popCursorVertex(), !this._cursorScreenPoint)
+      return;
+    const e = this.getCoordsAndPointFromScreenPoint(this._cursorScreenPoint);
+    e != null && this._pushCursorVertex(e.vertex, () => this.emit("cursor-update", new H(this.view, this._activeComponent.vertices.length, this.vertices, this._stagedVertex != null ? new P(this._stagedVertex) : null)));
+  }
+  _completeDrawing() {
+    if (this._drawTool)
+      return this._drawTool.completeCreateOperation(), void this.removeAllHandles();
+    if (this._activePointerId = null, this._popCursorVertex(), this._cursorScreenPoint = null, this._isDragging = !1, this._abortSnapping(), this._snappingManager != null && this._snappingManager.doneSnapping(), this.vertices.length < 1)
+      return;
+    const e = new I(this.vertices);
+    this.emit("draw-complete", e), e.defaultPrevented || this.removeAllHandles();
+  }
+  _resetGeometry() {
+    this._editGeometryOperations.destroy(), this._editGeometryOperations = new _e(new ge("polygon", this._coordinateHelper)), this._activeComponent = new ye(this._coordinateHelper.spatialReference, ue.Local), this._editGeometryOperations.data.components.push(this._activeComponent);
+  }
+};
+o([r({ type: vi })], j.prototype, "mode", void 0), j = o([C("esri/views/2d/engine/markup/SegmentDrawAction")], j);
+let $ = class extends Q {
+  constructor() {
+    super(...arguments), this.activeAction = null, this.type = "draw", this.view = null;
+  }
+  destroy() {
+    this.activeAction && (this.activeAction.destroy(), this.activeAction = null);
+  }
+  create(e, t) {
+    this.reset();
+    const i = { view: this.view, ...t };
+    switch (e) {
+      case "point":
+        i.editGeometryType = "point", this.activeAction = new ce(i);
+        break;
+      case "polyline":
+        i.editGeometryType = "polyline", this.activeAction = new R(i);
+        break;
+      case "multipoint":
+        i.editGeometryType = "polygon", this.activeAction = new pe(i);
+        break;
+      case "polygon":
+        i.editGeometryType = "polygon", this.activeAction = new L(i);
+        break;
+      case "rectangle":
+      case "circle":
+      case "ellipse":
+      case "triangle":
+        i.editGeometryType = "polygon", this.activeAction = new j(i);
+    }
+    return this.activeAction;
+  }
+  complete() {
+    this.activeAction && this.activeAction.complete(), this.activeAction = null;
+  }
+  reset() {
+    this.activeAction && this.activeAction.destroy(), this.activeAction = null;
+  }
+};
+o([r()], $.prototype, "activeAction", void 0), o([r({ readOnly: !0 })], $.prototype, "type", void 0), o([r()], $.prototype, "view", void 0), $ = o([C("esri.views.draw.Draw")], $);
+const Gi = $;
+function _i(e) {
+  let t = 0, i = 0, n = 0;
+  return e ? (e.type === "cim" && e.data.symbol && "symbolLayers" in e.data.symbol && e.data.symbol.symbolLayers && e.data.symbol.symbolLayers.map((s) => {
+    s.type === "CIMVectorMarker" && s.anchorPoint && (Math.abs(s.anchorPoint.x) > t && (t = s.anchorPoint.x), Math.abs(s.anchorPoint.y) > i && (i = s.anchorPoint.y), s.size != null && s.size > n && (n = s.size));
+  }), t = k(t), i = k(i), n = k(n), { offsetX: t, offsetY: i, size: n }) : { offsetX: t, offsetY: i, size: n };
+}
+let y = class extends Q {
+  set graphic(e) {
+    this._circleCollisionCache = null, this._originalSymbol = e.symbol, this._set("graphic", e), this.attachSymbolChanged();
+  }
+  get elevationInfo() {
+    const { layer: e } = this.graphic, t = e && "elevationInfo" in e ? e.elevationInfo : null, i = Et(this.graphic), n = t ? t.offset : 0;
+    return new jt({ mode: i, offset: n });
+  }
+  set focusedSymbol(e) {
+    e !== this._get("focusedSymbol") && (this._set("focusedSymbol", e), this._updateGraphicSymbol(), this._circleCollisionCache = null);
+  }
+  grabbableForEvent() {
+    return !0;
+  }
+  set grabbing(e) {
+    e !== this._get("grabbing") && (this._set("grabbing", e), this._updateGraphicSymbol());
+  }
+  set hovering(e) {
+    e !== this._get("hovering") && (this._set("hovering", e), this._updateGraphicSymbol());
+  }
+  set selected(e) {
+    e !== this._get("selected") && (this._set("selected", e), this._updateGraphicSymbol(), this.events.emit("select-changed", { action: e ? "select" : "deselect" }));
+  }
+  get _focused() {
+    return this._get("hovering") || this._get("grabbing");
+  }
+  constructor(e) {
+    super(e), this.layer = null, this.interactive = !0, this.selectable = !1, this.grabbable = !0, this.dragging = !1, this.cursor = null, this.consumesClicks = !0, this.events = new U.EventEmitter(), this._circleCollisionCache = null, this._graphicSymbolChangedHandle = null, this._originalSymbol = null;
+  }
+  destroy() {
+    this.detachSymbolChanged(), this._resetGraphicSymbol(), this._set("view", null);
+  }
+  intersectionDistance(e) {
+    const t = this.graphic;
+    if (t.visible === !1)
+      return null;
+    const i = t.geometry;
+    if (i == null)
+      return null;
+    const n = this._get("focusedSymbol"), s = n ?? t.symbol;
+    return this.view.type === "2d" ? this._intersectDistance2D(this.view, e, i, s) : this._intersectDistance3D(this.view, e, t);
+  }
+  attach() {
+    this.attachSymbolChanged(), this.layer != null && this.layer.add(this.graphic);
+  }
+  detach() {
+    this.detachSymbolChanged(), this._resetGraphicSymbol(), this.layer != null && this.layer.remove(this.graphic);
+  }
+  attachSymbolChanged() {
+    this.detachSymbolChanged(), this._graphicSymbolChangedHandle = G(() => {
+      var e;
+      return (e = this.graphic) == null ? void 0 : e.symbol;
+    }, (e) => {
+      e != null && e !== this.focusedSymbol && e !== this._originalSymbol && (this._originalSymbol = e, this._focused && this.focusedSymbol != null && (this.graphic.symbol = this.focusedSymbol));
+    }, mt);
+  }
+  detachSymbolChanged() {
+    this._graphicSymbolChangedHandle != null && (this._graphicSymbolChangedHandle.remove(), this._graphicSymbolChangedHandle = null);
+  }
+  onElevationChange() {
+  }
+  onViewChange() {
+  }
+  _updateGraphicSymbol() {
+    this.graphic.symbol = this._focused && this.focusedSymbol != null ? this.focusedSymbol : this._originalSymbol;
+  }
+  _resetGraphicSymbol() {
+    this.graphic.symbol = this._originalSymbol;
+  }
+  _intersectDistance2D(e, t, i, n) {
+    var p, l;
+    if ((n = n || Bt(i)) == null)
+      return null;
+    const s = 1;
+    let a = this._circleCollisionCache;
+    if (i.type === "point" && n.type === "cim" && ((p = n.data.symbol) == null ? void 0 : p.type) === "CIMPointSymbol" && n.data.symbol.symbolLayers) {
+      const { offsetX: h, offsetY: u, size: v } = _i(n), f = Ce(t, Le), x = v / 2, S = e.toScreen(i), V = S.x + h, M = S.y + u;
+      return Ve(f, [V, M]) < x * x ? s : null;
+    }
+    if (i.type !== "point" || n.type !== "simple-marker")
+      return Nt(t, i, e) ? s : null;
+    if (a == null || !a.originalPoint.equals(i)) {
+      const h = i, u = e.spatialReference;
+      if (vt(h.spatialReference, u)) {
+        const v = _t(h, u);
+        a = { originalPoint: h.clone(), mapPoint: v, radiusPx: k(n.size) }, this._circleCollisionCache = a;
+      }
+    }
+    if (a != null) {
+      const h = Ce(t, Le), u = (l = e.toScreen) == null ? void 0 : l.call(e, a.mapPoint);
+      if (!u)
+        return null;
+      const v = a.radiusPx, f = u.x + k(n.xoffset), x = u.y - k(n.yoffset);
+      return Ve(h, [f, x]) < v * v ? s : null;
+    }
+    return null;
+  }
+  _intersectDistance3D(e, t, i) {
+    const n = e.toMap(t, { include: [i] });
+    return n && Wt(n, Ae, e.renderSpatialReference) ? gt(Ae, e.state.camera.eye) : null;
+  }
+};
+o([r({ constructOnly: !0, nonNullable: !0 })], y.prototype, "graphic", null), o([r()], y.prototype, "elevationInfo", null), o([r({ constructOnly: !0, nonNullable: !0 })], y.prototype, "view", void 0), o([r({ value: null })], y.prototype, "focusedSymbol", null), o([r({ constructOnly: !0 })], y.prototype, "layer", void 0), o([r()], y.prototype, "interactive", void 0), o([r()], y.prototype, "selectable", void 0), o([r()], y.prototype, "grabbable", void 0), o([r({ value: !1 })], y.prototype, "grabbing", null), o([r()], y.prototype, "dragging", void 0), o([r()], y.prototype, "hovering", null), o([r({ value: !1 })], y.prototype, "selected", null), o([r()], y.prototype, "cursor", void 0), y = o([C("esri.views.interactive.GraphicManipulator")], y);
+const Ae = b(), Le = N();
+export {
+  y as S,
+  Gi as l
+};