@agrotools1/at-components 0.6.15 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/ControlPointsTransformTool.js

@@ -0,0 +1,149 @@
+import { _ as c } from "../../../../chunks/tslib.es6.js";
+import y from "../../../../Color.js";
+import _ from "../../../../Graphic.js";
+import "../../../../symbols.js";
+import { destroyMaybe as g } from "../../../../core/maybe.js";
+import { watch as f } from "../../../../core/reactiveUtils.js";
+import { property as l } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as u } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { project as p, initializeProjection as P } from "../../../../geometry/projection.js";
+import { isValid as v } from "../../../../geometry/support/spatialReferenceUtils.js";
+import S from "../../../../layers/GraphicsLayer.js";
+import { applyCIMSymbolColor as d } from "../../../../symbols/support/cimSymbolUtils.js";
+import { ViewingMode as k } from "../../../ViewingMode.js";
+import { DragManipulation as b } from "./manipulations/DragManipulation.js";
+import { primaryKey as w } from "../../../input/keys.js";
+import { InteractiveToolBase as G } from "../../../interactive/InteractiveToolBase.js";
+import { EditGeometryOperations as M } from "../../../interactive/editGeometry/EditGeometryOperations.js";
+import { AccumulationBehavior as E } from "../../../interactive/editGeometry/interfaces.js";
+import H from "../../../../symbols/CIMSymbol.js";
+const a = { up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight", toggleOpacity: "t", shift: "Shift", primaryKey: w }, A = 1, C = 10, m = new y("#009AF2");
+let h = class extends G {
+  constructor(t) {
+    super(t), this._isOpacityToggled = !1, this._isModifierActive = !1, this._factor = 1, this._initialControlPoints = null, this._graphicsLayer = new S({ internal: !0, listMode: "hide", visible: !1, effect: "drop-shadow(0px, 0px, 3px)" }), this._undoStack = [], this._redoStack = [], this._sharedUndoStack = [], this._sharedRedoStack = [], this._highlightHandle = null, this.activeHandle = 0;
+  }
+  initialize() {
+    this._initialize();
+  }
+  destroy() {
+    const { map: t } = this.view;
+    this._controlPointManipulations.forEach((i) => i.destroy()), this._controlPointEditGeometryOperations.forEach((i) => i.destroy()), t.removeMany([this._graphicsLayer]), this._graphicsLayer.removeAll(), this._graphicsLayer = g(this._graphicsLayer), this._georeference = null, this._controlPointGraphics = null, this._controlPointManipulations = null, this._graphicsLayer = null, this._controlPointEditGeometryOperations = null, this._undoStack = null, this._redoStack = null, this._initialControlPoints = null, this._sharedUndoStack = null, this._sharedRedoStack = null;
+  }
+  get _hasValidSpatialReference() {
+    return v(this.view.spatialReference);
+  }
+  onActivate() {
+    this.visible = !0;
+  }
+  onDeactivate() {
+    this.visible = !1;
+  }
+  onShow() {
+    this._graphicsLayer.visible = !0;
+  }
+  onHide() {
+    this._graphicsLayer.visible = !1;
+  }
+  canUndo() {
+    const t = this._undoStack[this._undoStack.length - 1];
+    return t != null && this._controlPointEditGeometryOperations[t].canUndo;
+  }
+  canRedo() {
+    const t = this._redoStack[this._redoStack.length - 1];
+    return t != null && this._controlPointEditGeometryOperations[t].canRedo;
+  }
+  undo() {
+    if (this._undoStack.length > 0) {
+      const t = this._undoStack.pop();
+      this._controlPointEditGeometryOperations[t].undo(), this.updateGraphics(), this._redoStack.push(t);
+    }
+  }
+  redo() {
+    if (this._redoStack.length > 0) {
+      const t = this._redoStack.pop();
+      this._controlPointEditGeometryOperations[t].redo(), this.updateGraphics(), this._undoStack.push(t);
+    }
+  }
+  refresh() {
+    const { mediaElement: t } = this;
+    if (t.georeference == null)
+      return;
+    const i = t.georeference;
+    i.type === "control-points" && i.coords != null && (this._georeference = i, this._georeference.controlPoints.forEach(({ mapPoint: r }, e) => {
+      const o = this._controlPointEditGeometryOperations[e], s = o.data.components[0].vertices[0];
+      o.setVertexPosition(s, o.data.coordinateHelper.pointToVector(r));
+    }), this.updateGraphics());
+  }
+  reset() {
+    this._georeference.controlPoints = this._initialControlPoints, this.refresh(), this._sharedUndoStack.length = 0, this._sharedRedoStack.length = 0;
+  }
+  updateGraphics() {
+    const t = this._georeference, i = t.controlPoints, r = i[0].mapPoint.spatialReference, e = this._hasValidSpatialReference;
+    this._georeference.controlPoints = this._controlPointEditGeometryOperations.map((o, s) => {
+      const n = o.data.geometry;
+      return this._controlPointGraphics[s].geometry = n, { mapPoint: p(n, r), sourcePoint: e ? i[s].sourcePoint : t.toSource(n) };
+    });
+  }
+  updateActiveHandle(t) {
+    if (this.activeHandle === t)
+      return;
+    const i = this._controlPointGraphics[this.activeHandle].symbol.clone();
+    d(i, this.view.effectiveTheme.accentColor), this._controlPointGraphics[this.activeHandle].symbol = i;
+    const r = this._controlPointGraphics[t].symbol.clone();
+    d(r, m), this._controlPointGraphics[t].symbol = r, this.activeHandle = t, this.view.surface === document.activeElement && this.highlightActiveHandle();
+  }
+  async highlightActiveHandle() {
+    this.removeHighlightActiveHandle();
+    const t = await this.view.whenLayerView(this._graphicsLayer);
+    this._highlightHandle = t.highlight(this._controlPointGraphics[this.activeHandle]);
+  }
+  removeHighlightActiveHandle() {
+    this._highlightHandle && this._highlightHandle.remove();
+  }
+  setSharedUndoStack(t) {
+    this._sharedUndoStack = t;
+  }
+  setSharedRedoStack(t) {
+    this._sharedRedoStack = t;
+  }
+  async _initialize() {
+    const { view: t, mediaElement: i } = this;
+    if (i.georeference == null)
+      return;
+    const r = i.georeference;
+    r.type === "control-points" && r.coords != null && (this._georeference = r, this._initialControlPoints = this._georeference.controlPoints, t.map.addMany([this._graphicsLayer]), t.focus(), this.visible = !1, this.finishToolCreation(), await this._loadProjectionEngine(), this._controlPointEditGeometryOperations = this._georeference.controlPoints.map(({ mapPoint: e }) => M.fromGeometry(p(e, t.spatialReference), k.Local)), this._controlPointGraphics = this._controlPointEditGeometryOperations.map((e, o) => new _({ symbol: new H({ data: { type: "CIMSymbolReference", symbol: { type: "CIMPointSymbol", symbolLayers: [{ type: "CIMVectorMarker", enable: !0, colorLocked: !0, anchorPoint: { x: 0, y: -15.75 }, anchorPointUnits: "Absolute", dominantSizeAxis3D: "Y", size: 9, billboardMode3D: "FaceNearPlane", frame: { xmin: 0, ymin: 0, xmax: 84.3, ymax: 84.3 }, markerGraphics: [{ type: "CIMMarkerGraphic", geometry: { rings: [[[83.2, 32.5], [84.3, 40.7], [83.8, 48.9], [81.7, 56.9], [78.1, 64.3], [73, 70.9], [66.9, 76.4], [59.7, 80.5], [51.9, 83.2], [43.7, 84.3], [35.4, 83.8], [27.4, 81.7], [20, 78], [13.4, 73], [7.9, 66.8], [3.8, 59.7], [1.1, 51.9], [0, 43.7], [0.5, 35.4], [2.6, 27.4], [6.3, 20], [11.3, 13.4], [17.5, 7.9], [24.7, 3.8], [32.5, 1.1], [39.8, 0.1], [47.1, 0.3], [54.3, 1.8], [61.1, 4.5], [67.4, 8.4], [72.9, 13.3], [77.4, 19.1], [80.9, 25.5], [83.2, 32.5]]] }, symbol: { type: "CIMPolygonSymbol", symbolLayers: [{ type: "CIMSolidFill", enable: !0, color: [255, 255, 255, 255] }] } }], scaleSymbolsProportionally: !0, respectFrame: !0, clippingPath: { type: "CIMClippingPath", clippingType: "Intersect", path: { rings: [[[0, 0], [84.3, 0], [84.3, 84.3], [0, 84.3], [0, 0]]] } }, rotation: 0 }, { type: "CIMVectorMarker", enable: !0, anchorPoint: { x: 0, y: -11.25 }, anchorPointUnits: "Absolute", dominantSizeAxis3D: "Y", size: 22.5, billboardMode3D: "FaceNearPlane", frame: { xmin: 0, ymin: 0, xmax: 197.7, ymax: 294.7 }, markerGraphics: [{ type: "CIMMarkerGraphic", geometry: { rings: [[[98.9, 0], [119.4, 23.2], [139.4, 49.3], [156.8, 75.2], [171.2, 100.8], [182.4, 125.3], [190.6, 148.8], [195.7, 171.4], [197.7, 192.9], [197.7, 195.8], [197.7, 200.3], [197.6, 202.5], [197.5, 204.8], [197.3, 207.1], [197, 209.4], [196.7, 211.7], [196.4, 214.1], [196, 216.4], [195.5, 218.7], [195, 221.1], [194.4, 223.4], [193.7, 225.8], [193, 228.1], [192.2, 230.5], [191.4, 232.8], [190.5, 235.1], [189.5, 237.5], [188.5, 239.7], [187.4, 242], [186.2, 244.3], [185, 246.5], [183.7, 248.7], [182.4, 250.9], [181, 253.1], [179.5, 255.2], [178, 257.3], [176.4, 259.4], [174.7, 261.4], [173.1, 263.3], [171.3, 265.3], [169.5, 267.2], [167.7, 269], [165.8, 270.8], [163.9, 272.5], [161.9, 274.2], [159.9, 275.8], [157.8, 277.4], [155.7, 278.9], [153.6, 280.4], [151.4, 281.7], [149.2, 283.1], [147, 284.4], [144.8, 285.6], [142.5, 286.7], [140.3, 287.8], [138, 288.8], [135.7, 289.8], [133.4, 290.7], [131, 291.5], [128.7, 292.3], [126.4, 293], [124, 293.6], [121.7, 294.2], [119.4, 294.7], [117, 295.2], [114.7, 295.6], [112.4, 296], [110.1, 296.3], [107.8, 296.5], [105.5, 296.7], [103.3, 296.8], [101.1, 296.9], [98.8, 296.9], [83.1, 295.7], [67.8, 292], [53.3, 285.9], [39.9, 277.5], [28.1, 267.2], [18, 255.1], [10, 241.5], [4.2, 226.9], [0.9, 211.5], [0, 195.8], [0.1, 192.9], [2.1, 171.4], [7.2, 148.8], [15.4, 125.3], [26.6, 100.8], [41, 75.2], [58.4, 49.3], [78.4, 23.2], [98.9, 0]]] }, symbol: { type: "CIMPolygonSymbol", symbolLayers: [{ type: "CIMSolidFill", enable: !0, color: o === this.activeHandle ? m.toArray() : this.view.effectiveTheme.accentColor.toArray() }] } }], scaleSymbolsProportionally: !0, respectFrame: !0, clippingPath: { type: "CIMClippingPath", clippingType: "Intersect", path: { rings: [[[0, 0], [197.7, 0], [197.7, 294.7], [0, 294.7], [0, 0]]] } }, rotation: 0 }], haloSize: 1, scaleX: 1, angleAlignment: "Display", angle: 0 } } }), geometry: e.data.geometry })), this._graphicsLayer.graphics.addMany([...this._controlPointGraphics]), this._controlPointManipulations = this._controlPointGraphics.map((e) => new b({ tool: this, view: t, graphic: e })), this.addHandles([...this._controlPointManipulations.map((e, o) => e.createDragPipeline(this._getInfo.bind(this, o), (s, n) => {
+      s.action === "start" && (this._undoStack.push(o), this._redoStack = [], this._sharedUndoStack.push({ tool: this, operation: n }), this._sharedRedoStack.length = 0), this.updateGraphics();
+    })), f(() => this.view.scale, () => this.active ? this.updateGraphics() : null)]), this._controlPointManipulations.forEach((e, o) => {
+      const s = (n) => {
+        this.addHandles([n.events.on(["click", "grab-changed"], (x) => this.updateActiveHandle(o))]);
+      };
+      e.forEachManipulator(s);
+    }), this.addHandles([t.on("key-down", (e) => {
+      t.activeTool === this && (e.key !== a.shift || e.repeat || (this._isModifierActive = !0, e.stopPropagation()), e.key !== a.toggleOpacity || e.repeat || (i.opacity *= this._isOpacityToggled ? 2 : 0.5, this._isOpacityToggled = !this._isOpacityToggled, e.stopPropagation()), e.key !== a.primaryKey || e.repeat || (this._factor = C, e.stopPropagation()), this._isModifierActive && (e.key === a.up && (this._move(0, this._factor), e.stopPropagation()), e.key === a.down && (this._move(0, -this._factor), e.stopPropagation()), e.key === a.left && (this._move(-this._factor, 0), e.stopPropagation()), e.key === a.right && (this._move(this._factor, 0), e.stopPropagation())));
+    }), t.on("key-up", (e) => {
+      t.activeTool === this && (e.key === a.shift && (this._isModifierActive = !1, e.stopPropagation()), e.key === a.primaryKey && (this._factor = A, e.stopPropagation()));
+    })]));
+  }
+  async _loadProjectionEngine() {
+    const t = this._georeference.controlPoints[0].mapPoint;
+    return P(t.spatialReference, this.view.spatialReference);
+  }
+  _getInfo(t) {
+    return { editGeometryOperations: this._controlPointEditGeometryOperations[t], constraints: this._hasValidSpatialReference ? null : { xmin: 0, ymin: 0, xmax: this._georeference.width, ymax: this._georeference.height } };
+  }
+  _move(t, i) {
+    const r = this._controlPointEditGeometryOperations[this.activeHandle], e = [];
+    for (const s of r.data.components)
+      e.push(...s.vertices);
+    const o = r.moveVertices(e, t * this.view.resolution, i * this.view.resolution, 0, E.NEW_STEP);
+    this._sharedUndoStack.push({ tool: this, operation: o }), this._sharedRedoStack.length = 0, this.updateGraphics();
+  }
+};
+c([l()], h.prototype, "_hasValidSpatialReference", null), c([l()], h.prototype, "activeHandle", void 0), c([l({ constructOnly: !0, nonNullable: !0 })], h.prototype, "mediaElement", void 0), c([l({ constructOnly: !0 })], h.prototype, "view", void 0), h = c([u("esri.views.2d.interactive.editingTools.ControlPointsTransformTool")], h);
+export {
+  h as ControlPointsTransformTool,
+  a as keys
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/MediaTransformToolsWrapper.js

@@ -0,0 +1,78 @@
+import { _ as i } from "../../../../chunks/tslib.es6.js";
+import f from "../../../../core/Accessor.js";
+import { watch as h } from "../../../../core/reactiveUtils.js";
+import { property as r } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as u } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { ControlPointsTransformTool as m } from "./ControlPointsTransformTool.js";
+import { TransformTool as y } from "./TransformTool.js";
+const d = { redo: "r", undo: "z" };
+let s = class extends f {
+  constructor(e) {
+    super(e), this._transformTool = null, this._controlPointsTransformTool = null, this._advancedModeTransformTool = null, this._activeTool = null, this._sharedUndoStack = [], this._sharedRedoStack = [], this._originalOpacity = null, this.activeHandle = 0;
+  }
+  initialize() {
+    const { view: e, mediaElement: o, preserveAspectRatio: a, snapRotation: v, advancedMode: n } = this;
+    this._originalOpacity = o.opacity, this._transformTool = new y({ target: o, view: e, preserveAspectRatio: a, snapRotation: v }), this._controlPointsTransformTool = new m({ mediaElement: o, view: e }), this._advancedModeTransformTool = new m({ mediaElement: n.mediaElement, view: n.view }), this._transformTool.setSharedUndoStack(this._sharedUndoStack), this._transformTool.setSharedRedoStack(this._sharedRedoStack), this._controlPointsTransformTool.setSharedUndoStack(this._sharedUndoStack), this._controlPointsTransformTool.setSharedRedoStack(this._sharedRedoStack), this._advancedModeTransformTool.setSharedUndoStack(this._sharedUndoStack), this._advancedModeTransformTool.setSharedRedoStack(this._sharedRedoStack);
+    const l = o.georeference, c = n.mediaElement.georeference;
+    n.view.tools.addMany([this._advancedModeTransformTool]), "controlPoints" in c && "controlPoints" in l && this.addHandles([n.view.on("key-down", (t) => {
+      t.key === d.undo && this.canUndo() && (this.undo(), t.stopPropagation()), t.key === d.redo && this.canRedo() && (this.redo(), t.stopPropagation());
+    }), n.view.on("focus", async (t) => {
+      this._controlPointsTransformTool.removeHighlightActiveHandle(), this._advancedModeTransformTool.highlightActiveHandle();
+    }), h(() => c.controlPoints, (t) => {
+      var T;
+      l.controlPoints = t.map(({ sourcePoint: _ }, p) => ({ sourcePoint: _, mapPoint: l.controlPoints[p].mapPoint })), (T = this._activeTool) == null || T.refresh();
+    }), h(() => this._controlPointsTransformTool.activeHandle, (t) => {
+      this._advancedModeTransformTool.updateActiveHandle(t), this.activeHandle = t;
+    }), h(() => this._advancedModeTransformTool.activeHandle, (t) => {
+      this._controlPointsTransformTool.updateActiveHandle(t), this.activeHandle = t;
+    })]), this.addHandles([e.on("key-down", (t) => {
+      t.key === d.undo && this.canUndo() && (this.undo(), t.stopPropagation()), t.key === d.redo && this.canRedo() && (this.redo(), t.stopPropagation());
+    }), e.on("focus", async (t) => {
+      this._advancedModeTransformTool.removeHighlightActiveHandle(), this._controlPointsTransformTool.highlightActiveHandle();
+    })]), e.tools.addMany([this._transformTool, this._controlPointsTransformTool]), e.activeTool = this._transformTool, this._activeTool = this._transformTool, e.focus();
+  }
+  destroy() {
+    var e, o;
+    (e = this._transformTool) == null || e.destroy(), (o = this._controlPointsTransformTool) == null || o.destroy(), this._transformTool = null, this._controlPointsTransformTool = null, this._advancedModeTransformTool = null, this._activeTool = null, this._sharedUndoStack = null, this._sharedRedoStack = null;
+  }
+  canUndo() {
+    return this._sharedUndoStack.length > 0;
+  }
+  canRedo() {
+    return this._sharedRedoStack.length > 0;
+  }
+  undo() {
+    var e;
+    if (this._sharedUndoStack.length > 0) {
+      const { tool: o, operation: a } = this._sharedUndoStack.pop();
+      o !== this._activeTool && o.refresh(), a.undo(), o.updateGraphics(), this._sharedRedoStack.push({ tool: o, operation: a }), this._activeTool !== o && ((e = this._activeTool) == null || e.refresh());
+    }
+  }
+  redo() {
+    var e;
+    if (this._sharedRedoStack.length > 0) {
+      const { tool: o, operation: a } = this._sharedRedoStack.pop();
+      o !== this._activeTool && o.refresh(), a.apply(), o.updateGraphics(), this._sharedUndoStack.push({ tool: o, operation: a }), this._activeTool !== o && ((e = this._activeTool) == null || e.refresh());
+    }
+  }
+  refresh() {
+    this._activeTool.refresh();
+  }
+  reset() {
+    this._activeTool.reset(), this._advancedModeTransformTool.reset();
+  }
+  async enableAdvancedMode() {
+    this.view.activeTool = this._controlPointsTransformTool, this._activeTool = this._controlPointsTransformTool, this._activeTool.refresh(), await this.advancedMode.view.when(), this.advancedMode.view.activeTool = this._advancedModeTransformTool, this._originalOpacity = this._controlPointsTransformTool.mediaElement.opacity, this._controlPointsTransformTool.mediaElement.opacity = 0.25 * this._originalOpacity;
+  }
+  disableAdvancedMode() {
+    this.view.activeTool = this._transformTool, this._activeTool = this._transformTool, this._activeTool.refresh(), this.advancedMode.view.activeTool = null, this._controlPointsTransformTool.mediaElement.opacity = this._originalOpacity;
+  }
+};
+i([r()], s.prototype, "activeHandle", void 0), i([r({ constructOnly: !0 })], s.prototype, "advancedMode", void 0), i([r()], s.prototype, "preserveAspectRatio", void 0), i([r()], s.prototype, "snapRotation", void 0), i([r({ constructOnly: !0, nonNullable: !0 })], s.prototype, "mediaElement", void 0), i([r({ constructOnly: !0 })], s.prototype, "view", void 0), s = i([u("esri.views.2d.interactive.editingTools.MediaTransformToolsWrapper")], s);
+export {
+  s as MediaTransformToolsWrapper,
+  d as keys
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/TransformTool.js

@@ -0,0 +1,218 @@
+import { _ as l } from "../../../../chunks/tslib.es6.js";
+import "../../../../geometry.js";
+import g from "../../../../Graphic.js";
+import "../../../../symbols.js";
+import { getContrast as R } from "../../../../core/colorUtils.js";
+import { destroyMaybe as O } from "../../../../core/maybe.js";
+import { watch as x } from "../../../../core/reactiveUtils.js";
+import { getMetersPerUnitForSR as b } from "../../../../core/unitUtils.js";
+import { property as d } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as D } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { subtract as E, normalize as B } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as L, UNIT_X as U } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { h as G, l as A, n as H, g as u, m as f, f as v } from "../../../../chunks/vec32.js";
+import { create as _ } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { project as P, initializeProjection as z } from "../../../../geometry/projection.js";
+import { a as k, c as I } from "../../../../chunks/boundedPlane.js";
+import { equals as V } from "../../../../geometry/support/spatialReferenceUtils.js";
+import j from "../../../../layers/GraphicsLayer.js";
+import { ViewingMode as C } from "../../../ViewingMode.js";
+import { DragManipulation as F } from "./manipulations/DragManipulation.js";
+import { RotateManipulation as N } from "./manipulations/RotateManipulation.js";
+import { ScaleManipulation as W } from "./manipulations/ScaleManipulation.js";
+import { PreserveAspectRatio as K, SnapRotation as q } from "./manipulations/utils.js";
+import { primaryKey as X } from "../../../input/keys.js";
+import { InteractiveToolBase as J } from "../../../interactive/InteractiveToolBase.js";
+import { EditGeometry as Q } from "../../../interactive/editGeometry/EditGeometry.js";
+import { EditGeometryOperations as Y } from "../../../interactive/editGeometry/EditGeometryOperations.js";
+import { AccumulationBehavior as M } from "../../../interactive/editGeometry/interfaces.js";
+import { AccumulationType as Z } from "../../../interactive/editGeometry/operations/UpdateVertices.js";
+import { calculateOrientedBounds as ee } from "../../../interactive/editGeometry/support/editPlaneUtils.js";
+import { findFirstGraphicHit as te } from "../../../support/hitTestSelectUtils.js";
+import { createScreenPointFromEvent as ie } from "../../../support/screenUtils.js";
+import se from "../../../../geometry/Polygon.js";
+import m from "../../../../geometry/Point.js";
+import oe from "../../../../symbols/SimpleFillSymbol.js";
+import T from "../../../../symbols/SimpleMarkerSymbol.js";
+const h = { up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight", plus: "+", minus: "-", toggleOpacity: "t", shift: "Shift", primaryKey: X }, ae = 80, re = 10, ne = 30, he = [[1, 1], [1, -1], [-1, -1], [-1, 1], [1, 0], [0, -1], [-1, 0], [0, 1]], ce = 1, pe = 10;
+let c = class extends J {
+  constructor(t) {
+    super(t), this._initialControlPoints = null, this._initialGeometry = null, this._graphic = null, this._planeCache = k(), this._displayPlaneCache = k(), this._mainAxisCache = L(), this._rotationHandleCache = _(), this._cornerA = _(), this._cornerB = _(), this._cornerC = _(), this._cornerD = _(), this._avgAB = _(), this._avgBC = _(), this._avgCD = _(), this._avgDA = _(), this._preserveAspectRatio = new K(), this._snapRotation = new q(), this._graphicsLayer = new j({ internal: !0, listMode: "hide", visible: !1 }), this._sharedUndoStack = [], this._sharedRedoStack = [], this._isOpacityToggled = !1, this._isModifierActive = !1, this._factor = 1, this.preserveAspectRatio = null, this.snapRotation = null;
+  }
+  initialize() {
+    this._initialize();
+  }
+  destroy() {
+    const { map: t } = this.view;
+    this._dragManipulation.destroy(), this._rotateManipulation.destroy(), this._scaleManipulations.forEach((e) => e.destroy()), this._editGeometryOperations.destroy(), t.removeMany([this._graphicsLayer]), this._graphicsLayer.removeAll(), this._graphicsLayer = O(this._graphicsLayer), this._initialControlPoints = null, this._initialGeometry = null, this._graphic = null, this._preserveAspectRatio = null, this._snapRotation = null, this._planeCache = null, this._displayPlaneCache = null, this._rotationHandleCache = null, this._mainAxisCache = null, this._cornerA = null, this._cornerB = null, this._cornerC = null, this._cornerD = null, this._avgAB = null, this._avgBC = null, this._avgCD = null, this._avgDA = null, this._sharedUndoStack = null, this._sharedRedoStack = null;
+  }
+  get _plane() {
+    const t = this._graphic.geometry;
+    if (t == null)
+      return null;
+    const e = this._editGeometryOperations.data, s = e.components[0].edges[0], i = E(this._mainAxisCache, s.leftVertex.pos, s.rightVertex.pos);
+    B(i, i);
+    let o = ae * this.view.resolution;
+    const a = this.view.spatialReference;
+    return V(a, t.spatialReference) && (o *= b(a) / b(t.spatialReference)), ee(i, e, o, this._planeCache);
+  }
+  get _displayPlane() {
+    const t = this._plane;
+    if (!t)
+      return null;
+    const e = this._displayPlaneCache;
+    I(t, e);
+    const s = re * this.view.resolution;
+    return G(e.basis1, e.basis1, 1 + s / A(e.basis1)), G(e.basis2, e.basis2, 1 + s / A(e.basis2)), e;
+  }
+  get _backgroundGraphicGeometry() {
+    const t = this._displayPlane;
+    if (!t)
+      return null;
+    const e = this.view.spatialReference;
+    return this._updateDisplayPlaneConrers(t), new se({ spatialReference: e, rings: [[this._cornerA, this._cornerB, this._cornerC, this._cornerD, this._cornerA]] });
+  }
+  get _rotateGraphicGeometry() {
+    const t = this._plane;
+    if (!t)
+      return null;
+    const e = this._rotationHandleCache;
+    return H(e, t.basis1), G(e, e, ne * this.view.resolution), u(e, e, t.origin), u(e, e, t.basis1), new m({ x: e[0], y: e[1], spatialReference: this.view.spatialReference });
+  }
+  get _scaleGraphicGeometries() {
+    const t = this._displayPlane;
+    if (!t)
+      return [];
+    const e = this.view.spatialReference;
+    this._updateDisplayPlaneConrers(t);
+    const { _cornerA: s, _cornerB: i, _cornerC: o, _cornerD: a } = this, r = f(this._avgAB, s, i, 0.5), n = f(this._avgBC, i, o, 0.5), p = f(this._avgCD, o, a, 0.5), y = f(this._avgDA, a, s, 0.5);
+    return [new m({ x: s[0], y: s[1], spatialReference: e }), new m({ x: i[0], y: i[1], spatialReference: e }), new m({ x: o[0], y: o[1], spatialReference: e }), new m({ x: a[0], y: a[1], spatialReference: e }), new m({ x: r[0], y: r[1], spatialReference: e }), new m({ x: n[0], y: n[1], spatialReference: e }), new m({ x: p[0], y: p[1], spatialReference: e }), new m({ x: y[0], y: y[1], spatialReference: e })];
+  }
+  onActivate() {
+    this.visible = !0;
+  }
+  onDeactivate() {
+    this.visible = !1;
+  }
+  onShow() {
+    this._graphicsLayer.visible = !0;
+  }
+  onHide() {
+    this._graphicsLayer.visible = !1;
+  }
+  canUndo() {
+    return this._editGeometryOperations.canUndo;
+  }
+  canRedo() {
+    return this._editGeometryOperations.canRedo;
+  }
+  undo() {
+    this._editGeometryOperations.undo(), this.updateGraphics();
+  }
+  redo() {
+    this._editGeometryOperations.redo(), this.updateGraphics();
+  }
+  refresh() {
+    const { view: t, target: e } = this, s = "georeference" in e ? e.georeference.coords : e.geometry, i = this._editGeometryOperations, o = i.data.components[0].vertices, a = Q.fromGeometry(P(s, t.spatialReference), C.Local).components[0].vertices;
+    o.forEach((r, n) => {
+      i.setVertexPosition(r, a[n].pos);
+    }), this.updateGraphics();
+  }
+  reset() {
+    const { target: t } = this;
+    if ("georeference" in t) {
+      const e = t.georeference;
+      e.type === "control-points" && (e.controlPoints = this._initialControlPoints);
+    } else
+      t.geometry = this._initialGeometry;
+    this.refresh(), this._sharedUndoStack.length = 0, this._sharedRedoStack.length = 0;
+  }
+  updateGraphics() {
+    const t = this._editGeometryOperations.data.geometry;
+    "georeference" in this.target && (this.target.georeference.coords = t), this._graphic.geometry = t, this._backgroundGraphic.geometry = this._backgroundGraphicGeometry, this._rotateGraphic.geometry = this._rotateGraphicGeometry, this._scaleGraphicGeometries.forEach((e, s) => {
+      this._scaleGraphics[s].geometry = e;
+    });
+  }
+  setSharedUndoStack(t) {
+    this._sharedUndoStack = t;
+  }
+  setSharedRedoStack(t) {
+    this._sharedRedoStack = t;
+  }
+  async _initialize() {
+    const { view: t, target: e } = this;
+    if ("georeference" in e) {
+      const i = e.georeference;
+      this._graphic = new g({ geometry: i.coords }), this._initialControlPoints = i.type === "control-points" ? i.controlPoints : null;
+    } else
+      this._graphic = e, this._initialGeometry = e.geometry;
+    t.map.addMany([this._graphicsLayer]), t.focus(), this.visible = !1, this.finishToolCreation(), await this._loadProjectionEngine(), this._editGeometryOperations = Y.fromGeometry(P(this._graphic.geometry, t.spatialReference), C.Local), this._backgroundGraphic = new g({ symbol: new oe({ color: "transparent", outline: { type: "simple-line", color: t.effectiveTheme.accentColor, width: 2 } }), geometry: this._backgroundGraphicGeometry }), this._rotateGraphic = new g({ symbol: new T({ color: R(t.effectiveTheme.accentColor), outline: { type: "simple-line", color: t.effectiveTheme.accentColor, width: 1 } }), geometry: this._rotateGraphicGeometry }), this._scaleGraphics = this._scaleGraphicGeometries.map((i) => new g({ symbol: new T({ size: 6, style: "square", color: R(t.effectiveTheme.accentColor), outline: { type: "simple-line", color: t.effectiveTheme.accentColor, width: 1 } }), geometry: i })), this._graphicsLayer.graphics.addMany([this._backgroundGraphic, this._rotateGraphic, ...this._scaleGraphics]), this._dragManipulation = new F({ tool: this, view: t, graphic: this._graphic }), this._rotateManipulation = new N({ tool: this, view: t, graphic: this._rotateGraphic, snapRotation: this._snapRotation }), this._scaleManipulations = this._scaleGraphics.map((i, o) => new W({ tool: this, view: t, graphic: i, direction: he[o], preserveAspectRatio: this._preserveAspectRatio })), this.addHandles([this._dragManipulation.createDragPipeline(this._getInfo.bind(this), this._updateGraphics.bind(this)), this._rotateManipulation.createDragPipeline(this._getInfo.bind(this), this._updateGraphics.bind(this)), ...this._scaleManipulations.map((i) => i.createDragPipeline(this._getInfo.bind(this), this._updateGraphics.bind(this))), x(() => this.view.scale, () => this.active ? this.updateGraphics() : null), t.on("click", async (i) => {
+      if (t.activeTool != null && t.activeTool !== this)
+        return;
+      const o = ie(i), a = [];
+      t.map.allLayers.forEach((p) => {
+        p.type !== "vector-tile" && p.type !== "imagery" || a.push(p);
+      });
+      const r = await this.view.hitTest(o, { exclude: a }), n = r.results;
+      if (n.length === 0)
+        t.activeTool = null;
+      else {
+        const p = te(r.results), y = "georeference" in e, S = n.map((w) => w.type === "media" ? w.element : null).filter(Boolean), $ = new Set([...this._graphicsLayer.graphics, y ? null : e].filter(Boolean));
+        y && S.includes(e) || p != null && $.has(p.graphic) ? t.activeTool == null && (t.activeTool = this) : t.activeTool = null;
+      }
+    })]);
+    const s = (i) => {
+      this.addHandles(i.events.on("grab-changed", (o) => {
+        "georeference" in e && (o.action === "start" ? e.opacity *= 0.5 : o.action === "end" && (e.opacity *= 2));
+      }));
+    };
+    this._dragManipulation.forEachManipulator(s), this._rotateManipulation.forEachManipulator(s), this._scaleManipulations.forEach((i) => i.forEachManipulator(s)), this.addHandles([t.on("key-down", (i) => {
+      t.activeTool === this && (i.key !== h.shift || i.repeat || (this.preserveAspectRatio == null && (this._preserveAspectRatio.enabled = !this._preserveAspectRatio.enabled), this.snapRotation == null && (this._snapRotation.enabled = !this._snapRotation.enabled), this._isModifierActive = !0, i.stopPropagation()), i.key !== h.toggleOpacity || i.repeat || ("georeference" in e && (e.opacity *= this._isOpacityToggled ? 2 : 0.5, this._isOpacityToggled = !this._isOpacityToggled), i.stopPropagation()), i.key !== h.primaryKey || i.repeat || (this._factor = pe, i.stopPropagation()), this._isModifierActive && (i.key === h.plus && (this._scale(this._factor), i.stopPropagation()), i.key === h.minus && (this._scale(-this._factor), i.stopPropagation()), i.key === h.up && (this._move(0, this._factor), i.stopPropagation()), i.key === h.down && (this._move(0, -this._factor), i.stopPropagation()), i.key === h.left && (this._move(-this._factor, 0), i.stopPropagation()), i.key === h.right && (this._move(this._factor, 0), i.stopPropagation())));
+    }), t.on("key-up", (i) => {
+      t.activeTool === this && (i.key === h.shift && (this.preserveAspectRatio == null && (this._preserveAspectRatio.enabled = !this._preserveAspectRatio.enabled), this.snapRotation == null && (this._snapRotation.enabled = !this._snapRotation.enabled), this._isModifierActive = !1, i.stopPropagation()), i.key === h.primaryKey && (this._factor = ce, i.stopPropagation()));
+    })]);
+  }
+  async _loadProjectionEngine() {
+    const t = this._graphic.geometry;
+    return z(t.spatialReference, this.view.spatialReference);
+  }
+  _updateDisplayPlaneConrers(t) {
+    const { basis1: e, basis2: s, origin: i } = t, o = this._cornerA;
+    u(o, i, e), u(o, o, s);
+    const a = this._cornerB;
+    u(a, i, e), v(a, a, s);
+    const r = this._cornerC;
+    v(r, i, e), v(r, r, s);
+    const n = this._cornerD;
+    v(n, i, e), u(n, n, s);
+  }
+  _getInfo() {
+    return { editGeometryOperations: this._editGeometryOperations, plane: this._plane, displayPlane: this._displayPlane };
+  }
+  _updateGraphics(t, e) {
+    t.action === "start" && (this._sharedUndoStack.push({ tool: this, operation: e }), this._sharedRedoStack.length = 0), this.updateGraphics();
+  }
+  _scale(t) {
+    var r;
+    const e = this._editGeometryOperations, s = [];
+    for (const n of e.data.components)
+      s.push(...n.vertices);
+    const i = (r = e.data.geometry.extent) == null ? void 0 : r.width, o = (i + t * this.view.resolution) / i, a = e.scaleVertices(s, this._plane.origin, U, o, o, M.NEW_STEP, Z.REPLACE);
+    this._sharedUndoStack.push({ tool: this, operation: a }), this._sharedRedoStack.length = 0, this.updateGraphics();
+  }
+  _move(t, e) {
+    const s = this._editGeometryOperations, i = [];
+    for (const a of s.data.components)
+      i.push(...a.vertices);
+    const o = s.moveVertices(i, t * this.view.resolution, e * this.view.resolution, 0, M.NEW_STEP);
+    this._sharedUndoStack.push({ tool: this, operation: o }), this._sharedRedoStack.length = 0, this.updateGraphics();
+  }
+};
+l([d()], c.prototype, "_plane", null), l([d()], c.prototype, "_backgroundGraphicGeometry", null), l([d()], c.prototype, "_rotateGraphicGeometry", null), l([d()], c.prototype, "_scaleGraphicGeometries", null), l([d()], c.prototype, "preserveAspectRatio", void 0), l([d()], c.prototype, "snapRotation", void 0), l([d({ constructOnly: !0, nonNullable: !0 })], c.prototype, "target", void 0), l([d({ constructOnly: !0 })], c.prototype, "view", void 0), c = l([D("esri.views.2d.interactive.editingTools.TransformTool")], c);
+export {
+  c as TransformTool,
+  h as keys
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/draw/DrawGraphicTool2D.js

@@ -0,0 +1,70 @@
+import { _ as l } from "../../../../../chunks/tslib.es6.js";
+import "../../../../../geometry.js";
+import o from "../../../../../Graphic.js";
+import { makeHandle as a } from "../../../../../core/handleUtils.js";
+import { destroyMaybe as c } from "../../../../../core/maybe.js";
+import { watch as m, initial as p } from "../../../../../core/reactiveUtils.js";
+import { property as h } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/has.js";
+import "../../../../../core/Logger.js";
+import "../../../../../core/RandomLCG.js";
+import { subclass as u } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { SnappingVisualizer2D as v } from "../../SnappingVisualizer2D.js";
+import { outline as y, regularVertices as d, activeVertex as g } from "./symbols.js";
+import { DrawGraphicTool as E, geometryTypeToDrawOperationGeometryType as G } from "../../../../draw/DrawGraphicTool.js";
+import { DrawOperation as _ } from "../../../../draw/DrawOperation.js";
+import { MapDrawSurface as V } from "../../../../draw/drawSurfaces.js";
+import b from "../../../../../geometry/Point.js";
+import f from "../../../../../geometry/Multipoint.js";
+let s = class extends E {
+  constructor(e) {
+    super(e), this._visualElementGraphics = { regularVertices: null, activeVertex: null, activeEdge: null }, this.activeFillSymbol = null, this.type = "draw-2d", this._visualElementSymbols = { outline: e.activeLineSymbol ?? y, regularVertices: e.regularVerticesSymbol ?? d, activeVertex: e.activeVertexSymbol ?? g, fill: e.activeFillSymbol }, e.activeVertexSymbol || this.addHandles(m(() => {
+      var t, i;
+      return (i = (t = this.view) == null ? void 0 : t.effectiveTheme) == null ? void 0 : i.accentColor;
+    }, (t) => {
+      var r;
+      if (!t)
+        return;
+      const i = this._visualElementSymbols.activeVertex.clone().set({ color: t });
+      (r = this._visualElementGraphics.activeVertex) == null || r.set("symbol", i), this._visualElementSymbols = { ...this._visualElementSymbols, activeVertex: i };
+    }, p));
+  }
+  normalizeCtorArgs(e) {
+    const t = { ...e };
+    return delete t.activeFillSymbol, delete t.activeVertexSymbol, delete t.regularVerticesSymbol, delete t.activeLineSymbol, t;
+  }
+  initializeGraphic(e) {
+    return this._visualElementSymbols.fill != null && (e.symbol = this._visualElementSymbols.fill), this.internalGraphicsLayer.graphics.sort(n), a();
+  }
+  makeDrawOperation() {
+    const { defaultZ: e, hasZ: t, view: i } = this;
+    return this._createOrUpdateGraphic(null), new _({ view: i, manipulators: this.manipulators, geometryType: G(this.geometryType), drawingMode: this.mode, hasZ: t, defaultZ: e, snapToSceneEnabled: this.snapToScene, drawSurface: new V(i, t, e), hasM: !1, snappingManager: this.snappingManager, snappingVisualizer: new v(this.internalGraphicsLayer), graphic: this.graphic, cursor: this.cursor, constraintsEnabled: !0 });
+  }
+  onActiveVertexChanged(e) {
+    if (this.geometryType === "point")
+      return a();
+    const [t, i] = e, r = new b({ x: t, y: i, spatialReference: this.view.spatialReference });
+    return this._visualElementGraphics.activeVertex != null ? (this._visualElementGraphics.activeVertex.geometry = r, a()) : (this._visualElementGraphics.activeVertex = new o({ geometry: r, symbol: this._visualElementSymbols.activeVertex, attributes: { displayOrder: 2 } }), this.internalGraphicsLayer.add(this._visualElementGraphics.activeVertex), this.internalGraphicsLayer.graphics.sort(n), a(() => {
+      this._visualElementGraphics.activeVertex != null && (this.internalGraphicsLayer.remove(this._visualElementGraphics.activeVertex), this._visualElementGraphics.activeVertex = c(this._visualElementGraphics.activeVertex));
+    }));
+  }
+  onCursorEdgeChanged(e) {
+    return this._visualElementGraphics.activeEdge != null ? (this._visualElementGraphics.activeEdge.geometry = e, a()) : (this._visualElementGraphics.activeEdge = new o({ geometry: e, symbol: this._visualElementSymbols.outline, attributes: { displayOrder: 0 } }), this.internalGraphicsLayer.add(this._visualElementGraphics.activeEdge), this.internalGraphicsLayer.graphics.sort(n), a(() => {
+      this._visualElementGraphics.activeEdge != null && (this.internalGraphicsLayer.remove(this._visualElementGraphics.activeEdge), this._visualElementGraphics.activeEdge = c(this._visualElementGraphics.activeEdge));
+    }));
+  }
+  onRegularVerticesChanged(e) {
+    const t = new f({ points: e, spatialReference: this.view.spatialReference });
+    return this._visualElementGraphics.regularVertices != null ? (this._visualElementGraphics.regularVertices.geometry = t, a()) : (this._visualElementGraphics.regularVertices = new o({ geometry: t, symbol: this._visualElementSymbols.regularVertices, attributes: { displayOrder: 1 } }), this.internalGraphicsLayer.add(this._visualElementGraphics.regularVertices), this.internalGraphicsLayer.graphics.sort(n), a(() => {
+      this._visualElementGraphics.regularVertices != null && (this.internalGraphicsLayer.remove(this._visualElementGraphics.regularVertices), this._visualElementGraphics.regularVertices = c(this._visualElementGraphics.regularVertices));
+    }));
+  }
+};
+function n(e, t) {
+  var i, r;
+  return (((i = e.attributes) == null ? void 0 : i.displayOrder) ?? -1 / 0) - (((r = t.attributes) == null ? void 0 : r.displayOrder) ?? -1 / 0);
+}
+l([h()], s.prototype, "activeFillSymbol", void 0), l([h({ readOnly: !0 })], s.prototype, "type", void 0), l([h({ constructOnly: !0, nonNullable: !0 })], s.prototype, "view", void 0), s = l([u("esri.views.2d.interactive.draw.DrawGraphicTool2D")], s);
+export {
+  s as DrawGraphicTool2D
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/draw/symbols.js

@@ -0,0 +1,9 @@
+import "../../../../../symbols.js";
+import t from "../../../../../symbols/CIMSymbol.js";
+import e from "../../../../../symbols/SimpleMarkerSymbol.js";
+const r = new t({ data: { type: "CIMSymbolReference", symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMSolidStroke", effects: [{ type: "CIMGeometricEffectDashes", dashTemplate: [3.75, 3.75], lineDashEnding: "HalfPattern", controlPointEnding: "NoConstraint" }], enable: !0, capStyle: "Butt", joinStyle: "Round", miterLimit: 10, width: 1.6, color: [255, 255, 255, 255] }, { type: "CIMSolidStroke", enable: !0, capStyle: "Butt", joinStyle: "Round", miterLimit: 10, width: 2, color: [0, 0, 0, 255] }] } } }), n = new e({ style: "circle", size: 6, color: [127, 127, 127, 1], outline: { color: [50, 50, 50], width: 1 } }), c = new e({ style: "circle", size: 6, color: [255, 127, 0, 1], outline: { color: [50, 50, 50], width: 1 } });
+export {
+  c as activeVertex,
+  r as outline,
+  n as regularVertices
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/manipulations/DragManipulation.js

@@ -0,0 +1,50 @@
+import { Manipulation as S, ManipulatorType as w } from "./Manipulation.js";
+import { createManipulatorDragEventPipeline as T, screenToMap as A } from "../../../../interactive/dragEventPipeline.js";
+import { GraphicManipulator as P } from "../../../../interactive/GraphicManipulator.js";
+import { AccumulationBehavior as f } from "../../../../interactive/editGeometry/interfaces.js";
+import { getSymbolInfo as b } from "../../../../interactive/support/utils.js";
+class X extends S {
+  constructor(t) {
+    super(), this._view = t.view, this._tool = t.tool, this._graphic = t.graphic, this._manipulator = this._createManipulator(), this.forEachManipulator((o) => this._tool.manipulators.add(o));
+  }
+  destroy() {
+    this.forEachManipulator((t) => {
+      this._tool.manipulators.remove(t), t.destroy();
+    }), this._tool = null, this._view = null, this._manipulator = null, this._graphic = null;
+  }
+  forEachManipulator(t) {
+    t(this._manipulator, w.TRANSLATE_XY);
+  }
+  createDragPipeline(t, o) {
+    let p = null, i = null, s = 0, n = 0, e = 0;
+    const { offsetX: c, offsetY: u, size: m } = b(this._graphic.symbol);
+    return T(this._manipulator, (D, v) => {
+      v.next((a) => {
+        if (a.action === "start") {
+          const r = t();
+          p = r.editGeometryOperations, i = r.constraints;
+        }
+        return a;
+      }).next(A(this._view)).next((a) => {
+        const { x: r, y: l, z: h } = a.mapEnd;
+        if (i && (r + c < i.xmin || l + u - m < i.ymin || r + c > i.xmax || l + u - m > i.ymax))
+          return a;
+        (a.action === "start" || s === 0 && n === 0 && e === 0) && (s = a.mapStart.x, n = a.mapStart.y, e = a.mapStart.z);
+        const x = r - s, E = l - n, M = h - e;
+        s = r, n = l, e = h;
+        const _ = [];
+        for (const d of p.data.components)
+          _.push(...d.vertices);
+        const g = a.action === "start" ? f.NEW_STEP : f.ACCUMULATE_STEPS, y = p.moveVertices(_, x, E, M, g);
+        return o(a, y), a;
+      });
+    });
+  }
+  _createManipulator() {
+    const t = this._view, o = this._graphic;
+    return new P({ view: t, graphic: o, selectable: !0, cursor: "move" });
+  }
+}
+export {
+  X as DragManipulation
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/interactive/editingTools/manipulations/Manipulation.js

@@ -0,0 +1,28 @@
+class o {
+  get hovering() {
+    return this.someManipulator((a) => a.hovering);
+  }
+  get grabbing() {
+    return this.someManipulator((a) => a.grabbing);
+  }
+  get dragging() {
+    return this.someManipulator((a) => a.dragging);
+  }
+  hasManipulator(a) {
+    return this.someManipulator((n) => n === a);
+  }
+  someManipulator(a) {
+    let n = !1;
+    return this.forEachManipulator((i) => {
+      !n && a(i) && (n = !0);
+    }), n;
+  }
+}
+var r;
+(function(t) {
+  t[t.TRANSLATE_XY = 0] = "TRANSLATE_XY", t[t.SCALE = 1] = "SCALE", t[t.ROTATE = 2] = "ROTATE";
+})(r || (r = {}));
+export {
+  o as Manipulation,
+  r as ManipulatorType
+};