@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/draw/drawSurfaces.js

@@ -1,45 +1,71 @@
 import "../../geometry.js";
-import { createScreenPointArray as a } from "../../core/screenUtils.js";
-import { makeDehydratedPoint as o } from "../../layers/graphics/dehydratedPoint.js";
-import { clonePoint as l } from "../../layers/graphics/hydratedFeatures.js";
-import { getConvertedElevation as r, getZForElevationMode as c } from "../../support/elevationInfoUtils.js";
-import u from "../../geometry/SpatialReference.js";
-import "../../geometry/Point.js";
-class x {
-  constructor(e, t, i, n = null) {
-    this._elevationInfo = e, this.defaultZ = t, this._view = i, this._excludeGraphics = n;
+import { createScreenPointArray as u, createScreenPoint as h } from "../../core/screenUtils.js";
+import { makeDehydratedPoint as a } from "../../layers/graphics/dehydratedPoint.js";
+import { clonePoint as c } from "../../layers/graphics/hydratedFeatures.js";
+import { getConvertedElevation as l, getZForElevationMode as f } from "../../support/elevationInfoUtils.js";
+import p from "../../geometry/SpatialReference.js";
+import v from "../../geometry/Point.js";
+class y {
+  constructor(e, t, n, r = null) {
+    this._elevationInfo = e, this.defaultZ = t, this._view = n, this._excludeGraphics = r;
   }
   screenToMap(e) {
-    const { defaultZ: t, _view: i } = this, n = i.sceneIntersectionHelper.intersectElevationFromScreen(a(e.x, e.y), this._elevationInfo, t ?? 0, this._excludeGraphics);
-    return t == null && n != null && (n.z = void 0), n;
+    const { defaultZ: t, _view: n } = this, r = n.sceneIntersectionHelper.intersectElevationFromScreen(u(e.x, e.y), this._elevationInfo, t ?? 0, this._excludeGraphics);
+    return t == null && r != null && (r.z = void 0), r;
   }
   mapToScreen(e) {
-    const t = o(e.x, e.y, r(this._view, e, this._elevationInfo), e.spatialReference);
+    const t = a(e.x, e.y, l(this._view, e, this._elevationInfo), e.spatialReference);
     return this._view.toScreen(t);
   }
   constrainZ(e) {
     const { defaultZ: t } = this;
-    return t != null && e.z !== t && ((e = l(e)).z = t), e;
+    return t != null && e.z !== t && ((e = c(e)).z = t), e;
   }
 }
-let S = class {
-  constructor(e, t, i = []) {
-    this.view = e, this.elevationInfo = t, this.exclude = i;
+let I = class {
+  constructor(e, t, n = []) {
+    this.view = e, this.elevationInfo = t, this.exclude = n;
   }
   screenToMap(e) {
     const t = this.view.toMap(e, { exclude: this.exclude, excludeHud: !0 });
-    return t != null && (t.z = c(t, this.view, this.elevationInfo)), t;
+    return t != null && (t.z = f(t, this.view, this.elevationInfo)), t;
   }
   mapToScreen(e) {
     let t = e;
-    return this.elevationInfo != null && (t = o(e.x, e.y, r(this.view, e, this.elevationInfo), e.spatialReference)), this.view.toScreen(t);
+    return this.elevationInfo != null && (t = a(e.x, e.y, l(this.view, e, this.elevationInfo), e.spatialReference)), this.view.toScreen(t);
   }
   constrainZ(e) {
     return e;
   }
 };
-new u();
+class _ {
+  constructor(e, t = !1, n = 0) {
+    this.view = e, this.hasZ = t, this.defaultZ = n, this.mapToScreen = (r) => e.toScreen(r), this.screenToMap = t ? (r) => {
+      const o = e.toMap(r);
+      return o.z = n, o;
+    } : (r) => e.toMap(r);
+  }
+  constrainZ(e) {
+    const { defaultZ: t } = this;
+    return this.hasZ && e.z !== t && ((e = c(e)).z = t), e;
+  }
+}
+class s {
+  screenToMap(e) {
+    const { x: t, y: n } = e;
+    return new v({ x: t, y: n, spatialReference: s.spatialReference });
+  }
+  mapToScreen(e) {
+    return h(e.x, e.y);
+  }
+  constrainZ(e) {
+    return e;
+  }
+}
+s.spatialReference = new p();
 export {
-  x as ElevationDrawSurface,
-  S as SceneDrawSurface
+  y as ElevationDrawSurface,
+  _ as MapDrawSurface,
+  I as SceneDrawSurface,
+  s as ScreenDrawSurface
 };

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/draw/support/Box.js

@@ -0,0 +1,481 @@
+import { _ as u } from "../../../chunks/tslib.es6.js";
+import "../../../geometry.js";
+import H from "../../../Graphic.js";
+import ot from "../../../core/Evented.js";
+import { destroyMaybe as A } from "../../../core/maybe.js";
+import { zeroMeters as rt } from "../../../core/quantityUtils.js";
+import { when as at, watch as M, syncAndInitial as ht, initial as ct } from "../../../core/reactiveUtils.js";
+import { property as m } from "../../../core/accessorSupport/decorators/property.js";
+import "../../../core/has.js";
+import "../../../core/Logger.js";
+import "../../../core/RandomLCG.js";
+import { subclass as nt } from "../../../core/accessorSupport/decorators/subclass.js";
+import { create as O } from "../../../geometry/support/aaBoundingRect.js";
+import { getRingsOrPathsBounds as N } from "../../../geometry/support/boundsUtils.js";
+import { geometryToCoordinates as X } from "../../../geometry/support/coordsUtils.js";
+import E from "../../../geometry/support/rotate.js";
+import D from "../../../symbols/SimpleFillSymbol.js";
+import lt from "../../../symbols/SimpleLineSymbol.js";
+import T from "../../../symbols/SimpleMarkerSymbol.js";
+import { cloneMove as w, scale as z, getRotationAngle as pt, getScaleRatio as _t } from "./drawUtils.js";
+import dt from "./GraphicMover.js";
+import ut from "./HighlightHelper.js";
+import { addUniqueLayer as mt } from "./layerUtils.js";
+import { settings as gt } from "./settings.js";
+import q from "../../interactive/sketch/SketchOptions.js";
+import { ExtentRotateTooltipInfo as vt, ExtentScaleTooltipInfo as yt } from "../../interactive/tooltip/ExtentTooltipInfos.js";
+import { Tooltip as F } from "../../interactive/tooltip/Tooltip.js";
+import { TranslateGraphicTooltipInfo as ft } from "../../interactive/tooltip/TranslateTooltipInfos.js";
+import { autoDistanceBetweenPoints2D as Gt } from "../../support/automaticLengthMeasurementUtils.js";
+import { autoSize2D as bt } from "../../support/extentUtils.js";
+import f from "../../../geometry/Point.js";
+import wt from "../../../geometry/Polygon.js";
+import xt from "../../../geometry/Polyline.js";
+class St {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.dx = s, this.dy = o, this.type = "move-start";
+  }
+}
+class kt {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.dx = s, this.dy = o, this.type = "move";
+  }
+}
+class U {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.dx = s, this.dy = o, this.type = "move-stop";
+  }
+}
+class Rt {
+  constructor(i, e, s) {
+    this.graphics = i, this.mover = e, this.angle = s, this.type = "rotate-start";
+  }
+}
+class Mt {
+  constructor(i, e, s) {
+    this.graphics = i, this.mover = e, this.angle = s, this.type = "rotate";
+  }
+}
+class V {
+  constructor(i, e, s) {
+    this.graphics = i, this.mover = e, this.angle = s, this.type = "rotate-stop";
+  }
+}
+class It {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.xScale = s, this.yScale = o, this.type = "scale-start";
+  }
+}
+class Ct {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.xScale = s, this.yScale = o, this.type = "scale";
+  }
+}
+class j {
+  constructor(i, e, s, o) {
+    this.graphics = i, this.mover = e, this.xScale = s, this.yScale = o, this.type = "scale-stop";
+  }
+}
+const _ = gt.transformGraphics, Ht = { centerIndicator: new T({ style: "cross", size: _.center.size, color: _.center.color }), fill: { default: new D({ color: _.fill.color, outline: { color: _.fill.outlineColor, join: "round", width: 1 } }), active: new D({ color: _.fill.stagedColor, outline: { color: _.fill.outlineColor, join: "round", style: "dash", width: 1 } }) }, handles: { default: new T({ style: "square", size: _.vertex.size, color: _.vertex.color, outline: { color: _.vertex.outlineColor, width: 1 } }), hover: new T({ style: "square", size: _.vertex.hoverSize, color: _.vertex.hoverColor, outline: { color: _.vertex.hoverOutlineColor, width: 1 } }) }, rotator: { default: new T({ style: "circle", size: _.vertex.size, color: _.vertex.color, outline: { color: _.vertex.outlineColor, width: 1 } }), hover: new T({ style: "circle", size: _.vertex.hoverSize, color: _.vertex.hoverColor, outline: { color: _.vertex.hoverOutlineColor, width: 1 } }) }, rotatorLine: new lt({ color: _.line.color, width: 1 }) };
+let d = class extends ot.EventedAccessor {
+  constructor(t) {
+    super(t), this._activeHandleGraphic = null, this._graphicAttributes = { esriSketchTool: "box" }, this._mover = null, this._centerGraphic = null, this._backgroundGraphic = null, this._vertexGraphics = [], this._rotateHandleGraphic = null, this._rotateGraphicOffset = 20, this._angleOfRotation = 0, this._rotateLineGraphic = null, this._startInfo = null, this._totalDx = 0, this._totalDy = 0, this._xScale = 1, this._yScale = 1, this.tooltip = null, this.type = "box", this.callbacks = { onMoveStart() {
+    }, onMove() {
+    }, onMoveStop() {
+    }, onScaleStart() {
+    }, onScale() {
+    }, onScaleStop() {
+    }, onRotateStart() {
+    }, onRotate() {
+    }, onRotateStop() {
+    }, onGraphicClick() {
+    } }, this.enableMovement = !0, this.enableRotation = !0, this.enableScaling = !0, this.graphics = [], this.highlightsEnabled = !0, this.layer = null, this.preserveAspectRatio = !1, this.showCenterGraphic = !0, this.symbols = Ht, this.sketchOptions = new q(), this.view = null, this._getBounds = (() => {
+      const i = O();
+      return (e, s) => {
+        e[0] = Number.POSITIVE_INFINITY, e[1] = Number.POSITIVE_INFINITY, e[2] = Number.NEGATIVE_INFINITY, e[3] = Number.NEGATIVE_INFINITY;
+        for (const o of s) {
+          if (!o)
+            continue;
+          let r, h, c, a;
+          if (o.type === "point")
+            r = c = o.x, h = a = o.y;
+          else if (o.type === "multipoint") {
+            const n = X(o);
+            [r, h, c, a] = N(i, [n]);
+          } else if (o.type === "extent")
+            [r, h, c, a] = [o.xmin, o.ymin, o.xmax, o.ymax];
+          else {
+            const n = X(o);
+            [r, h, c, a] = N(i, n);
+          }
+          e[0] = Math.min(r, e[0]), e[1] = Math.min(h, e[1]), e[2] = Math.max(c, e[2]), e[3] = Math.max(a, e[3]);
+        }
+        return e;
+      };
+    })();
+  }
+  initialize() {
+    const t = this.view;
+    this._highlightHelper = new ut({ view: t }), this.tooltip = new F({ view: t }), this._setup(), this.addHandles([at(() => t == null ? void 0 : t.ready, () => {
+      const { layer: i, view: e } = this;
+      mt(e, i);
+    }, { once: !0, initial: !0 }), M(() => this.preserveAspectRatio, () => {
+      this._activeHandleGraphic && (this._scaleGraphic(this._activeHandleGraphic), this._updateGraphics(), this._updateTooltip(this._activeHandleGraphic));
+    }), M(() => t == null ? void 0 : t.scale, () => {
+      this._updateRotateGraphic(), this._updateRotateLineGraphic();
+    }), M(() => this.graphics, () => this.refresh()), M(() => this.layer, (i, e) => {
+      e && this._resetGraphics(e), this.refresh();
+    }), M(() => this.highlightsEnabled, () => {
+      var i;
+      (i = this._highlightHelper) == null || i.removeAll(), this._setUpHighlights();
+    }), M(() => this.sketchOptions.tooltips.effectiveEnabled, (i) => {
+      this.tooltip = i ? new F({ view: this.view }) : A(this.tooltip);
+    }, ht), M(() => this.view.effectiveTheme.accentColor, () => this._updateSymbolsForTheme(), ct), this.on("move-start", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onMoveStart) == null ? void 0 : s.call(e, i);
+    }), this.on("move", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onMove) == null ? void 0 : s.call(e, i);
+    }), this.on("move-stop", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onMoveStop) == null ? void 0 : s.call(e, i);
+    }), this.on("rotate-start", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onRotateStart) == null ? void 0 : s.call(e, i);
+    }), this.on("rotate", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onRotate) == null ? void 0 : s.call(e, i);
+    }), this.on("rotate-stop", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onRotateStop) == null ? void 0 : s.call(e, i);
+    }), this.on("scale-start", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onScaleStart) == null ? void 0 : s.call(e, i);
+    }), this.on("scale", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onScale) == null ? void 0 : s.call(e, i);
+    }), this.on("scale-stop", (i) => {
+      var e, s;
+      return (s = (e = this.callbacks) == null ? void 0 : e.onScaleStop) == null ? void 0 : s.call(e, i);
+    })]);
+  }
+  destroy() {
+    this._reset(), this.tooltip = A(this.tooltip);
+  }
+  get state() {
+    var e;
+    const t = ((e = this.view) == null ? void 0 : e.ready) ?? !1, i = this.graphics.length && this.layer;
+    return t && i ? "active" : t ? "ready" : "disabled";
+  }
+  isUIGraphic(t) {
+    return this._vertexGraphics.includes(t) || t === this._backgroundGraphic || t === this._centerGraphic || t === this._rotateHandleGraphic || t === this._rotateLineGraphic;
+  }
+  move(t, i) {
+    if (this._mover && this.graphics.length) {
+      for (const e of this.graphics) {
+        const s = e.geometry, o = w(s, t, i, this.view);
+        e.geometry = o;
+      }
+      this.refresh(), this.emit("move-stop", new U(this.graphics, null, t, i));
+    }
+  }
+  scale(t, i) {
+    if (this._mover && this.graphics.length) {
+      for (const e of this.graphics) {
+        const s = e.geometry, o = z(s, t, i);
+        e.geometry = o;
+      }
+      this.refresh(), this.emit("scale-stop", new j(this.graphics, null, t, i));
+    }
+  }
+  rotate(t, i) {
+    if (this._mover && this.graphics.length) {
+      if (!i) {
+        const e = this._vertexGraphics[1].geometry.x, s = this._vertexGraphics[3].geometry.y;
+        i = new f(e, s, this.view.spatialReference);
+      }
+      for (const e of this.graphics) {
+        const s = e.geometry, o = E(s, t, i);
+        e.geometry = o;
+      }
+      this.refresh(), this.emit("rotate-stop", new V(this.graphics, null, t));
+    }
+  }
+  refresh() {
+    this._reset(), this._setup();
+  }
+  reset() {
+    this.graphics = [];
+  }
+  _setup() {
+    this.state === "active" && (this._setUpHighlights(), this._setupGraphics(), this._setupMover(), this._updateGraphics());
+  }
+  _reset() {
+    var t;
+    (t = this._highlightHelper) == null || t.removeAll(), this._resetGraphicStateVars(), this._resetGraphics(), this._updateTooltip(), this._mover && this._mover.destroy(), this._mover = null, this.view.cursor = "default";
+  }
+  _resetGraphicStateVars() {
+    this._startInfo = null, this._activeHandleGraphic = null, this._totalDx = 0, this._totalDy = 0, this._xScale = 1, this._yScale = 1, this._angleOfRotation = 0;
+  }
+  _resetGraphics(t) {
+    (t = t || this.layer) && (t.removeMany(this._vertexGraphics), t.remove(this._backgroundGraphic), t.remove(this._centerGraphic), t.remove(this._rotateHandleGraphic), t.remove(this._rotateLineGraphic)), this._vertexGraphics.forEach((i) => !i.destroyed && i.destroy()), !this._backgroundGraphic.destroyed && this._backgroundGraphic.destroy(), !this._centerGraphic.destroyed && this._centerGraphic.destroy(), !this._rotateHandleGraphic.destroyed && this._rotateHandleGraphic.destroy(), !this._rotateLineGraphic.destroyed && this._rotateLineGraphic.destroy(), this._vertexGraphics = [], this._backgroundGraphic = null, this._centerGraphic = null, this._rotateHandleGraphic = null, this._rotateLineGraphic = null;
+  }
+  _setupMover() {
+    let t = [];
+    this.enableScaling && (t = t.concat(this._vertexGraphics)), this.enableMovement && (t = t.concat(this.graphics, this._backgroundGraphic)), this.enableRotation && t.push(this._rotateHandleGraphic), this.showCenterGraphic && t.push(this._centerGraphic), this._mover = new dt({ enableMoveAllGraphics: !1, highlightsEnabled: !1, indicatorsEnabled: !1, view: this.view, graphics: t, callbacks: { onGraphicClick: (i) => this._onGraphicClickCallback(i), onGraphicMoveStart: (i) => this._onGraphicMoveStartCallback(i), onGraphicMove: (i) => this._onGraphicMoveCallback(i), onGraphicMoveStop: (i) => this._onGraphicMoveStopCallback(i), onGraphicPointerOver: (i) => this._onGraphicPointerOverCallback(i), onGraphicPointerOut: (i) => this._onGraphicPointerOutCallback(i) } });
+  }
+  _getStartInfo(t) {
+    const [i, e, s, o] = this._getBoxBounds(O()), r = Math.abs(s - i), h = Math.abs(o - e), c = (s + i) / 2, a = (o + e) / 2, { x: n, y: l } = t.geometry;
+    return { width: r, height: h, centerX: c, centerY: a, startX: n, startY: l, graphicInfos: this._getGraphicInfos(), box: this._backgroundGraphic.geometry, rotate: this._rotateHandleGraphic.geometry };
+  }
+  _getGraphicInfos() {
+    return this.graphics.map((t) => this._getGraphicInfo(t));
+  }
+  _getGraphicInfo(t) {
+    const i = t.geometry, [e, s, o, r] = this._getBounds(O(), [i]);
+    return { width: Math.abs(o - e), height: Math.abs(r - s), centerX: (o + e) / 2, centerY: (r + s) / 2, geometry: i };
+  }
+  _onGraphicClickCallback(t) {
+    t.viewEvent.stopPropagation(), this.emit("graphic-click", t), this.callbacks.onGraphicClick && this.callbacks.onGraphicClick(t);
+  }
+  _onGraphicMoveStartCallback(t) {
+    const { _angleOfRotation: i, _xScale: e, _yScale: s, _backgroundGraphic: o, _vertexGraphics: r, _rotateHandleGraphic: h, symbols: c } = this, a = t.graphic;
+    this._resetGraphicStateVars(), this._hideGraphicsBeforeUpdate(), o.symbol = c.fill.active, this._startInfo = this._getStartInfo(a), this._updateTooltip(a, t.viewEvent), a === h ? (this.view.cursor = "grabbing", this.emit("rotate-start", new Rt(this.graphics, a, i))) : r.includes(a) ? (this._activeHandleGraphic = a, this.emit("scale-start", new It(this.graphics, a, e, s))) : this.emit("move-start", new St(this.graphics, a, t.dx, t.dy));
+  }
+  _onGraphicMoveCallback(t) {
+    const i = t.graphic;
+    if (this._startInfo)
+      if (this._vertexGraphics.includes(i))
+        this._scaleGraphic(i), this._updateTooltip(i, t.viewEvent), this.emit("scale", new Ct(this.graphics, i, this._xScale, this._yScale));
+      else if (i === this._rotateHandleGraphic)
+        this._rotateGraphic(i), this._updateTooltip(i, t.viewEvent), this.emit("rotate", new Mt(this.graphics, i, this._angleOfRotation));
+      else {
+        const { dx: e, dy: s } = t;
+        this._totalDx += e, this._totalDy += s, this._moveGraphic(i, e, s), this._updateTooltip(i, t.viewEvent), this.emit("move", new kt(this.graphics, i, e, s));
+      }
+  }
+  _onGraphicMoveStopCallback(t) {
+    const i = t.graphic;
+    if (!this._startInfo)
+      return void this.refresh();
+    const { _angleOfRotation: e, _totalDx: s, _totalDy: o, _xScale: r, _yScale: h, _vertexGraphics: c, _rotateHandleGraphic: a } = this;
+    this.refresh(), i === a ? (this.view.cursor = "pointer", this.emit("rotate-stop", new V(this.graphics, i, e))) : c.includes(i) ? this.emit("scale-stop", new j(this.graphics, i, r, h)) : this.emit("move-stop", new U(this.graphics, i, s, o));
+  }
+  _onGraphicPointerOverCallback(t) {
+    const { _backgroundGraphic: i, _vertexGraphics: e, graphics: s, _rotateHandleGraphic: o, symbols: r, view: h } = this, c = t.graphic;
+    if (this._hoveredGraphic = c, c === o)
+      return o.symbol = r.rotator.hover, h.cursor = "pointer", void this._updateTooltip(c);
+    if (s.includes(c) || c === i)
+      return void (h.cursor = "move");
+    if (!e.includes(c))
+      return void (h.cursor = "pointer");
+    this._updateTooltip(c), t.graphic.symbol = r.handles.hover;
+    const a = h.rotation;
+    let n, l = t.index;
+    switch (l < 8 && (a >= 0 && a < 45 ? l %= 8 : l = a >= 45 && a < 90 ? (l + 1) % 8 : a >= 90 && a < 135 ? (l + 2) % 8 : a >= 135 && a < 180 ? (l + 3) % 8 : a >= 180 && a < 225 ? (l + 4) % 8 : a >= 225 && a < 270 ? (l + 5) % 8 : a >= 270 && a < 315 ? (l + 6) % 8 : (l + 7) % 8), l) {
+      case 0:
+      case 4:
+        n = "nwse-resize";
+        break;
+      case 1:
+      case 5:
+        n = "ns-resize";
+        break;
+      case 2:
+      case 6:
+        n = "nesw-resize";
+        break;
+      case 3:
+      case 7:
+        n = "ew-resize";
+        break;
+      default:
+        n = "pointer";
+    }
+    h.cursor = n;
+  }
+  _onGraphicPointerOutCallback(t) {
+    const { _vertexGraphics: i, _rotateHandleGraphic: e, symbols: s, view: o } = this;
+    this._hoveredGraphic = null, t.graphic === e ? e.symbol = s.rotator.default : i.includes(t.graphic) && (t.graphic.symbol = s.handles.default), o.cursor = "default", this._updateTooltip();
+  }
+  _toPrecision(t, i = 2) {
+    return Number.parseFloat(t.toFixed(i));
+  }
+  _scaleGraphic(t) {
+    const { _startInfo: i, _vertexGraphics: e, preserveAspectRatio: s, view: o } = this, { centerX: r, centerY: h, graphicInfos: c, height: a, startX: n, startY: l, width: I } = i, { resolution: G, transform: p } = o.state, g = e.indexOf(t);
+    g !== 1 && g !== 5 || this._updateX(t, r), g !== 3 && g !== 7 || this._updateY(t, h);
+    const { x: S, y: C } = t.geometry, J = p[0] * S + p[2] * C + p[4], K = p[1] * S + p[3] * C + p[5], k = (c == null ? void 0 : c.map((v) => v.geometry)) ?? [], Q = k.every((v) => v.type === "point");
+    if ((I === 0 || a === 0) && Q) {
+      const v = this._toPrecision((S - n) / G), y = this._toPrecision((l - C) / G);
+      for (let x = 0; x < k.length; x++)
+        this.graphics[x].geometry = w(k[x], v, y, o, !0);
+      return this._centerGraphic.geometry = new f(S, C, o.spatialReference), void (this._backgroundGraphic.geometry = w(i.box, v, y, o, !0));
+    }
+    if (s) {
+      const v = this._toPrecision(p[0] * r + p[2] * h + p[4], 2), y = this._toPrecision(p[1] * r + p[3] * h + p[5], 2), x = this._toPrecision(p[0] * n + p[2] * l + p[4], 2), L = this._toPrecision(p[1] * n + p[3] * l + p[5], 2);
+      let b = _t(v, y, x, L, J, K);
+      b !== 0 && Math.abs(b) !== 1 / 0 || (b = 1), this._xScale = this._yScale = b;
+      for (const R of k) {
+        const B = k.indexOf(R);
+        this.graphics[B].geometry = z(R, this._xScale, this._yScale, [r, h]);
+      }
+      this._updateBackgroundGraphic();
+    } else {
+      let v = S - n, y = l - C;
+      if (g === 1 || g === 5 ? v = 0 : g !== 3 && g !== 7 || (y = 0), v === 0 && y === 0)
+        return;
+      const x = r + v / 2, L = h + y / 2;
+      let b = (I + (n > r ? v : -1 * v)) / I, R = (a + (l < h ? y : -1 * y)) / a;
+      g !== 1 && g !== 5 && b !== 0 && Math.abs(b) !== 1 / 0 || (b = 1), g !== 3 && g !== 7 && R !== 0 && Math.abs(R) !== 1 / 0 || (R = 1), this._xScale = b, this._yScale = R;
+      const B = (x - r) / G, W = (L - h) / G, Z = z(i.box, this._xScale, this._yScale);
+      this._backgroundGraphic.geometry = w(Z, B, W, o, !0);
+      const { centerX: P, centerY: Y } = this._getGraphicInfo(this._backgroundGraphic), tt = (P - r) / G, et = -1 * (Y - h) / G;
+      for (const $ of k) {
+        const it = k.indexOf($), st = z($, this._xScale, this._yScale, [r, h]);
+        this.graphics[it].geometry = w(st, tt, et, o, !0);
+      }
+      this._centerGraphic.geometry = new f(P, Y, o.spatialReference);
+    }
+  }
+  _rotateGraphic(t) {
+    var G;
+    const { centerX: i, centerY: e, startX: s, startY: o, box: r, rotate: h } = this._startInfo, c = this.view.spatialReference, a = new f(s, o, c), n = new f(i, e, c), l = t.geometry;
+    this._angleOfRotation = pt(a, l, n);
+    const I = ((G = this._startInfo.graphicInfos) == null ? void 0 : G.map((p) => p.geometry)) ?? [];
+    for (const p of I) {
+      const g = I.indexOf(p), S = E(p, this._angleOfRotation, n);
+      this.graphics[g].geometry = S;
+    }
+    this._backgroundGraphic.geometry = E(r, this._angleOfRotation, n), this._rotateHandleGraphic.geometry = E(h, this._angleOfRotation, n);
+  }
+  _moveGraphic(t, i, e) {
+    if (this.graphics.includes(t)) {
+      const s = this._backgroundGraphic.geometry;
+      this._backgroundGraphic.geometry = w(s, i, e, this.view);
+      for (const o of this.graphics)
+        o !== t && (o.geometry = w(o.geometry, i, e, this.view));
+    } else if (t === this._centerGraphic) {
+      const s = this._backgroundGraphic.geometry;
+      this._backgroundGraphic.geometry = w(s, i, e, this.view);
+    }
+    if (t === this._backgroundGraphic || t === this._centerGraphic)
+      for (const s of this.graphics)
+        s.geometry = w(s.geometry, i, e, this.view);
+  }
+  _setUpHighlights() {
+    var t;
+    this.highlightsEnabled && this.graphics.length && ((t = this._highlightHelper) == null || t.add(this.graphics));
+  }
+  _setupGraphics() {
+    const { _graphicAttributes: t, symbols: i } = this;
+    this._centerGraphic = new H(null, i.centerIndicator, t), this.showCenterGraphic && this.layer.add(this._centerGraphic), this._backgroundGraphic = new H(null, i.fill.default, t), this.layer.add(this._backgroundGraphic), this._rotateLineGraphic = new H(null, i.rotatorLine, t), this._rotateHandleGraphic = new H(null, i.rotator.default, t), this.enableRotation && !this._hasExtentGraphic() && this.layer.addMany([this._rotateLineGraphic, this._rotateHandleGraphic]);
+    for (let e = 0; e < 8; e++)
+      this._vertexGraphics.push(new H(null, i.handles.default, t));
+    this.enableScaling && this.layer.addMany(this._vertexGraphics);
+  }
+  _updateSymbolsForTheme() {
+    var i, e;
+    const t = this.view.effectiveTheme.accentColor;
+    this.symbols = { ...this.symbols, fill: { active: (i = this.symbols.fill.active) == null ? void 0 : i.clone().set("outline.color", t), default: (e = this.symbols.fill.default) == null ? void 0 : e.clone().set("outline.color", t) }, handles: { ...this.symbols.handles, default: this.symbols.handles.default.clone().set("outline.color", t) }, rotator: { ...this.symbols.rotator, default: this.symbols.rotator.default.clone().set("outline.color", t) }, rotatorLine: this.symbols.rotatorLine.clone().set("color", t) };
+    for (const s of this._vertexGraphics)
+      s.symbol = s === this._hoveredGraphic ? this.symbols.handles.hover : this.symbols.handles.default;
+    this._backgroundGraphic.symbol = this.symbols.fill.default, this._rotateHandleGraphic.symbol = this._rotateHandleGraphic === this._hoveredGraphic ? this.symbols.rotator.hover : this.symbols.rotator.default, this._rotateLineGraphic.symbol = this.symbols.rotatorLine;
+  }
+  _updateGraphics() {
+    this._updateBackgroundGraphic(), this._updateHandleGraphics(), this._updateCenterGraphic(), this._updateRotateGraphic(), this._updateRotateLineGraphic();
+  }
+  _hideGraphicsBeforeUpdate() {
+    this._centerGraphic.visible = !1, this._rotateHandleGraphic.visible = !1, this._rotateLineGraphic.visible = !1, this._vertexGraphics.forEach((t) => t.visible = !1);
+  }
+  _updateHandleGraphics() {
+    const t = this._getCoordinates(!0);
+    this._vertexGraphics.forEach((i, e) => {
+      const [s, o] = t[e];
+      this._updateXY(i, s, o);
+    });
+  }
+  _updateBackgroundGraphic() {
+    const t = this._getCoordinates();
+    this._backgroundGraphic.geometry = new wt({ rings: t, spatialReference: this.view.spatialReference });
+  }
+  _updateCenterGraphic() {
+    const [t, i, e, s] = this._getBoxBounds(O()), o = (e + t) / 2, r = (s + i) / 2;
+    this._centerGraphic.geometry = new f(o, r, this.view.spatialReference);
+  }
+  _updateRotateGraphic() {
+    if (!this._vertexGraphics.length)
+      return;
+    const { x: t, y: i } = this._vertexGraphics[1].geometry, e = i + this.view.state.resolution * this._rotateGraphicOffset;
+    this._rotateHandleGraphic.geometry = new f(t, e, this.view.spatialReference);
+  }
+  _updateRotateLineGraphic() {
+    var e;
+    if (!this._vertexGraphics.length || !((e = this._rotateHandleGraphic) != null && e.geometry))
+      return;
+    const t = this._vertexGraphics[1].geometry, i = this._rotateHandleGraphic.geometry;
+    this._rotateLineGraphic.geometry = new xt({ paths: [[t.x, t.y], [i.x, i.y]], spatialReference: this.view.spatialReference });
+  }
+  _updateXY(t, i, e) {
+    t.geometry = new f(i, e, this.view.spatialReference);
+  }
+  _updateX(t, i) {
+    const e = t.geometry.y;
+    t.geometry = new f(i, e, this.view.spatialReference);
+  }
+  _updateY(t, i) {
+    const e = t.geometry.x;
+    t.geometry = new f(e, i, this.view.spatialReference);
+  }
+  _hasExtentGraphic() {
+    return this.graphics.some((t) => (t == null ? void 0 : t.geometry) != null && t.geometry.type === "extent");
+  }
+  _getBoxBounds(t) {
+    const i = this.graphics.map((e) => e.geometry);
+    return this._getBounds(t, i);
+  }
+  _getCoordinates(t) {
+    const [i, e, s, o] = this._getBoxBounds(O());
+    if (t) {
+      const r = (i + s) / 2, h = (o + e) / 2;
+      return [[i, o], [r, o], [s, o], [s, h], [s, e], [r, e], [i, e], [i, h]];
+    }
+    return [[i, o], [s, o], [s, e], [i, e]];
+  }
+  _updateTooltip(t, i) {
+    if (this.tooltip == null)
+      return;
+    if (!t)
+      return void this.tooltip.clear();
+    const { _backgroundGraphic: e, graphics: s, _vertexGraphics: o, _rotateHandleGraphic: r } = this;
+    t === r ? this._updateRotateTooltip() : o.includes(t) ? this._updateScaleTooltip() : (s.includes(t) || t === e) && this._updateMoveTooltip(i);
+  }
+  _updateRotateTooltip() {
+    this.tooltip != null && (this.tooltip.info = new vt({ sketchOptions: this.sketchOptions, angle: -this._angleOfRotation }));
+  }
+  _updateScaleTooltip() {
+    const { tooltip: t, _xScale: i, _yScale: e, sketchOptions: s, view: o } = this;
+    if (t == null)
+      return;
+    const r = this._getCoordinates(), h = bt({ topLeft: r[0], topRight: r[1], bottomRight: r[2], bottomLeft: r[3], spatialReference: o.spatialReference });
+    if (h == null)
+      return;
+    const { xSize: c, ySize: a } = h, n = Math.abs(i), l = Math.abs(e);
+    t.info = new yt({ sketchOptions: s, xScale: n, yScale: l, xSize: c, ySize: a });
+  }
+  _updateMoveTooltip(t) {
+    const { tooltip: i, sketchOptions: e, view: s } = this;
+    if (i == null)
+      return;
+    const o = new ft({ sketchOptions: e });
+    if (t) {
+      const { x: r, y: h } = t.origin, c = s.toMap(t), a = s.toMap({ x: r, y: h }), n = Gt(a, c);
+      o.distance = n ?? rt;
+    }
+    i.info = o;
+  }
+};
+u([m()], d.prototype, "tooltip", void 0), u([m({ readOnly: !0 })], d.prototype, "type", void 0), u([m()], d.prototype, "callbacks", void 0), u([m()], d.prototype, "enableMovement", void 0), u([m()], d.prototype, "enableRotation", void 0), u([m()], d.prototype, "enableScaling", void 0), u([m()], d.prototype, "graphics", void 0), u([m()], d.prototype, "highlightsEnabled", void 0), u([m()], d.prototype, "layer", void 0), u([m()], d.prototype, "preserveAspectRatio", void 0), u([m()], d.prototype, "showCenterGraphic", void 0), u([m({ readOnly: !0 })], d.prototype, "state", null), u([m()], d.prototype, "symbols", void 0), u([m({ type: q })], d.prototype, "sketchOptions", void 0), u([m({ constructOnly: !0 })], d.prototype, "view", void 0), d = u([nt("esri.views.draw.support.Box")], d);
+const le = d;
+export {
+  le as default
+};