@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/reshapeGraphic/ReshapeOperation.js

@@ -0,0 +1,738 @@
+import { _ as v } from "../../../../../chunks/tslib.es6.js";
+import "../../../../../geometry.js";
+import Me from "../../../../../core/Accessor.js";
+import { removeUnordered as ye } from "../../../../../core/arrayUtils.js";
+import { unitRGBAFromColor as G } from "../../../../../core/colorUtils.js";
+import "../../../../../core/has.js";
+import xe from "../../../../../core/Evented.js";
+import Oe from "../../../../../core/Handles.js";
+import { handlesGroup as R, makeHandle as Q, destroyHandle as Ee } from "../../../../../core/handleUtils.js";
+import { destroyMaybe as A, removeMaybe as w } from "../../../../../core/maybe.js";
+import { zeroMeters as U, scale as ee, createLength as te } from "../../../../../core/quantityUtils.js";
+import { watch as V, initial as L } from "../../../../../core/reactiveUtils.js";
+import { getMetersPerUnitForSR as be } from "../../../../../core/unitUtils.js";
+import { property as x } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/Logger.js";
+import { subclass as Ge } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { IDENTITY as Te } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { l as Ie, f as Se, m as we, s as Ve, g as He, h as Ae } from "../../../../../chunks/vec32.js";
+import { fromValues as De, create as Le } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { UpdatingHandles as Pe } from "../../../../../core/support/UpdatingHandles.js";
+import $e from "../../../../../geometry/Polyline.js";
+import { hasCompatibleTopology as Ce } from "../../../../../geometry/support/coordsUtils.js";
+import { projectPoint as ke } from "../../../../../geometry/support/plane.js";
+import { sv3d as Ne } from "../../../../../geometry/support/vectorStacks.js";
+import { makeDehydratedPoint as ve } from "../../../../../layers/graphics/dehydratedPoint.js";
+import { getGraphicEffectiveElevationInfo as P } from "../../../../../support/elevationInfoUtils.js";
+import { isVolumetricSymbol as ie } from "../../../../../symbols/support/utils.js";
+import { Manipulator3D as Y } from "../../Manipulator3D.js";
+import { createManipulatorMaterial as $, createManipulatorOutlineMaterial as C, placeAtGraphic as Re } from "../../manipulatorUtils.js";
+import { RenderObject as E } from "../../RenderObject.js";
+import { SegmentLabels3D as Ue } from "../../SegmentLabels3D.js";
+import { SnappingVisualizer3D as ae } from "../../SnappingVisualizer3D.js";
+import { screenToRenderPlaneFromEvent as Fe, convertToMapCoordinates as Xe, screenToMapXYAtLocation as Ze, screenToMapXYForGraphicAtLocation as ze } from "../dragEventPipeline3D.js";
+import { orientation as Ye } from "../geometryUtils.js";
+import { ManipulatorType as ne } from "../ManipulatorType.js";
+import { canMoveZ as q } from "../manipulatorUtils.js";
+import { Settings as qe } from "../settings.js";
+import { createVisualElements as Be } from "../visualElementUtils.js";
+import { discRadiusSmall as je } from "../manipulations/config.js";
+import { ManipulationType as b, MoveManipulation as B } from "../manipulations/MoveManipulation.js";
+import { axisConstrainedDragSign as oe } from "../manipulations/moveUtils.js";
+import { MoveXYGraphicManipulation as We } from "../manipulations/MoveXYGraphicManipulation.js";
+import { createEdgeOffsetIntersectionPlane as se, createEdgeOffsetOperation as re, edgeOffsetRotationMatrix as Je, screenEdgeLengthSquared as Ke } from "./edgeOffsetUtils.js";
+import { OutlineVisualElement as le } from "../../visualElements/OutlineVisualElement.js";
+import { GraphicState as Qe } from "../../../layers/graphics/GraphicState.js";
+import { createExtrudedTriangle as pe, createSphereGeometry as F } from "../../../webgl-engine/lib/GeometryUtil.js";
+import { MouseButton as he } from "../../../../input/IViewEvents.js";
+import { sceneSnappingAtLocation as de, addMapDelta as X, createManipulatorDragEventPipeline as j, dragAtLocation as W, addScreenDelta as et } from "../../../../interactive/dragEventPipeline.js";
+import { ManipulatorStateFlags as g, ManipulatorStateCustomFlags as ue } from "../../../../interactive/interfaces.js";
+import { EditGeometryOperations as tt } from "../../../../interactive/editGeometry/EditGeometryOperations.js";
+import { AccumulationBehavior as J } from "../../../../interactive/editGeometry/interfaces.js";
+import { SnappingContext as ce } from "../../../../interactive/snapping/SnappingContext.js";
+import { createSnapDragEventPipelineStep as me } from "../../../../interactive/snapping/SnappingDragPipelineStep.js";
+import { ReshapeEdgeOffsetTooltipInfo as ge } from "../../../../interactive/tooltip/ReshapeTooltipInfos.js";
+import { Tooltip as it } from "../../../../interactive/tooltip/Tooltip.js";
+import { TranslateGraphicZTooltipInfo as at, TranslateGraphicXYTooltipInfo as nt, TranslateGraphicTooltipInfo as ot, TranslateVertexZTooltipInfo as st, TranslateVertexXYTooltipInfo as rt, TranslateVertexTooltipInfo as lt } from "../../../../interactive/tooltip/TranslateTooltipInfos.js";
+import { makeElevationField as pt } from "../../../../interactive/tooltip/fields/fields.js";
+import { autoArea2D as ht } from "../../../../support/automaticAreaMeasurementUtils.js";
+import { autoDistanceBetweenPoints2D as Z, autoLength2D as dt } from "../../../../support/automaticLengthMeasurementUtils.js";
+import { verticalSignedDistanceBetweenPoints as fe, elevationFromPoint as ut } from "../../../../support/euclideanLengthMeasurementUtils.js";
+import { geodesicDistance as ct } from "../../../../support/geodesicLengthMeasurementUtils.js";
+import mt from "../../../../../geometry/SpatialReference.js";
+let _ = class extends xe.EventedMixin(Me) {
+  constructor(e) {
+    super(e), this._selectedIndex = 0, this._manipulatorHandles = new Oe(), this._manipulatorInfos = [], this._numGrabbing = 0, this._numDragging = 0, this._reshapeEventState = d.NONE, this._updatingHandles = new Pe(), this._recreatingManipulators = !1, this._settings = new qe({ getTheme: () => this.view.effectiveTheme }), this._latestTooltipInfo = null, this._translateGraphicTooltipInfo = null, this._translateGraphicXYTooltipInfo = null, this._translateGraphicZTooltipInfo = null, this._translateVertexTooltipInfo = null, this._translateVertexXYTooltipInfo = null, this._translateVertexZTooltipInfo = null, this._edgeOffsetTooltipInfo = null, this.outputGeometry = null, this._vertexLaserLineVisualElement = null;
+  }
+  initialize() {
+    const { graphic: e, view: t } = this, a = this._settings.manipulators, i = a.vertex;
+    this._vertexManipulatorMaterial = $(G(i.color), i.renderOccluded), this._vertexManipulatorOutlineMaterial = C(G(i.outlineColor), i.renderOccluded), this._vertexManipulatorHoverOutlineMaterial = C(G(i.hoverOutlineColor), i.renderOccluded);
+    const n = a.edge;
+    this._edgeManipulatorMaterial = $(G(n.color), n.renderOccluded), this._edgeManipulatorOutlineMaterial = C(G(n.outlineColor), n.renderOccluded);
+    const o = a.edgeOffset;
+    this._edgeOffsetManipulatorMaterial = $(G(o.color), o.renderOccluded, !1), this._edgeOffsetManipulatorHoverMaterial = $(G(o.hoverColor), o.renderOccluded, !1);
+    const s = a.selected;
+    this._selectedManipulatorMaterial = $(G(s.color), s.renderOccluded), this._selectedManipulatorOutlineMaterial = C(G(s.outlineColor), s.renderOccluded), this._selectedManipulatorHoverOutlineMaterial = C(G(s.hoverOutlineColor), s.renderOccluded);
+    const r = this._graphicState = new Qe({ graphic: e });
+    this.tooltip = new it({ view: t }), this.addHandles([V(() => {
+      const l = this._settings.manipulators;
+      return { vertexSettings: l.vertex, edgeSettings: l.edge, edgeOffsetSettings: l.edgeOffset, selectedSettings: l.selected };
+    }, ({ vertexSettings: l, edgeSettings: p, edgeOffsetSettings: h, selectedSettings: M }) => {
+      l.applyColor(this._vertexManipulatorMaterial), l.applyOutline(this._vertexManipulatorOutlineMaterial), l.applyHoverOutline(this._vertexManipulatorHoverOutlineMaterial), p.applyColor(this._edgeManipulatorMaterial), p.applyOutline(this._edgeManipulatorOutlineMaterial), h.applyColor(this._edgeOffsetManipulatorMaterial), h.applyHover(this._edgeOffsetManipulatorHoverMaterial), M.applyColor(this._selectedManipulatorMaterial), M.applyOutline(this._selectedManipulatorOutlineMaterial), M.applyHoverOutline(this._selectedManipulatorHoverOutlineMaterial);
+    }), V(() => r.displaying, (l) => {
+      for (const p of this._manipulatorInfos)
+        p.manipulator.available = l;
+    }), V(() => ({ labels: this._segmentLabels, enabled: this.sketchOptions.labels.enabled, edgeOffsetEnabled: this.enableEdgeOffset }), ({ labels: l, enabled: p, edgeOffsetEnabled: h }) => {
+      l != null && (l.visible = p, l.edgeDistance = h ? "far" : "default");
+    }, L), V(() => this.sketchOptions.tooltips.effectiveEnabled, (l) => {
+      this.tooltip.info = l ? this._latestTooltipInfo : null;
+    }, L), this.view.trackGraphicState(r)]);
+  }
+  destroy() {
+    this._segmentLabels = A(this._segmentLabels), this.tooltip = A(this.tooltip), this._removeManipulators(), this._updatingHandles.destroy();
+  }
+  get inputGeometry() {
+    return this._editGeometryOperations != null ? this._editGeometryOperations.data.geometry : null;
+  }
+  set inputGeometry(e) {
+    this._recreateEditGeometryAndManipulators(e);
+  }
+  get updating() {
+    return this._updatingHandles.updating;
+  }
+  get manipulators() {
+    return this.tool.manipulators;
+  }
+  get view() {
+    return this.tool.view;
+  }
+  get graphic() {
+    return this.tool.graphic;
+  }
+  get enableZShape() {
+    return this.tool.enableZShape;
+  }
+  get enableZVertex() {
+    return this.tool.enableZVertex;
+  }
+  get enableMoveGraphic() {
+    return this.tool.enableMoveGraphic;
+  }
+  get enableMidpoints() {
+    return this.tool.enableMidpoints;
+  }
+  get enableEdgeOffset() {
+    return this.tool.enableEdgeOffset;
+  }
+  get sketchOptions() {
+    return this.tool.sketchOptions;
+  }
+  get _accentColor() {
+    return this.view.effectiveTheme.accentColor;
+  }
+  removeSelectedVertices() {
+    const e = this._manipulatorInfos.filter((t) => t.manipulator.selected && t.type === "vertex");
+    this._removeVertices(e);
+  }
+  onManipulatorSelectionChanged() {
+    this.emit("manipulators-changed");
+  }
+  _removeManipulators() {
+    this._manipulatorHandles.removeAll(), this._moveManipulation = A(this._moveManipulation), this._graphicMoveManipulation = A(this._graphicMoveManipulation), this.manipulators.removeAll(), this._manipulatorInfos = [], this._numGrabbing = 0, this._numDragging = 0;
+  }
+  _createManipulators(e) {
+    if (this._editGeometryOperations == null)
+      return;
+    const t = P(this.graphic);
+    for (const a of this._editGeometryOperations.data.components) {
+      const i = e == null ? void 0 : e.byComponentIndex.get(a.index);
+      for (const n of a.vertices) {
+        const o = i == null ? void 0 : i.has(n.index);
+        this._createVertexOrEdgeManipulator(n, t, o);
+      }
+      for (const n of a.edges)
+        this._createVertexOrEdgeManipulator(n, t);
+    }
+    this._createGraphicMoveManipulation(), this._createMoveManipulation(t), this._createVisualElements();
+  }
+  get canRedo() {
+    return this._editGeometryOperations != null && this._editGeometryOperations.canRedo;
+  }
+  get canUndo() {
+    return this._editGeometryOperations != null && this._editGeometryOperations.canUndo;
+  }
+  redo() {
+    if (this._editGeometryOperations == null)
+      return null;
+    const e = this._editGeometryOperations.redo();
+    return e != null && (this.outputGeometry = this._editGeometryOperations.data.geometry, this._recreateManipulators()), e;
+  }
+  undo() {
+    if (this._editGeometryOperations == null)
+      return null;
+    this.emit("undo");
+    const e = this._editGeometryOperations.undo();
+    return e != null && (this.outputGeometry = this._editGeometryOperations.data.geometry, this._recreateManipulators()), e;
+  }
+  _recreateManipulators() {
+    this._recreatingManipulators || (this._recreatingManipulators = !0, this._removeManipulators(), this._hideTooltip(), this._createManipulators(), this._recreatingManipulators = !1);
+  }
+  _recreateEditGeometryAndManipulators(e) {
+    const t = { byComponentIndex: /* @__PURE__ */ new Map() };
+    if (e != null && this.inputGeometry != null && Ce(e, this.inputGeometry)) {
+      for (const n of this._manipulatorInfos)
+        if (n.type === "vertex" && n.manipulator.selected) {
+          const { index: o, component: { index: s } } = n.handle, { byComponentIndex: r } = t, l = r.get(s) || /* @__PURE__ */ new Set();
+          l.add(o), r.set(s, l);
+        }
+    }
+    if (this._recreatingManipulators = !0, this._removeManipulators(), this._hideTooltip(), this._editGeometryOperations = A(this._editGeometryOperations), this._segmentLabels = A(this._segmentLabels), e == null)
+      return void (this._recreatingManipulators = !1);
+    const a = e.type === "mesh" ? e.anchor : e;
+    this._editGeometryOperations = tt.fromGeometry(a, this.view.state.viewingMode), this._createManipulators(t);
+    const i = this.sketchOptions.labels;
+    this._segmentLabels = new Ue({ context: { view: this.view, editGeometryOperations: this._editGeometryOperations, elevationInfo: P(this.graphic), labelOptions: i, graphic: this.graphic, graphicState: this._graphicState }, visible: i.enabled }), this._recreatingManipulators = !1;
+  }
+  _perGraphicManipulatorDragAction(e, t) {
+    if (t.action === "end")
+      return t;
+    let a = 0;
+    const i = [], n = this._manipulatorInfos.some((s) => s.type === "vertex" && s.manipulator.selected), o = e === D.SELECTED_OR_ALL && n;
+    for (const s of this._manipulatorInfos)
+      s.type === "vertex" && (s.manipulator.grabbing || o && !s.manipulator.selected || i.push(s), a++);
+    if (i.length === 0)
+      return t;
+    if (this._moveVertices(i, t), i.length === a) {
+      if (this._updateEventState(d.MOVING), this.destroyed)
+        return t;
+      this.emit("move", { type: "move", dx: t.screenDeltaX, dy: t.screenDeltaY, mover: this.graphic });
+    } else {
+      if (this._updateEventState(d.RESHAPING), this.destroyed)
+        return t;
+      this.emit("reshape", { type: "reshape", mover: this.graphic });
+    }
+    return t;
+  }
+  _isMultiVertexSelection() {
+    return this._manipulatorInfos.reduce((e, t) => t.type === "vertex" && t.manipulator.selected ? e + 1 : e, 0) > 1;
+  }
+  _perVertexManipulatorDragAction(e) {
+    if (this._updateEventState(d.RESHAPING), this.destroyed)
+      return;
+    const { mapDeltaX: t, mapDeltaY: a, mapDeltaZ: i } = e;
+    if (!t && !a && !i)
+      return;
+    const n = [];
+    for (const o of this._manipulatorInfos)
+      o.type === "vertex" && (o.manipulator.selected && !o.manipulator.grabbing || o === e.info) && n.push(o);
+    this._moveVertices(n, e, J.ACCUMULATE_STEPS), this.emit("reshape", { type: "reshape", mover: this.graphic });
+  }
+  _updateEventState(e) {
+    if (e === this._reshapeEventState)
+      return !1;
+    switch (e) {
+      case d.NONE:
+        if (this._numGrabbing !== 0 || this._numDragging !== 0)
+          return !1;
+        switch (this._reshapeEventState) {
+          case d.MOVING:
+            this.emit("move", { type: "move-stop", dx: 0, dy: 0, mover: this.graphic });
+            break;
+          case d.RESHAPING:
+            this.emit("reshape", { type: "reshape-stop", mover: this.graphic });
+        }
+        break;
+      case d.MOVING:
+        switch (this._reshapeEventState) {
+          case d.NONE:
+            this.emit("move", { type: "move-start", dx: 0, dy: 0, mover: this.graphic });
+            break;
+          case d.RESHAPING:
+            this.emit("reshape", { type: "reshape-stop", mover: this.graphic }), this.destroyed || this.emit("move", { type: "move-start", dx: 0, dy: 0, mover: this.graphic });
+        }
+        break;
+      case d.RESHAPING:
+        switch (this._reshapeEventState) {
+          case d.NONE:
+            this.emit("reshape", { type: "reshape-start", mover: this.graphic });
+            break;
+          case d.MOVING:
+            this.emit("move", { type: "move-stop", dx: 0, dy: 0, mover: this.graphic }), this.destroyed || this.emit("reshape", { type: "reshape-start", mover: this.graphic });
+        }
+    }
+    if (this.destroyed)
+      return !1;
+    const t = this._reshapeEventState !== e;
+    return this._reshapeEventState = e, t;
+  }
+  _createGraphicMoveManipulation() {
+    const { tool: e, view: t } = this, a = this._graphicState;
+    if (this._graphicMoveManipulation = new We({ tool: e, view: t, graphicState: a }), this.enableMoveGraphic) {
+      let i = null;
+      this._manipulatorHandles.add(this._graphicMoveManipulation.createDragPipeline((n, o, s) => {
+        o.next((r) => this._trackNumDragging(r)).next((r) => (r.action === "start" && (i = this._editGeometryOperations.createUndoGroup()), r)).next((r) => this._perGraphicManipulatorDragAction(D.ALL, r)).next((r) => (this._updateTranslateGraphicTooltip(b.XY, r), r)).next((r) => {
+          r.action === "end" && (this._hideTooltip(), i = w(i));
+        }), s.next(() => this._onDragCancel(!0, () => i = w(i)));
+      })), this._graphicMoveManipulation.forEachManipulator((n) => this._manipulatorHandles.add(this._watchAndUpdateGrabState(n, !1)));
+    } else
+      this._graphicMoveManipulation.forEachManipulator((i) => {
+        i.grabbable = !1, i.cursor = null;
+      });
+    this._graphicMoveManipulation.forEachManipulator((i) => this._manipulatorHandles.add(i.events.on("immediate-click", (n) => {
+      this._manipulatorInfos.some((o) => o.manipulator.selected) ? this._clearSelection() : this.emit("immediate-click", { ...n, graphic: this.graphic }), n.stopPropagation();
+    })));
+  }
+  _createMoveManipulation(e) {
+    const { graphic: t, tool: a, view: i } = this, n = this._graphicState;
+    this._moveManipulation = new B({ tool: a, view: i, xyAvailable: !0, xyAxisAvailable: !0, zAvailable: this.enableZShape && q(t), snapToScene: !1, radius: B.radiusForSymbol(t.symbol) }), this._moveManipulation.forEachManipulator((r) => this.addHandles([r.events.on("immediate-click", (l) => {
+      this._moveManipulation.zManipulation.hasManipulator(r) || this._manipulatorInfos.some((p) => p.manipulator.selected) || this.emit("immediate-click", { ...l, graphic: t }), l.stopPropagation();
+    }), this._watchAndUpdateGrabState(r, !1)]));
+    const o = (r) => (l) => {
+      this.addHandles(l.events.on("focus-changed", ({ action: p }) => {
+        p === "focus" ? this._updateTranslateTooltip(r) : this._hideTooltip();
+      }));
+    };
+    this._moveManipulation.xyManipulation.forEachManipulator(o(b.XY)), this._moveManipulation.xyAxisManipulation.forEachManipulator(o(b.XY_AXIS)), this._moveManipulation.zManipulation.forEachManipulator(o(b.Z)), this._moveManipulation.elevationInfo = { mode: "absolute-height", offset: 0 };
+    const s = t.geometry.spatialReference;
+    this.addHandles([this._moveManipulation.createDragPipeline((r, l, p, h, M) => {
+      const { snappingStep: c, cancelSnapping: u } = me({ predicate: (m) => !!m.info, snappingManager: a.snappingManager, snappingContext: new ce({ editGeometryOperations: this._editGeometryOperations, elevationInfo: e, pointer: M, excludeFeature: t, visualizer: new ae() }), updatingHandles: this._updatingHandles, useZ: !1 });
+      return h = h.next((m) => (this._onDragCancel(), m)).next(u), { steps: p = p.next((m) => this._trackNumDragging(m)).next((m) => {
+        const y = this._manipulatorInfos.filter((f) => f.type === "vertex" && f.manipulator.selected);
+        return m.manipulatorType === ne.TRANSLATE_XY && y.length === 1 ? { ...m, info: y[0], snapOrigin: y[0].handle.pos } : m;
+      }).next(de(this.view, e, t)).next(...c).next(X()).next((m) => this._perGraphicManipulatorDragAction(D.SELECTED_OR_ALL, m)).next((m) => (this._updateTranslateTooltip(r, m), m)), cancel: h };
+    }, e, s, t), V(() => n.displaying, () => this._updateMoveManipulationPosition(), L), n.on("changed", () => {
+      this._recreatingManipulators || this._updateMoveManipulationPosition();
+    }), V(() => n.isDraped, (r) => {
+      this._updateMoveManipulationPosition();
+      const l = "align-move-manipulation";
+      r ? this.addHandles(this.view.elevationProvider.on("elevation-change", () => this._updateMoveManipulationPosition()), l) : this.removeHandles(l);
+    }, L)]);
+  }
+  _createVisualElements() {
+    const { graphic: e, view: t } = this, a = Be({ view: t, graphic: e, forEachManipulator: (i) => {
+      if (!this.destroyed && !this._recreatingManipulators) {
+        this._graphicMoveManipulation.forEachManipulator(i), this._moveManipulation.forEachManipulator(i);
+        for (const n of this._manipulatorInfos)
+          i(n.manipulator, ne.TRANSLATE_XY);
+      }
+    }, onManipulatorsChanged: (i) => this.on("manipulators-changed", i) });
+    a != null && (this._outlineVisualElement = a.visualElement instanceof le ? a.visualElement : null), this._outlineVisualElement != null && this._manipulatorHandles.add(this._outlineVisualElement.events.on("attachment-origin-changed", () => {
+      this._graphicState.isDraped || this._updateMoveManipulationPosition();
+    })), this._manipulatorHandles.add(a);
+  }
+  _createEdgeOffsetManipulator(e, t = P(this.graphic)) {
+    var u, m;
+    if (e.component.vertices.length <= 2)
+      return null;
+    const a = this._settings.manipulators.edgeOffset, i = a.size / 2, n = i + a.collisionPadding, o = i / n, s = o * Math.sqrt(3) / 2;
+    this._edgeOffsetManipulatorGeometryInside == null && (this._edgeOffsetManipulatorGeometryInside = pe(this._edgeOffsetManipulatorMaterial, s, o / 2, o / 2, a.height, a.offset)), this._edgeOffsetManipulatorGeometryOutside == null && (this._edgeOffsetManipulatorGeometryOutside = pe(this._edgeOffsetManipulatorMaterial, -s, o / 2, o / 2, a.height, -a.offset));
+    const r = [new E(this._edgeOffsetManipulatorGeometryInside.instantiate(), g.Unfocused), new E(this._edgeOffsetManipulatorGeometryInside.instantiate({ material: this._edgeOffsetManipulatorHoverMaterial }), g.Focused), new E(this._edgeOffsetManipulatorGeometryOutside.instantiate(), g.Unfocused), new E(this._edgeOffsetManipulatorGeometryOutside.instantiate({ material: this._edgeOffsetManipulatorHoverMaterial }), g.Focused)], l = new Y({ view: this.view, renderObjects: r, elevationInfo: t.mode !== "on-the-ground" || ie(this.graphic.symbol) ? { mode: "absolute-height", offset: 0 } : t, worldOriented: !1, focusMultiplier: 1, radius: n, available: !(!this.graphic.visible || !((u = this.graphic.layer) != null && u.visible)), collisionType: { type: "disc", direction: De(0, 0, 1) }, collisionPriority: 1, metadata: { deleting: !1 } }), p = new Y({ view: this.view, worldSized: !0, worldOriented: !1, available: !(!this.graphic.visible || !((m = this.graphic.layer) != null && m.visible)), collisionPriority: -10, cursor: this.enableMoveGraphic ? "move" : "default", metadata: { deleting: !1 } }), h = { manipulator: l, handle: e, locationUpdateHandle: null, type: "edge", selectedIndex: 0, edgeManipulator: p, elevationInfo: t, visibilityHandle: null };
+    this._autoHideEdgeOffsetManipulator(h, a.minSquaredEdgeLength), this._updateEdgeOffsetManipulator(h);
+    const M = [];
+    for (const y of [e.leftVertex, e.rightVertex]) {
+      const f = this._getManipulatorInfoFromHandle(y);
+      f != null && M.push(f.manipulator.events.on("location-update", () => this._updateEdgeOffsetManipulator(h)));
+    }
+    h.locationUpdateHandle = R(M), this._manipulatorHandles.add(h.locationUpdateHandle, l), this._manipulatorHandles.add([this._watchAndUpdateGrabState(l, !0), this._watchAndUpdateGrabState(p, !0)], l), this._manipulatorHandles.add(j(l, this._createEdgeOffsetPipeline(h, t)), l), this._manipulatorHandles.add(j(p, (y, f, H, I) => {
+      if (I === "touch")
+        this._createEdgeOffsetPipeline(h, t)(y, f, H);
+      else if (this.enableMoveGraphic) {
+        const O = this.graphic, N = O.geometry != null ? O.geometry.spatialReference : null;
+        f.next((S) => this._trackNumDragging(S)).next(W(this.view, y.elevationAlignedLocation)).next(Ze(this.view, y.elevationAlignedLocation, t, N, O)).next(et()).next(X()).next((S) => this._perGraphicManipulatorDragAction(D.ALL, S)).next((S) => (this._updateTranslateGraphicTooltip(b.XY, S), S)).next((S) => {
+          S.action === "end" && this._hideTooltip();
+        }), H.next(() => this._onDragCancel(!y.metadata.deleting));
+      }
+    }), l);
+    const c = (y) => {
+      this._manipulatorInfos.some((f) => f.manipulator.selected) ? this._clearSelection() : this.emit("immediate-click", { ...y, graphic: this.graphic }), y.stopPropagation();
+    };
+    return this._manipulatorHandles.add([l.events.on("immediate-click", c), p.events.on("immediate-click", c), l.events.on("focus-changed", ({ action: y }) => {
+      const { sketchOptions: f, tooltip: H } = this;
+      if (y === "focus") {
+        const I = this._edgeOffsetTooltipInfo ?? (this._edgeOffsetTooltipInfo = new ge({ sketchOptions: f }));
+        I.distance = U, I.sketchOptions = f, this._updateTooltipAreaOrTotalLength(I), this._latestTooltipInfo = I, H.info = f.tooltips.effectiveEnabled ? this._latestTooltipInfo : null;
+      } else
+        this._hideTooltip();
+    })], l), this._manipulatorInfos.push(h), this.manipulators.add(l), this.manipulators.add(p), this.emit("manipulators-changed"), h;
+  }
+  _autoHideEdgeOffsetManipulator(e, t) {
+    const a = e.manipulator, i = e.edgeManipulator, n = () => {
+      e.visibilityHandle = w(e.visibilityHandle);
+      const o = this._getManipulatorInfoFromHandle(e.handle.leftVertex), s = this._getManipulatorInfoFromHandle(e.handle.rightVertex), r = o != null && s != null && Ke(o.manipulator.renderLocation, s.manipulator.renderLocation, this.view.state.camera) < t;
+      (!a.focused && !i.focused || r) && (a.grabbable = !r, i.grabbable = !r, e.visibilityHandle = R([a.disableDisplay(), Q(() => {
+        a.grabbable = !0, i.grabbable = this.enableMoveGraphic;
+      })]));
+    };
+    this._manipulatorHandles.add([a.events.on("focus-changed", n), i.events.on("focus-changed", n), Q(() => {
+      w(e.visibilityHandle), i.metadata.deleting = !0, this.manipulators.remove(i);
+    })], a), n();
+  }
+  _updateEdgeOffsetManipulator(e) {
+    this._updateManipulatorPosition(e);
+    const { coordinateHelper: t } = this._editGeometryOperations.data, a = se(this.view, e.manipulator.elevationAlignedLocation, re(t, e.handle, e.manipulator.elevationInfo)), i = this._getManipulatorInfoFromHandle(e.handle.leftVertex), n = this._getManipulatorInfoFromHandle(e.handle.rightVertex);
+    if (i == null || n == null)
+      return;
+    const o = i.manipulator.renderLocation, s = n.manipulator.renderLocation, r = a != null ? Je(a, o, s) : Te;
+    e.manipulator.modelTransform = r, e.edgeManipulator.elevationAlignedLocation = e.manipulator.elevationAlignedLocation, e.edgeManipulator.modelTransform = r;
+    const l = Ie(Se(z, o, s)) / 2;
+    e.edgeManipulator.collisionType = { type: "line", paths: [[[-l, 0, 0], [l, 0, 0]]] };
+  }
+  _createEdgeOffsetPipeline(e, t) {
+    return (a, i, n) => {
+      this._clearSelection();
+      const { step: o, cleanup: s } = this._initializeEdgeOffset(e, t);
+      i.next((r) => this._trackNumDragging(r)).next(W(this.view, a.elevationAlignedLocation)).next(o).next(Fe(this.view)).next(Xe(this.view, this._editGeometryOperations.data.spatialReference)).next(X()).next(this._applyComputeEdgeOffsetDistanceStep()).next(this._applyEdgeOffsetStep(e)).next(this._showEdgeOffsetTooltip()).next((r) => {
+        r.action === "end" && s();
+      }), n.next(() => {
+        a.metadata.deleting || (s(), this._onDragCancel());
+      });
+    };
+  }
+  _initializeEdgeOffset(e, t) {
+    const { view: a } = this, i = this._editGeometryOperations, n = re(i.data.coordinateHelper, e.handle, t), o = i.createUndoGroup(), s = se(a, e.manipulator.elevationAlignedLocation, n);
+    if (n.requiresSplitEdgeLeft) {
+      const u = this._getManipulatorInfoFromHandle(e.handle.leftVertex.leftEdge);
+      u != null && this._splitEdgeManipulator(u, 1);
+    }
+    if (n.requiresSplitEdgeRight) {
+      const u = this._getManipulatorInfoFromHandle(e.handle.rightVertex.rightEdge);
+      u != null && this._splitEdgeManipulator(u, 0);
+    }
+    const r = () => new $e({ paths: [[e.handle.leftVertex.pos, e.handle.rightVertex.pos]], spatialReference: i.data.spatialReference }), l = this._settings, p = new le({ view: a, isDraped: this._graphicState.isDraped, geometry: r(), elevationInfo: e.elevationInfo, width: l.visualElements.lineGraphics.outline.width, attached: !1, isDecoration: !0 });
+    let h;
+    const M = () => {
+      this._cleanEdgeOffsetCollapsedEdges(e), h = w(h);
+    }, c = this.on("undo", M);
+    return h = R([V(() => G(this._accentColor), (u) => p.color = u, L), Ee(p), V(() => this._graphicState.isDraped, (u) => p.isDraped = u), this._graphicState.on("changed", () => p.geometry = r()), o, c]), p.attached = !0, { step: (u) => n == null || s == null ? (M(), null) : { ...u, operation: n, plane: s }, cleanup: M };
+  }
+  _applyEdgeOffsetStep(e) {
+    return (t) => {
+      if (this.destroyed || t.operation == null)
+        return t;
+      this._updateEventState(d.RESHAPING);
+      const { mapDeltaX: a, mapDeltaY: i, mapDeltaZ: n } = t;
+      return (a || i || n) && (this._offsetEdge(e, t), this.emit("reshape", { type: "reshape", mover: this.graphic })), t;
+    };
+  }
+  _applyComputeEdgeOffsetDistanceStep() {
+    return (e) => {
+      const { operation: t, mapEnd: a } = e;
+      return t == null || a == null ? e : (e.action === "start" && t.selectArrowFromStartPoint(a), { ...e, signedDistance: t.signedDistanceToPoint(a) });
+    };
+  }
+  _showEdgeOffsetTooltip() {
+    return (e) => {
+      const { mapEnd: t, signedDistance: a, operation: i } = e, { tooltip: n, sketchOptions: o } = this;
+      if (a != null) {
+        const s = this._edgeOffsetTooltipInfo ?? (this._edgeOffsetTooltipInfo = new ge({ sketchOptions: o }));
+        s.sketchOptions = o, s.distance = e.action === "end" ? U : gt(this._graphicState.isDraped, a * i.selectedArrow, t, i.plane, this._editGeometryOperations.data.coordinateHelper), this._updateTooltipAreaOrTotalLength(s), this._latestTooltipInfo = s;
+      } else
+        this._latestTooltipInfo = null;
+      return n.info = o.tooltips.effectiveEnabled ? this._latestTooltipInfo : null, e;
+    };
+  }
+  _cleanEdgeOffsetCollapsedEdges(e) {
+    var r, l;
+    const t = (r = e.handle.leftVertex.leftEdge) == null ? void 0 : r.leftVertex, a = e.handle.leftVertex, i = (l = e.handle.rightVertex.rightEdge) == null ? void 0 : l.rightVertex, n = e.handle.rightVertex, o = this._editGeometryOperations.data.coordinateHelper, s = [];
+    if (t && o.distance(t.pos, a.pos) < K) {
+      const p = this._getManipulatorInfoFromHandle(a);
+      p != null && s.push(p);
+    }
+    if (o.distance(a.pos, n.pos) < K || i && o.distance(i.pos, n.pos) < K) {
+      const p = this._getManipulatorInfoFromHandle(n);
+      p != null && s.push(p);
+    }
+    s.length && this._removeVertices(s);
+  }
+  _computeVertexManipulatorSizeAndOutline(e) {
+    const t = e.size / 2, a = t + e.collisionPadding;
+    return { size: t / a, outlineSize: (t + e.outlineSize) / a };
+  }
+  _createVertexOrEdgeManipulator(e, t = P(this.graphic), a = !1) {
+    var M;
+    const { view: i } = this, n = this._settings;
+    if (e.type === "edge") {
+      if (this.enableEdgeOffset)
+        return this._createEdgeOffsetManipulator(e, t);
+      if (!this.enableMidpoints)
+        return null;
+    }
+    if (this._vertexManipulatorGeometry == null || this._vertexManipulatorOutlineGeometry == null) {
+      const { size: c, outlineSize: u } = this._computeVertexManipulatorSizeAndOutline(n.manipulators.vertex);
+      this._vertexManipulatorGeometry = F(this._vertexManipulatorMaterial, c, 16, 16), this._vertexManipulatorOutlineGeometry = F(this._vertexManipulatorOutlineMaterial, u, 16, 16);
+    }
+    if (this._edgeManipulatorGeometry == null || this._edgeManipulatorOutlineGeometry == null) {
+      const { size: c, outlineSize: u } = this._computeVertexManipulatorSizeAndOutline(n.manipulators.edge);
+      this._edgeManipulatorGeometry = F(this._edgeManipulatorMaterial, c, 16, 16), this._edgeManipulatorOutlineGeometry = F(this._edgeManipulatorOutlineMaterial, u, 16, 16);
+    }
+    const { geometry: o } = this.graphic, s = o == null ? void 0 : o.type, r = s === "point" || s === "mesh" ? [] : [new E(this._vertexManipulatorGeometry.instantiate(), T.Vertex | g.Unselected), new E(this._vertexManipulatorOutlineGeometry.instantiate(), T.Vertex | g.Unfocused | g.Unselected), new E(this._vertexManipulatorOutlineGeometry.instantiate({ material: this._vertexManipulatorHoverOutlineMaterial }), T.Vertex | g.Focused | g.Unselected), new E(this._vertexManipulatorGeometry.instantiate({ material: this._selectedManipulatorMaterial }), g.Selected), new E(this._vertexManipulatorOutlineGeometry.instantiate({ material: this._selectedManipulatorOutlineMaterial }), g.Selected | g.Unfocused), new E(this._vertexManipulatorOutlineGeometry.instantiate({ material: this._selectedManipulatorHoverOutlineMaterial }), g.Selected | g.Focused)];
+    this.enableMidpoints && r.push(new E(this._edgeManipulatorGeometry.instantiate({ material: this._vertexManipulatorMaterial }), T.Edge | g.Focused | g.Unselected), new E(this._edgeManipulatorOutlineGeometry.instantiate({ material: this._vertexManipulatorHoverOutlineMaterial }), T.Edge | g.Focused | g.Unselected), new E(this._edgeManipulatorGeometry.instantiate(), T.Edge | g.Unfocused | g.Unselected), new E(this._edgeManipulatorOutlineGeometry.instantiate(), T.Edge | g.Unfocused | g.Unselected));
+    const l = new Y({ view: i, renderObjects: r, elevationInfo: t, focusMultiplier: 1, touchMultiplier: 1, available: !(!this.graphic.visible || !((M = this.graphic.layer) != null && M.visible)), metadata: { deleting: !1 } });
+    l.selected = a, this._setTypeSpecificManipulatorSettings(l, e, t);
+    const p = e.type === "edge" ? { manipulator: l, handle: e, locationUpdateHandle: null, type: "edge", selectedIndex: 0 } : { manipulator: l, handle: e, type: "vertex", selectedIndex: 0 };
+    if (this._manipulatorInfos.push(p), this.manipulators.add(l), this._updateManipulatorPosition(p), p.type === "edge") {
+      const c = [];
+      for (const u of [p.handle.leftVertex, p.handle.rightVertex]) {
+        const m = this._getManipulatorInfoFromHandle(u);
+        m != null && c.push(m.manipulator.events.on("location-update", () => this._updateManipulatorPosition(p)));
+      }
+      p.locationUpdateHandle = R(c), this._manipulatorHandles.add(p.locationUpdateHandle, l);
+    }
+    this._manipulatorHandles.add(this._watchAndUpdateGrabState(l, !0), l);
+    const h = j(l, (c, u, m, y) => {
+      let f = null;
+      const { snappingStep: H, cancelSnapping: I } = me({ predicate: () => !this._isMultiVertexSelection(), snappingManager: this.tool.snappingManager, snappingContext: new ce({ editGeometryOperations: this._editGeometryOperations, elevationInfo: t, pointer: y, excludeFeature: this.graphic, visualizer: new ae() }), updatingHandles: this._updatingHandles, useZ: !1 });
+      m = m.next((O) => (this._onDragCancel(!c.metadata.deleting, () => f = w(f)), O)).next(I), u.next((O) => this._trackNumDragging(O)).next((O) => {
+        if (O.action === "start" && (f = this._editGeometryOperations.createUndoGroup()), p.type === "edge") {
+          const N = this._splitEdgeManipulator(p);
+          return { ...O, info: N, snapOrigin: N.handle.pos };
+        }
+        return { ...O, info: p, snapOrigin: p.handle.pos };
+      }).next(W(this.view, c.elevationAlignedLocation)).next(ze(this.view, this.graphic, c.elevationAlignedLocation, c.location.spatialReference, this.graphic)).next(de(this.view, t, this.graphic)).next(...H).next(X()).next((O) => {
+        this._perVertexManipulatorDragAction(O), O.action === "end" && (f = w(f)), this._updateTranslateVertexTooltip(c, b.XY, O);
+      });
+    });
+    return this._manipulatorHandles.add([h, l.events.on("immediate-click", (c) => this._manipulatorClickCallback(c, p)), l.events.on("select-changed", () => {
+      p.selectedIndex = ++this._selectedIndex, this._updateMoveManipulationPosition();
+    }), l.events.on("focus-changed", ({ action: c }) => {
+      c === "focus" && p.type !== "edge" ? this._updateTranslateVertexTooltip(l, b.XY) : this._hideTooltip();
+    })], l), this.emit("manipulators-changed"), p;
+  }
+  _trackNumDragging(e) {
+    switch (e.action) {
+      case "start":
+        this._numDragging++;
+        break;
+      case "end":
+        this._numDragging--;
+    }
+    return e;
+  }
+  _onDragCancel(e = !0, t) {
+    switch (this._numDragging--, e && (this.undo(), this.outputGeometry = this._editGeometryOperations != null ? this._editGeometryOperations.data.geometry : null), this.tool.snappingManager != null && this.tool.snappingManager.doneSnapping(), this._hideTooltip(), this._reshapeEventState) {
+      case d.NONE:
+        break;
+      case d.MOVING:
+        this.emit("move", { type: "move", dx: 0, dy: 0, mover: this.graphic });
+        break;
+      case d.RESHAPING:
+        this.emit("reshape", { type: "reshape", mover: this.graphic });
+    }
+    t && t(), this.destroyed || this._updateEventState(d.NONE);
+  }
+  _setTypeSpecificManipulatorSettings(e, t, a) {
+    const { graphic: i } = this, n = this._settings;
+    switch (t.type) {
+      case "vertex": {
+        e.state = T.Vertex, e.selectable = !0, e.cursor = "move", e.collisionPriority = 2;
+        const { size: o, collisionPadding: s } = n.manipulators.vertex;
+        e.radius = o / 2 + s, e.elevationInfo = a;
+        const { geometry: r } = i, l = r == null ? void 0 : r.type;
+        e.interactive = l != null && l !== "point" && l !== "mesh";
+        break;
+      }
+      case "edge": {
+        e.state = T.Edge, e.selectable = !1, e.cursor = "copy", e.collisionPriority = -1;
+        const { size: o, collisionPadding: s } = n.manipulators.edge;
+        e.radius = o / 2 + s, e.elevationInfo = a.mode !== "on-the-ground" || ie(i.symbol) ? { mode: "absolute-height", offset: 0 } : a;
+        break;
+      }
+    }
+  }
+  _watchAndUpdateGrabState(e, t) {
+    return e.events.on("grab-changed", (a) => this._onGrabStateChanged(e, t, a.action, a.pointerType));
+  }
+  _onGrabStateChanged(e, t, a, i = "mouse") {
+    if (!this._recreatingManipulators) {
+      if (a === "start")
+        t && this._updateSelection(e), this._numGrabbing++;
+      else if (this._numGrabbing--, this._updateEventState(d.NONE), this.destroyed)
+        return;
+      this._moveManipulation.interactive = !this._numGrabbing, (i !== "touch" || this.enableEdgeOffset) && (this._manipulatorInfos.forEach((n) => {
+        const { manipulator: o } = n, { geometry: s } = this.graphic, r = s == null ? void 0 : s.type;
+        o.interactive = o.grabbing || !this._numGrabbing && r != null && r !== "point" && r !== "mesh", "edgeManipulator" in n && (n.edgeManipulator.interactive = n.edgeManipulator.grabbing || !this._numGrabbing);
+      }), this._graphicMoveManipulation.forEachManipulator((n) => {
+        n.interactive = n.grabbing || !this._numGrabbing;
+      }));
+    }
+  }
+  _clearSelection() {
+    for (const e of this._manipulatorInfos)
+      e.manipulator.grabbing || (e.manipulator.selected = !1);
+  }
+  _updateSelection(e) {
+    e.grabbing && !e.selected && e.selectable && (this._clearSelection(), e.selected = !0, this.emit("manipulators-changed"));
+  }
+  _removeManipulator(e) {
+    e != null && (e.manipulator.metadata.deleting = !0, this.manipulators.remove(e.manipulator), this._manipulatorHandles.remove(e.manipulator), ye(this._manipulatorInfos, e), this.emit("manipulators-changed"));
+  }
+  _getManipulatorInfoFromHandle(e) {
+    if (e) {
+      for (const t of this._manipulatorInfos)
+        if (e === t.handle)
+          return t;
+    }
+    return null;
+  }
+  _updateManipulatorPosition(e) {
+    if (e == null)
+      return;
+    const t = this._editGeometryOperations;
+    if (e.type === "vertex")
+      e.manipulator.location = t.data.coordinateHelper.vectorToDehydratedPoint(e.handle.pos, k), e.manipulator.grabbing && this._vertexLaserLineVisualElement != null && (this._vertexLaserLineVisualElement.visualElement.intersectsWorldUpAtLocation = e.manipulator.renderLocation);
+    else if (e.type === "edge") {
+      const a = this._getManipulatorInfoFromHandle(e.handle.leftVertex), i = this._getManipulatorInfoFromHandle(e.handle.rightVertex);
+      if (a == null || i == null)
+        return;
+      const n = a.manipulator, o = i.manipulator;
+      if (e.manipulator.elevationInfo != null && e.manipulator.elevationInfo.mode === "on-the-ground") {
+        const s = n.location, r = o.location, l = 0.5, p = s.x + l * (r.x - s.x), h = s.y + l * (r.y - s.y), M = s.hasZ && r.hasZ ? 0 : void 0;
+        e.manipulator.location = ve(p, h, M, t.data.spatialReference);
+      } else
+        we(z, n.renderLocation, o.renderLocation, 0.5), e.manipulator.renderLocation = z;
+    }
+  }
+  _splitEdgeManipulator(e, t = 0.5) {
+    const a = this._editGeometryOperations, i = a.splitEdge(e.handle, t).createdVertex;
+    e.locationUpdateHandle = w(e.locationUpdateHandle);
+    const n = P(this.graphic);
+    let o;
+    this.enableEdgeOffset ? (this._removeManipulator(e), o = this._createVertexOrEdgeManipulator(i)) : (o = e, o.handle = i, o.type = "vertex", this._setTypeSpecificManipulatorSettings(e.manipulator, e.handle, n)), i.leftEdge && this._createVertexOrEdgeManipulator(i.leftEdge), i.rightEdge && this._createVertexOrEdgeManipulator(i.rightEdge), this.outputGeometry = a.data.geometry, this._updateManipulatorPosition(o), this.enableEdgeOffset || this._updateTranslateVertexTooltip(o.manipulator, b.XY), this._updateSelection(e.manipulator);
+    const s = this._updateEventState(d.RESHAPING), r = a.data.coordinateHelper.vectorToArray(o.handle.pos), l = a.data.components.indexOf(i.component);
+    return this.emit("vertex-add", { type: "vertex-add", vertices: [{ coordinates: r, componentIndex: l, vertexIndex: i.index }], added: r }), s && this._updateEventState(d.NONE), o;
+  }
+  _updateMoveManipulationPosition() {
+    const e = Ve(z, 0, 0, 0);
+    let t = 0, a = !1, i = null, n = null;
+    for (const o of this._manipulatorInfos)
+      o.type === "vertex" && (o.manipulator.selected ? (t++, He(e, e, o.manipulator.renderLocation), i == null || o.selectedIndex > i.selectedIndex ? (n = i, i = o) : (n == null || o.selectedIndex > n.selectedIndex) && (n = o)) : a = !0);
+    if (t === 0) {
+      const o = this._graphicState.displaying && this.enableMoveGraphic;
+      this._moveManipulation.xyManipulation.available = o, this._moveManipulation.xyAxisManipulation.available = o, this._moveManipulation.xyAxisManipulation.orthogonalAvailable = o, this._moveManipulation.zManipulation.available = o && this.enableZShape && q(this.graphic), this._moveManipulation.angle = Ye(this.graphic.geometry), this._moveManipulation.radius = B.radiusForSymbol(this.graphic.symbol);
+    } else {
+      const o = this._graphicState.displaying;
+      this._moveManipulation.xyManipulation.available = o, this._moveManipulation.xyAxisManipulation.available = o, this._moveManipulation.zManipulation.available = o && this.enableZVertex && q(this.graphic), this._moveManipulation.xyAxisManipulation.orthogonalAvailable = o && t !== 1;
+      let s = 0;
+      if (i != null) {
+        const r = i.handle.pos, l = n != null ? n.handle.pos : i.handle.leftEdge && i.handle.leftEdge.leftVertex ? i.handle.leftEdge.leftVertex.pos : null, p = n == null && i.handle.rightEdge && i.handle.rightEdge.rightVertex ? i.handle.rightEdge.rightVertex.pos : null;
+        l && p ? this._moveManipulation.xyAxisManipulation.available = !1 : l ? s = _e(l, r) : p && (s = _e(r, p));
+      }
+      this._moveManipulation.angle = s, this._moveManipulation.radius = je;
+    }
+    t !== 0 && a ? (Ae(e, e, 1 / t), k.spatialReference = this._editGeometryOperations.data.spatialReference, k.hasZ = !0, this.view.renderCoordsHelper.fromRenderCoords(e, k), this._moveManipulation.elevationAlignedLocation = k) : this._outlineVisualElement == null || this._graphicState.isDraped || this._outlineVisualElement.attachmentOrigin == null ? Re(this.view, this._moveManipulation, this.graphic) : this._moveManipulation.elevationAlignedLocation = this._outlineVisualElement.attachmentOrigin;
+  }
+  _removeVertices(e) {
+    var i;
+    const t = new Array(), a = this._editGeometryOperations;
+    for (const n of e) {
+      const o = n.handle.component;
+      if (n.type === "vertex" && a.canRemoveVertex(o)) {
+        t.push(n.handle), this._removeManipulator(n), this._removeManipulator(this._getManipulatorInfoFromHandle(n.handle.leftEdge)), this._removeManipulator(this._getManipulatorInfoFromHandle(n.handle.rightEdge));
+        const s = a.removeVertices([n.handle]), r = (i = s.removedVertices) == null ? void 0 : i[0].createdEdge;
+        r ? this._createVertexOrEdgeManipulator(r) : this.enableEdgeOffset && o.vertices.length <= 2 && this._removeManipulator(this._getManipulatorInfoFromHandle(o.edges[0]));
+      }
+    }
+    if (t.length > 0) {
+      const n = t.map((s) => {
+        const r = a.data.components.indexOf(s.component);
+        return { coordinates: a.data.coordinateHelper.vectorToArray(s.pos), componentIndex: r, vertexIndex: s.index };
+      });
+      this.outputGeometry = a.data.geometry;
+      const o = this._updateEventState(d.RESHAPING);
+      if (this.destroyed || (this.emit("vertex-remove", { type: "vertex-remove", removed: n.map((s) => s.coordinates), vertices: n }), this.destroyed) || o && (this._updateEventState(d.NONE), this.destroyed))
+        return;
+      this._updateMoveManipulationPosition();
+    }
+  }
+  _moveVertices(e, t, a = t.action === "start" ? J.NEW_STEP : J.ACCUMULATE_STEPS) {
+    const i = this._editGeometryOperations;
+    i.moveVertices(e.map((n) => n.handle), t.mapDeltaX, t.mapDeltaY, t.mapDeltaZ, a), this.outputGeometry = i.data.geometry;
+    for (const n of e)
+      this._updateManipulatorPosition(n);
+  }
+  _offsetEdge(e, t) {
+    if (t.operation == null || t.signedDistance == null)
+      return;
+    const a = this._editGeometryOperations, i = t.operation.clone();
+    i.distance = t.signedDistance, a.updateVertices([e.handle.leftVertex, e.handle.rightVertex], i), this.outputGeometry = a.data.geometry, this._updateManipulatorPosition(this._getManipulatorInfoFromHandle(e.handle.leftVertex)), this._updateManipulatorPosition(this._getManipulatorInfoFromHandle(e.handle.rightVertex));
+  }
+  _manipulatorClickCallback(e, t) {
+    e.shiftKey || this._clearSelection(), t.type === "vertex" && (t.manipulator.selected = !t.manipulator.selected, e.button === he.Right && this._removeVertices([t])), t.type === "edge" && e.button === he.Left && this._splitEdgeManipulator(t), e.stopPropagation();
+  }
+  _updateTranslateTooltip(e, t) {
+    const a = this._manipulatorInfos.filter((i) => i.type === "vertex" && i.manipulator.selected);
+    a.length === 1 ? this._updateTranslateVertexTooltip(a[0].manipulator, e, t) : this._updateTranslateGraphicTooltip(e, t);
+  }
+  _updateTranslateGraphicTooltip(e, t) {
+    const { sketchOptions: a, tooltip: i } = this;
+    switch (e) {
+      case b.XY:
+        this._latestTooltipInfo = this._translateGraphicTooltipInfo ?? (this._translateGraphicTooltipInfo = new ot({ sketchOptions: a })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, t, (n, o) => Z(n, o));
+        break;
+      case b.XY_AXIS:
+        this._latestTooltipInfo = this._translateGraphicXYTooltipInfo ?? (this._translateGraphicXYTooltipInfo = new nt({ sketchOptions: a })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, t, (n, o) => ee(Z(n, o), oe(t)));
+        break;
+      case b.Z:
+        this._latestTooltipInfo = this._translateGraphicZTooltipInfo ?? (this._translateGraphicZTooltipInfo = new at({ sketchOptions: a })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, t, fe);
+    }
+    this._latestTooltipInfo.sketchOptions = a, i.info = a.tooltips.effectiveEnabled ? this._latestTooltipInfo : null;
+  }
+  _updateTranslateVertexTooltip(e, t, a) {
+    const { sketchOptions: i, tooltip: n } = this;
+    switch (t) {
+      case b.XY:
+        this._latestTooltipInfo = this._translateVertexTooltipInfo ?? (this._translateVertexTooltipInfo = new lt({ sketchOptions: i })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, a, (s, r) => Z(s, r)), this._updateTooltipAreaOrTotalLength(this._latestTooltipInfo);
+        break;
+      case b.XY_AXIS:
+        this._latestTooltipInfo = this._translateVertexXYTooltipInfo ?? (this._translateVertexXYTooltipInfo = new rt({ sketchOptions: i })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, a, (s, r) => ee(Z(s, r), oe(a))), this._updateTooltipAreaOrTotalLength(this._latestTooltipInfo);
+        break;
+      case b.Z:
+        this._latestTooltipInfo = this._translateVertexZTooltipInfo ?? (this._translateVertexZTooltipInfo = new st({ sketchOptions: i })), this._updateTranslateTooltipDistance(this._latestTooltipInfo, a, fe);
+    }
+    const o = ut(e.location);
+    this._latestTooltipInfo.elevation = o != null ? pt({ actual: o }) : null, this._latestTooltipInfo.sketchOptions = i, n.info = i.tooltips.effectiveEnabled ? this._latestTooltipInfo : null;
+  }
+  _updateTranslateTooltipDistance(e, t, a) {
+    if (t != null && t.action !== "end") {
+      const { mapStart: i, mapEnd: n } = t, o = a(i, n);
+      e.distance = o ?? U;
+    } else
+      e.distance = U;
+  }
+  _updateTooltipAreaOrTotalLength(e) {
+    const { geometry: t } = this.graphic;
+    if (t == null)
+      return e.area = null, void (e.totalLength = null);
+    e.area = t.type === "polygon" ? ht(t) : null, e.totalLength = t.type === "polyline" ? dt(t) : null;
+  }
+  _hideTooltip() {
+    this.tooltip.clear(), this._latestTooltipInfo = null;
+  }
+  get test() {
+    return { segmentLabels: this._segmentLabels, manipulatorInfos: this._manipulatorInfos };
+  }
+};
+function _e(e, t) {
+  return Math.atan2(t[1] - e[1], t[0] - e[0]) + Math.PI / 2;
+}
+function gt(e, t, a, i, n) {
+  if (e) {
+    const o = n.toXYZ(n.pointToVector(a)), s = ke(i, o, Ne.get()), r = ct(s, o, n.spatialReference);
+    if (r != null)
+      return te(r.value * Math.sign(t), r.unit);
+  }
+  return te(t * be(a.spatialReference), "meters");
+}
+v([x()], _.prototype, "_editGeometryOperations", void 0), v([x()], _.prototype, "_segmentLabels", void 0), v([x({ constructOnly: !0 })], _.prototype, "tool", void 0), v([x()], _.prototype, "tooltip", void 0), v([x()], _.prototype, "inputGeometry", null), v([x()], _.prototype, "outputGeometry", void 0), v([x({ readOnly: !0 })], _.prototype, "updating", null), v([x()], _.prototype, "manipulators", null), v([x()], _.prototype, "view", null), v([x()], _.prototype, "graphic", null), v([x()], _.prototype, "enableZShape", null), v([x()], _.prototype, "enableZVertex", null), v([x()], _.prototype, "enableMoveGraphic", null), v([x()], _.prototype, "enableMidpoints", null), v([x()], _.prototype, "enableEdgeOffset", null), v([x()], _.prototype, "sketchOptions", null), v([x()], _.prototype, "_accentColor", null), _ = v([Ge("esri.views.3d.interactive.editingTools.reshapeGraphic.ReshapeOperation")], _);
+const k = ve(0, 0, void 0, mt.WGS84), z = Le(), K = 1e-6;
+var T, d, D;
+(function(e) {
+  e.Vertex = ue.Custom1, e.Edge = ue.Custom2;
+})(T || (T = {})), function(e) {
+  e[e.NONE = 0] = "NONE", e[e.MOVING = 1] = "MOVING", e[e.RESHAPING = 2] = "RESHAPING";
+}(d || (d = {})), function(e) {
+  e[e.ALL = 0] = "ALL", e[e.SELECTED_OR_ALL = 1] = "SELECTED_OR_ALL";
+}(D || (D = {}));
+export {
+  _ as ReshapeOperation
+};