@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/GraphicManipulator-84ac0573.js

@@ -1,1499 +0,0 @@
-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
-};