@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/MeasurementWidgetContent-82971f95.js

@@ -0,0 +1,2642 @@
+import { G as Ze, cy as Ut, fg as P, bd as et, bf as Et, W as jt, j as Bt, b1 as Tn, b0 as Vn, kf as q, dU as Ls, kg as Rs, kh as Ps, aI as Ss, bR as An, bg as X, bl as bt, e as f, y as _, c as It, ad as re, bx as Ln, g6 as V, fs as ue, fm as ks, aS as R, iJ as Mt, a$ as Rt, iI as Rn, ki as Pn, kj as Ns, jA as zs, b9 as g, kk as Cs, gc as Is, hk as Ds, bm as $t, kl as oe, aH as Zs, gn as Os, dc as Sn, dN as Xt, d0 as Us, jj as C, jv as qs, km as kn, kn as ct, ko as kt, kp as Pt, kq as Hs, hW as sn, bo as rn, bc as z, kr as on, bp as Ot, ks as Fs, bF as Gs, iH as js, kt as an, g as Xs, c7 as Ys, ku as Ws, kv as Bs, kw as Js, bT as pe, bz as Qs, aq as Yt, en as j, fr as O, kx as Ks, bn as Oe, gi as Le, fj as Nn, C as ti, B as ei, br as Re, bq as ni, ky as si, jr as zn, bE as ii, kz as ri, o as Ue, a as oi, l as ai, eQ as li, k as ci, fG as Cn, by as hi, q as ui, kA as pi, i0 as di, jm as fi, kB as gi, kC as _i, kD as mi, V as yi, S as In, kE as Tt, dO as vi, s as Dn, p as xi, fU as Ei, fV as Zn, hO as On, fW as N, kF as $i } from "./index-6ebf29c1.js";
+import { _ as Mi, a as wi, L as bi, s as Ti, j as Vi } from "./vec42-27060a00.js";
+import { n as Un, r as Ee, e as Ai } from "./vec4f64-043e974c.js";
+import { E as F, j as Jt, V as qt, A as $e, D as qn, F as Ht, w as qe, R as Pe, J as Hn, b as Li } from "./plane-84e27261.js";
+import { f as Ri, a as ln, D as Pi, T as Si, E as ki, W as Ni, Z as zi } from "./sphere-418b76df.js";
+import { e as Qt, n as ae } from "./projectVectorToVector-b7e757a1.js";
+import { g as Ci, h as Ii, w as He, v as cn } from "./elevationInfoUtils-c1caf596.js";
+import { g as Di, u as Zi } from "./meshVertexSpaceUtils-c9b69510.js";
+import { I as Oi, F as Ui } from "./Scheduler-b3c40220.js";
+import { y as Fn, l as qi } from "./quantityUtils-b64583f9.js";
+function Hi(n, t) {
+  return n === t || n != null && t != null && Ze(n.spatialReference, t.spatialReference) && n.x === t.x && n.y === t.y && n.z === t.z && n.m === t.m;
+}
+function Do(n, t, e) {
+  return n === t || n != null && t != null && Ze(n.spatialReference, t.spatialReference) && Ut(n.x, t.x, e) && Ut(n.y, t.y, e) && Ut(n.z ?? 0, t.z ?? 0, e) && Ut(n.m ?? 0, t.m ?? 0, e);
+}
+function Zo(n) {
+  const t = n[0] * n[0] + n[4] * n[4] + n[8] * n[8], e = n[1] * n[1] + n[5] * n[5] + n[9] * n[9], s = n[2] * n[2] + n[6] * n[6] + n[10] * n[10];
+  return Math.sqrt(Math.max(t, e, s));
+}
+function Gn(n, t, e) {
+  Math.abs(n[0]) > Math.abs(n[1]) ? P(t, 0, 1, 0) : P(t, 1, 0, 0), et(e, n, t), et(t, e, n), Et(e, e), Et(t, t);
+}
+function jn(n) {
+  if (!n)
+    return null;
+  if (Ls(n) && n.wkid) {
+    const e = Rs[n.wkid];
+    if (e)
+      return e;
+  }
+  const t = n.wkt2 || n.wkt;
+  if (t) {
+    const e = Fi(t);
+    if (e)
+      return e;
+  }
+  return null;
+}
+function Fi(n) {
+  const t = Ps.exec(n);
+  if (!t || t.length !== 2)
+    return null;
+  const e = t[1].split(",");
+  if (!e || e.length < 3)
+    return null;
+  const s = parseFloat(e[1]), i = parseFloat(e[2]);
+  return isNaN(s) || isNaN(i) ? null : { a: s, f: i === 0 ? 0 : 1 / i };
+}
+function de(n) {
+  const t = jn(n);
+  if (Gi(t))
+    return t;
+  const e = t.a * (1 - t.f);
+  return Object.assign(t, { b: e, eSq: 1 - (e / t.a) ** 2, radius: (2 * t.a + e) / 3, densificationRatio: 1e4 / ((2 * t.a + e) / 3) });
+}
+function Gi(n) {
+  return n != null && "b" in n && "eSq" in n && "radius" in n;
+}
+function ie(n, t, e) {
+  const { a: s, eSq: i } = de(e), r = Math.sqrt(i), o = Math.sin(t[1] * q), a = s * t[0] * q;
+  let l;
+  return i > 0 ? l = s * ((1 - i) * (o / (1 - i * (o * o)) - 1 / (2 * r) * Math.log((1 - r * o) / (1 + r * o)))) * 0.5 : l = s * o, n[0] = a, n[1] = l, n;
+}
+function fe(n) {
+  return jn(n) !== null;
+}
+function Oo(n, t = "square-meters") {
+  if (n.some((o) => !fe(o.spatialReference)))
+    throw new jt("geodesic-areas:invalid-spatial-reference", "the input geometries spatial reference is not supported");
+  const e = [];
+  for (let o = 0; o < n.length; o++) {
+    const a = n[o], l = a.spatialReference, { radius: c, densificationRatio: u } = de(l), h = c * u;
+    e.push(ji(a, h));
+  }
+  const s = [], i = [0, 0], r = [0, 0];
+  for (let o = 0; o < e.length; o++) {
+    const { rings: a, spatialReference: l } = e[o];
+    let c = 0;
+    for (let u = 0; u < a.length; u++) {
+      const h = a[u];
+      ie(i, h[0], l), ie(r, h[h.length - 1], l);
+      let d = r[0] * i[1] - i[0] * r[1];
+      for (let p = 0; p < h.length - 1; p++)
+        ie(i, h[p + 1], l), ie(r, h[p], l), d += r[0] * i[1] - i[0] * r[1];
+      c += d;
+    }
+    c = Bt(c, "square-meters", t), s.push(c / -2);
+  }
+  return s;
+}
+function Uo(n, t = "meters") {
+  if (!n)
+    throw new jt("geodesic-lengths:invalid-geometries", "the input geometries type is not supported");
+  if (n.some((s) => !fe(s.spatialReference)))
+    throw new jt("geodesic-lengths:invalid-spatial-reference", "the input geometries spatial reference is not supported");
+  const e = [];
+  for (let s = 0; s < n.length; s++) {
+    const i = n[s], { spatialReference: r } = i, o = i.type === "polyline" ? i.paths : i.rings;
+    let a = 0;
+    for (let l = 0; l < o.length; l++) {
+      const c = o[l];
+      let u = 0;
+      for (let h = 1; h < c.length; h++) {
+        const d = c[h - 1][0], p = c[h][0], y = c[h - 1][1], m = c[h][1];
+        if (y !== m || d !== p) {
+          const v = new Kt();
+          te(v, [d, y], [p, m], r), u += v.distance;
+        }
+      }
+      a += u;
+    }
+    a = Bt(a, "meters", t), e.push(a);
+  }
+  return e;
+}
+function ji(n, t) {
+  if (n.type !== "polyline" && n.type !== "polygon")
+    throw new jt("geodesic-densify:invalid-geometry", "the input geometry is neither polyline nor polygon");
+  const { spatialReference: e } = n;
+  if (!fe(e))
+    throw new jt("geodesic-densify:invalid-spatial-reference", "the input geometry spatial reference is not supported");
+  const s = n.type === "polyline" ? n.paths : n.rings, i = [], r = [0, 0], o = new Kt();
+  for (const a of s) {
+    const l = [];
+    i.push(l), l.push([a[0][0], a[0][1]]);
+    let c, u, h = a[0][0], d = a[0][1];
+    for (let p = 0; p < a.length - 1; p++) {
+      if (c = a[p + 1][0], u = a[p + 1][1], h === c && d === u)
+        continue;
+      const y = [h, d];
+      te(o, [h, d], [c, u], e);
+      const { azimuth: m, distance: v } = o, x = v / t;
+      if (x > 1) {
+        for (let b = 1; b <= x - 1; b++)
+          At(r, y, m, b * t, e), l.push(r.slice(0));
+        At(r, y, m, (v + Math.floor(x - 1) * t) / 2, e), l.push(r.slice(0));
+      }
+      At(r, y, m, v, e), l.push(r.slice(0)), h = r[0], d = r[1];
+    }
+  }
+  return n.type === "polyline" ? new Tn({ paths: i, spatialReference: e }) : new Vn({ rings: i, spatialReference: e });
+}
+let Kt = class {
+  constructor(t = 0, e = void 0, s = void 0) {
+    this.distance = t, this.azimuth = e, this.reverseAzimuth = s;
+  }
+};
+function At(n, t, e, s, i) {
+  const r = t[0], o = t[1], a = r * q, l = o * q, c = (e ?? 0) * q, { a: u, b: h, f: d } = de(i), p = Math.sin(c), y = Math.cos(c), m = (1 - d) * Math.tan(l), v = 1 / Math.sqrt(1 + m * m), x = m * v, b = Math.atan2(m, y), S = v * p, I = S * S, A = 1 - I, E = A * (u * u - h * h) / (h * h), k = 1 + E / 16384 * (4096 + E * (E * (320 - 175 * E) - 768)), U = E / 1024 * (256 + E * (E * (74 - 47 * E) - 128));
+  let D, G, L, rt, W = s / (h * k), H = 2 * Math.PI;
+  for (; Math.abs(W - H) > 1e-12; )
+    L = Math.cos(2 * b + W), D = Math.sin(W), G = Math.cos(W), rt = U * D * (L + U / 4 * (G * (2 * L * L - 1) - U / 6 * L * (4 * D * D - 3) * (4 * L * L - 3))), H = W, W = s / (h * k) + rt;
+  const Q = x * D - v * G * y, Dt = Math.atan2(x * G + v * D * y, (1 - d) * Math.sqrt(I + Q * Q)), ye = Math.atan2(D * p, v * G - x * D * y), Zt = d / 16 * A * (4 + d * (4 - 3 * A)), ve = Dt / q, xe = (a + (ye - (1 - Zt) * d * S * (W + Zt * D * (L + Zt * G * (2 * L * L - 1))))) / q;
+  return n[0] = xe, n[1] = ve, n;
+}
+function te(n, t, e, s) {
+  const i = t[0] * q, r = t[1] * q, o = e[0] * q, a = e[1] * q, { a: l, b: c, f: u, radius: h } = de(s), d = o - i, p = Math.atan((1 - u) * Math.tan(r)), y = Math.atan((1 - u) * Math.tan(a)), m = Math.sin(p), v = Math.cos(p), x = Math.sin(y), b = Math.cos(y);
+  let S, I, A, E, k, U, D, G, L, rt, W = 1e3, H = d;
+  do {
+    if (D = Math.sin(H), G = Math.cos(H), A = Math.sqrt(b * D * (b * D) + (v * x - m * b * G) * (v * x - m * b * G)), A === 0)
+      return n.distance = 0, n.azimuth = void 0, n.reverseAzimuth = void 0, n;
+    k = m * x + v * b * G, U = Math.atan2(A, k), L = v * b * D / A, I = 1 - L * L, E = k - 2 * m * x / I, isNaN(E) && (E = 0), rt = u / 16 * I * (4 + u * (4 - 3 * I)), S = H, H = d + (1 - rt) * u * L * (U + rt * A * (E + rt * k * (2 * E * E - 1)));
+  } while (Math.abs(H - S) > 1e-12 && --W > 0);
+  if (W === 0) {
+    const xe = h, bs = Math.acos(Math.sin(r) * Math.sin(a) + Math.cos(r) * Math.cos(a) * Math.cos(o - i)) * xe, nn = o - i, Ts = Math.sin(nn) * Math.cos(a), Vs = Math.cos(r) * Math.sin(a) - Math.sin(r) * Math.cos(a) * Math.cos(nn), As = Math.atan2(Ts, Vs);
+    return n.azimuth = As / q, n.distance = bs, n.reverseAzimuth = void 0, n;
+  }
+  const Q = I * (l * l - c * c) / (c * c), Dt = Q / 1024 * (256 + Q * (Q * (74 - 47 * Q) - 128)), ye = c * (1 + Q / 16384 * (4096 + Q * (Q * (320 - 175 * Q) - 768))) * (U - Dt * A * (E + Dt / 4 * (k * (2 * E * E - 1) - Dt / 6 * E * (4 * A * A - 3) * (4 * E * E - 3)))), Zt = Math.atan2(b * Math.sin(H), v * x - m * b * Math.cos(H)), ve = Math.atan2(v * Math.sin(H), v * x * Math.cos(H) - m * b);
+  return n.azimuth = Zt / q, n.distance = ye, n.reverseAzimuth = ve / q, n;
+}
+function Se(n) {
+  return fe(n) ? n : Ss(n) ? An.WGS84 : null;
+}
+function Xi(n, t, e) {
+  return X(n, t, e);
+}
+function Ho(n) {
+  return n;
+}
+function Fo(n) {
+  return n;
+}
+function St(n, t, e) {
+  return X(n, t, e);
+}
+function Nt(n) {
+  return bt(n);
+}
+function hn(n, t, { coordinateHelper: e, elevationInfo: s }) {
+  return n ? Yi(e.vectorToDehydratedPoint(n, Wi), t, s) : null;
+}
+function Yi(n, t, e) {
+  if (n == null)
+    return null;
+  if (t == null)
+    return X(n.x, n.y, n.z ?? 0);
+  if (t.type === "2d")
+    return X(n.x, n.y, 0);
+  const s = Ci(t, n, e, He) ?? 0;
+  return X(n.x, n.y, s);
+}
+function Go(n, t) {
+  return Qt(n[0], n[1], n[2], t);
+}
+function jo(n, t, { z: e, m: s }, i) {
+  const { spatialReference: r, elevationInfo: o } = i;
+  let a;
+  e == null && s == null ? a = void 0 : t == null || t.type === "2d" ? a = e ?? void 0 : a = Ii(t, n, r, He, o) ?? 0;
+  const l = Qt(n[0], n[1], a, r);
+  return s != null && (l.m = s, l.hasM = !0), l;
+}
+const Wi = Qt(0, 0, 0, null);
+let nt = class extends Ln {
+  constructor() {
+    super(...arguments), this.enabled = !0;
+  }
+};
+f([_({ type: Boolean })], nt.prototype, "enabled", void 0), nt = f([It("esri.views.interactive.snapping.Settings.DefaultSnappingAlgorithm")], nt);
+let M = class extends Ln {
+  constructor(t) {
+    super(t), this.lineSnapper = new nt(), this.parallelLineSnapper = new nt(), this.rightAngleSnapper = new nt(), this.rightAngleTriangleSnapper = new nt(), this.shortLineThreshold = 15, this.distance = 5, this.pointThreshold = 1e-6, this.intersectionParallelLineThreshold = 1e-6, this.parallelLineThreshold = 1e-6, this.verticalLineThresholdMeters = 0.3, this.touchSensitivityMultiplier = 1.5, this.pointOnLineThreshold = 1e-6, this.orange = new re([255, 127, 0]), this.orangeTransparent = new re([255, 127, 0, 0.5]), this.lineHintWidthReference = 3, this.lineHintWidthTarget = 3, this.lineHintFadedExtensions = 0.3, this.parallelLineHintWidth = 2, this.parallelLineHintLength = 24, this.parallelLineHintOffset = 1.5, this.rightAngleHintSize = 24, this.rightAngleHintOutlineSize = 1.5, this.satisfiesConstraintScreenThreshold = 1;
+  }
+};
+f([_({ type: nt, constructOnly: !0, nonNullable: !0, json: { write: !0 } })], M.prototype, "lineSnapper", void 0), f([_({ type: nt, constructOnly: !0, nonNullable: !0, json: { write: !0 } })], M.prototype, "parallelLineSnapper", void 0), f([_({ type: nt, constructOnly: !0, nonNullable: !0, json: { write: !0 } })], M.prototype, "rightAngleSnapper", void 0), f([_({ type: nt, constructOnly: !0, nonNullable: !0, json: { write: !0 } })], M.prototype, "rightAngleTriangleSnapper", void 0), f([_({ type: Number, nonNullable: !0, range: { min: -1, max: 50, step: 1 }, json: { write: !0 } })], M.prototype, "shortLineThreshold", void 0), f([_({ type: Number, nonNullable: !0, range: { min: -1, max: 50, step: 1 }, json: { write: !0 } })], M.prototype, "distance", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1e-5 }, json: { write: !0 } })], M.prototype, "pointThreshold", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1e-5 }, json: { write: !0 } })], M.prototype, "intersectionParallelLineThreshold", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1e-5 }, json: { write: !0 } })], M.prototype, "parallelLineThreshold", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1 }, json: { write: !0 } })], M.prototype, "verticalLineThresholdMeters", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 10 }, json: { write: !0 } })], M.prototype, "touchSensitivityMultiplier", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1e-5 }, json: { write: !0 } })], M.prototype, "pointOnLineThreshold", void 0), f([_({ type: re, nonNullable: !0 })], M.prototype, "orange", void 0), f([_({ type: re, nonNullable: !0 })], M.prototype, "orangeTransparent", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 10 }, json: { write: !0 } })], M.prototype, "lineHintWidthReference", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 10 }, json: { write: !0 } })], M.prototype, "lineHintWidthTarget", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 1 }, json: { write: !0 } })], M.prototype, "lineHintFadedExtensions", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 10 }, json: { write: !0 } })], M.prototype, "parallelLineHintWidth", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 50 }, json: { write: !0 } })], M.prototype, "parallelLineHintLength", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 5 }, json: { write: !0 } })], M.prototype, "parallelLineHintOffset", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 46 }, json: { write: !0 } })], M.prototype, "rightAngleHintSize", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 6 }, json: { write: !0 } })], M.prototype, "rightAngleHintOutlineSize", void 0), f([_({ type: Number, nonNullable: !0, range: { min: 0, max: 5 }, json: { write: !0 } })], M.prototype, "satisfiesConstraintScreenThreshold", void 0), M = f([It("esri.views.interactive.snapping.Settings.Defaults")], M);
+const Wo = new M();
+var zt;
+(function(n) {
+  n[n.FEATURE = 1] = "FEATURE", n[n.SELF = 2] = "SELF", n[n.ALL = 3] = "ALL";
+})(zt || (zt = {}));
+let ee = class {
+  constructor(t, e) {
+    this.isDraped = t, this.domain = e;
+  }
+}, Bi = class Xn extends ee {
+  constructor(t, e, s = zt.ALL) {
+    super(e, s), this.intersectionPoint = t;
+  }
+  equals(t) {
+    return t instanceof Xn && V(this.intersectionPoint, t.intersectionPoint);
+  }
+}, Ji = class Yn extends ee {
+  constructor(t, e, s, i, r = zt.ALL, o = !0, a = !0) {
+    super(i, r), this.type = t, this.lineStart = e, this.lineEnd = s, this.fadeLeft = o, this.fadeRight = a;
+  }
+  equals(t) {
+    return t instanceof Yn && this.type === t.type && V(this.lineStart, t.lineStart) && V(this.lineEnd, t.lineEnd) && this.fadeLeft === t.fadeLeft && this.fadeRight === t.fadeRight;
+  }
+  get length() {
+    return ue(this.lineStart, this.lineEnd);
+  }
+}, Qi = class Wn extends ee {
+  constructor(t, e, s, i = zt.ALL) {
+    super(s, i), this.lineStart = t, this.lineEnd = e;
+  }
+  equals(t) {
+    return t instanceof Wn && V(this.lineStart, t.lineStart) && V(this.lineEnd, t.lineEnd);
+  }
+}, Ki = class Bn extends ee {
+  constructor(t, e, s) {
+    super(e, s), this.point = t;
+  }
+  equals(t) {
+    return t instanceof Bn && V(this.point, t.point);
+  }
+};
+class Fe extends ee {
+  constructor(t, e, s, i, r = zt.ALL) {
+    super(i, r), this.previousVertex = t, this.centerVertex = e, this.nextVertex = s;
+  }
+  equals(t) {
+    return t instanceof Fe && V(this.previousVertex, t.previousVertex) && V(this.centerVertex, t.centerVertex) && V(this.nextVertex, t.nextVertex);
+  }
+}
+let Jo = class {
+  draw(t, e) {
+    const s = this._getUniqueHints(t), i = this.sortUniqueHints(s), r = [];
+    for (const o of i)
+      o instanceof Bi && r.push(this.visualizeIntersectionPoint(o, e)), o instanceof Ji && r.push(this.visualizeLine(o, e)), o instanceof Qi && r.push(this.visualizeParallelSign(o, e)), o instanceof Fe && r.push(this.visualizeRightAngleQuad(o, e)), o instanceof Ki && r.push(this.visualizePoint(o, e));
+    return ks(r);
+  }
+  sortUniqueHints(t) {
+    return t;
+  }
+  _getUniqueHints(t) {
+    const e = [];
+    for (const s of t) {
+      let i = !0;
+      for (const r of e)
+        if (s.equals(r)) {
+          i = !1;
+          break;
+        }
+      i && e.push(s);
+    }
+    return e;
+  }
+};
+var T;
+(function(n) {
+  n[n.Z = 0] = "Z", n[n.M = 1] = "M";
+})(T || (T = {}));
+let tr = class {
+  constructor(t) {
+    this.spatialReference = t;
+  }
+  createVector() {
+    return this._tag(R());
+  }
+  pointToVector(t) {
+    return this._tag(Mt(t.x, t.y));
+  }
+  arrayToVector(t) {
+    return this._tag(Mt(t[0], t[1]));
+  }
+  vectorToArray(t) {
+    return [t[0], t[1]];
+  }
+  pointToArray(t) {
+    return [t.x, t.y];
+  }
+  vectorToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = void 0, e.m = void 0, e.spatialReference = this.spatialReference, e;
+  }
+  arrayToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = void 0, e.m = void 0, e.spatialReference = this.spatialReference, e;
+  }
+  vectorToDehydratedPoint(t, e) {
+    if (t)
+      return e ?? (e = { x: void 0, y: void 0, z: void 0, m: void 0, hasZ: void 0, hasM: void 0, spatialReference: void 0, type: "point" }), e.x = t[0], e.y = t[1], e.z = void 0, e.m = void 0, e.hasZ = !1, e.hasM = !1, e.spatialReference = this.spatialReference, e;
+  }
+  lerp(t, e, s, i) {
+    return Rn(i, t, e, s);
+  }
+  addDelta(t, e, s) {
+    t[0] += e, t[1] += s;
+  }
+  distance(t, e) {
+    return Pn(t, e);
+  }
+  getZ(t, e = void 0) {
+    return e;
+  }
+  hasZ() {
+    return !1;
+  }
+  getM(t, e = void 0) {
+    return e;
+  }
+  hasM() {
+    return !1;
+  }
+  clone(t) {
+    return this._tag(Ns(t));
+  }
+  copy(t, e) {
+    return zs(e, t);
+  }
+  fromXYZ(t) {
+    return this._tag(Mt(t[0], t[1]));
+  }
+  toXYZ(t, e = g()) {
+    return P(e, t[0], t[1], 0);
+  }
+  pointToXYZ(t, e = g()) {
+    return P(e, t.x, t.y, 0);
+  }
+  equals(t, e) {
+    return Cs(t, e);
+  }
+  _tag(t) {
+    return t;
+  }
+}, un = class {
+  constructor(t, e) {
+    this._valueType = t, this.spatialReference = e;
+  }
+  createVector() {
+    return this._tag(g());
+  }
+  pointToVector(t) {
+    return this._tag(X(t.x, t.y, this._valueType === T.Z ? t.z : t.m));
+  }
+  arrayToVector(t) {
+    return this._tag(X(t[0], t[1], t[2] || 0));
+  }
+  vectorToArray(t) {
+    return [t[0], t[1], t[2]];
+  }
+  pointToArray(t) {
+    return this._valueType === T.Z ? [t.x, t.y, t.z] : [t.x, t.y, t.m];
+  }
+  vectorToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = this._valueType === T.Z ? t[2] : void 0, e.m = this._valueType === T.M ? t[2] : void 0, e.spatialReference = this.spatialReference, e;
+  }
+  arrayToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = this._valueType === T.Z ? t[2] : void 0, e.m = this._valueType === T.M ? t[2] : void 0, e.spatialReference = this.spatialReference, e;
+  }
+  vectorToDehydratedPoint(t, e) {
+    if (!t)
+      return;
+    e ?? (e = { x: void 0, y: void 0, z: void 0, m: void 0, hasZ: void 0, hasM: void 0, spatialReference: void 0, type: "point" });
+    const s = this._valueType === T.Z, i = this._valueType === T.M;
+    return e.x = t[0], e.y = t[1], e.z = s ? t[2] : void 0, e.m = i ? t[2] : void 0, e.hasZ = s, e.hasM = i, e.spatialReference = this.spatialReference, e;
+  }
+  lerp(t, e, s, i) {
+    return Is(i, t, e, s);
+  }
+  addDelta(t, e, s, i) {
+    t[0] += e, t[1] += s, this._valueType === T.Z && (t[2] += i);
+  }
+  distance(t, e) {
+    return this._valueType === T.Z ? ue(t, e) : Pn(t, e);
+  }
+  getZ(t, e = void 0) {
+    return this._valueType === T.Z ? t[2] : e;
+  }
+  hasZ() {
+    return this._valueType === T.Z;
+  }
+  getM(t, e = void 0) {
+    return this._valueType === T.M ? t[2] : e;
+  }
+  hasM() {
+    return this._valueType === T.M;
+  }
+  clone(t) {
+    return this._tag(Ds(t));
+  }
+  copy(t, e) {
+    return $t(e, t);
+  }
+  fromXYZ(t, e = 0, s = 0) {
+    return this._tag(X(t[0], t[1], this._valueType === T.Z ? t.length > 2 ? t[2] : e : s));
+  }
+  toXYZ(t, e = g()) {
+    return P(e, t[0], t[1], this._valueType === T.Z ? t[2] : 0);
+  }
+  pointToXYZ(t, e = g()) {
+    return P(e, t.x, t.y, this._valueType === T.Z ? t.z ?? 0 : 0);
+  }
+  equals(t, e) {
+    return oe(t, e);
+  }
+  _tag(t) {
+    return t;
+  }
+}, er = class {
+  constructor(t) {
+    this.spatialReference = t;
+  }
+  createVector() {
+    return this._tag(Un());
+  }
+  pointToVector(t) {
+    return this._tag(Ee(t.x, t.y, t.z, t.m));
+  }
+  arrayToVector(t) {
+    return this._tag(Ee(t[0], t[1], t[2] || 0, t[3] || 0));
+  }
+  vectorToArray(t) {
+    return [t[0], t[1], t[2], t[3]];
+  }
+  pointToArray(t) {
+    return [t.x, t.y, t.z, t.m];
+  }
+  vectorToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = t[2], e.m = t[3], e.spatialReference = this.spatialReference, e;
+  }
+  arrayToPoint(t, e = new Rt()) {
+    return e.x = t[0], e.y = t[1], e.z = t[2], e.m = t[3], e.spatialReference = this.spatialReference, e;
+  }
+  vectorToDehydratedPoint(t, e) {
+    if (t)
+      return e ?? (e = { x: void 0, y: void 0, z: void 0, m: void 0, hasZ: void 0, hasM: void 0, spatialReference: void 0, type: "point" }), e.x = t[0], e.y = t[1], e.z = t[2], e.m = t[3], e.hasZ = !0, e.hasM = !0, e.spatialReference = this.spatialReference, e;
+  }
+  lerp(t, e, s, i) {
+    return Mi(i, t, e, s);
+  }
+  addDelta(t, e, s, i) {
+    t[0] += e, t[1] += s, t[2] += i;
+  }
+  distance(t, e) {
+    return ue(t, e);
+  }
+  getZ(t) {
+    return t[2];
+  }
+  hasZ() {
+    return !0;
+  }
+  getM(t) {
+    return t[3];
+  }
+  hasM() {
+    return !0;
+  }
+  clone(t) {
+    return this._tag(Ai(t));
+  }
+  copy(t, e) {
+    return wi(e, t);
+  }
+  fromXYZ(t, e = 0, s = 0) {
+    return this._tag(Ee(t[0], t[1], t.length > 2 ? t[2] : e, s));
+  }
+  toXYZ(t, e = g()) {
+    return P(e, t[0], t[1], t[2]);
+  }
+  pointToXYZ(t, e = g()) {
+    return P(e, t.x, t.y, t.z ?? 0);
+  }
+  equals(t, e) {
+    return bi(t, e);
+  }
+  _tag(t) {
+    return t;
+  }
+};
+function nr(n, t, e) {
+  return n && t ? new er(e) : t ? new un(T.M, e) : n ? new un(T.Z, e) : new tr(e);
+}
+function sr(n, t) {
+  if (!t.supported)
+    return;
+  let e = 1 / 0, s = -1 / 0;
+  const i = t.upperBoundX - t.lowerBoundX;
+  n.forEach((o) => {
+    let a = o.pos[0];
+    for (; a < t.lowerBoundX; )
+      a += i;
+    for (; a > t.upperBoundX; )
+      a -= i;
+    e = Math.min(e, a), s = Math.max(s, a), o.pos[0] = a;
+  });
+  const r = s - e;
+  i - r < r && n.forEach((o) => {
+    o.pos[0] < 0 && (o.pos[0] += i);
+  });
+}
+function ir(n, t) {
+  const e = Zs(n);
+  return t === Os.Global && e ? { supported: !0, lowerBoundX: e.valid[0], upperBoundX: e.valid[1] } : { supported: !1, lowerBoundX: null, upperBoundX: null };
+}
+let Ft = class {
+  constructor(t) {
+    this.component = t, this.leftEdge = null, this.rightEdge = null, this.type = "vertex", this.index = null;
+  }
+  get pos() {
+    return this._pos;
+  }
+  set pos(t) {
+    this._pos = t, this.component.unnormalizeVertexPositions();
+  }
+}, _t = class {
+  constructor(t, e, s) {
+    this.component = t, this.leftVertex = e, this.rightVertex = s, this.type = "edge", e.rightEdge = this, s.leftEdge = this;
+  }
+}, Me = class {
+  constructor(t, e) {
+    this._spatialReference = t, this._viewingMode = e, this.vertices = [], this.edges = [], this.index = null;
+  }
+  unnormalizeVertexPositions() {
+    this.vertices.length <= 1 || sr(this.vertices, ir(this._spatialReference, this._viewingMode));
+  }
+  updateVertexIndex(t, e) {
+    if (this.vertices.length === 0)
+      return;
+    const s = this.vertices[0];
+    let i = null, r = t, o = e;
+    do
+      i = r, i.index = o++, r = i.rightEdge ? i.rightEdge.rightVertex : null;
+    while (r != null && r !== s);
+    i.leftEdge && i !== this.vertices[this.vertices.length - 1] && this.swapVertices(this.vertices.indexOf(i), this.vertices.length - 1);
+  }
+  getFirstVertex() {
+    return this.vertices.at(0);
+  }
+  getLastVertex() {
+    return this.vertices.at(-1);
+  }
+  isClosed() {
+    return this.vertices.length > 2 && this.vertices[0].leftEdge !== null;
+  }
+  swapVertices(t, e) {
+    const s = this.vertices[t];
+    this.vertices[t] = this.vertices[e], this.vertices[e] = s;
+  }
+  iterateVertices(t) {
+    if (this.vertices.length === 0)
+      return;
+    const e = this.vertices[0];
+    let s = e;
+    do
+      t(s, s.index), s = s.rightEdge != null ? s.rightEdge.rightVertex : null;
+    while (s !== e && s != null);
+  }
+}, rr = class Jn extends Sn {
+  constructor(t, e) {
+    super(), this.type = t, this.coordinateHelper = e, this._geometry = null, this._dirty = !0, this.components = [];
+  }
+  get geometry() {
+    if (this._dirty) {
+      switch (this.type) {
+        case "point":
+          this._geometry = this._toPoint();
+          break;
+        case "polyline":
+          this._geometry = this._toPolyline();
+          break;
+        case "polygon":
+          this._geometry = this._toPolygon();
+      }
+      this._dirty = !1;
+    }
+    return this._geometry;
+  }
+  get spatialReference() {
+    return this.coordinateHelper.spatialReference;
+  }
+  notifyChanges(t) {
+    this._dirty = !0, this.emit("change", t);
+  }
+  _toPoint() {
+    return this.components.length === 0 || this.components[0].vertices.length === 0 ? null : this.coordinateHelper.vectorToPoint(this.components[0].vertices[0].pos);
+  }
+  _toPolyline() {
+    const t = [], e = this.coordinateHelper.vectorToArray;
+    for (const s of this.components) {
+      if (s.vertices.length < 1)
+        continue;
+      const i = [];
+      let r = s.vertices.find((a) => a.leftEdge == null);
+      const o = r;
+      do
+        i.push(e(r.pos)), r = r.rightEdge ? r.rightEdge.rightVertex : null;
+      while (r && r !== o);
+      t.push(i);
+    }
+    return new Tn({ paths: t, spatialReference: this.spatialReference, hasZ: this.coordinateHelper.hasZ(), hasM: this.coordinateHelper.hasM() });
+  }
+  _toPolygon() {
+    const t = [], e = this.coordinateHelper.vectorToArray;
+    for (const s of this.components) {
+      if (s.vertices.length < 1)
+        continue;
+      const i = [], r = s.vertices[0];
+      let o = r;
+      const a = o;
+      do
+        i.push(e(o.pos)), o = o.rightEdge != null ? o.rightEdge.rightVertex : null;
+      while (o && o !== a);
+      s.isClosed() && i.push(e(r.pos)), t.push(i);
+    }
+    return new Vn({ rings: t, spatialReference: this.spatialReference, hasZ: this.coordinateHelper.hasZ(), hasM: this.coordinateHelper.hasM() });
+  }
+  static fromGeometry(t, e) {
+    const s = t.spatialReference, i = nr(t.hasZ, t.hasM, s), r = new Jn(t.type, i);
+    switch (t.type) {
+      case "polygon": {
+        const o = t.rings;
+        for (let a = 0; a < o.length; ++a) {
+          const l = o[a], c = new Me(s, e);
+          c.index = a;
+          const u = l.length > 2 && Xt(l[0], l[l.length - 1]), h = u ? l.length - 1 : l.length;
+          for (let p = 0; p < h; ++p) {
+            const y = i.arrayToVector(l[p]), m = new Ft(c);
+            c.vertices.push(m), m.pos = y, m.index = p;
+          }
+          const d = c.vertices.length - 1;
+          for (let p = 0; p < d; ++p) {
+            const y = c.vertices[p], m = c.vertices[p + 1], v = new _t(c, y, m);
+            c.edges.push(v);
+          }
+          if (u) {
+            const p = new _t(c, c.vertices[c.vertices.length - 1], c.vertices[0]);
+            c.edges.push(p);
+          }
+          r.components.push(c);
+        }
+        break;
+      }
+      case "polyline": {
+        const o = t.paths;
+        for (let a = 0; a < o.length; ++a) {
+          const l = o[a], c = new Me(s, e);
+          c.index = a;
+          const u = l.length;
+          for (let d = 0; d < u; ++d) {
+            const p = i.arrayToVector(l[d]), y = new Ft(c);
+            c.vertices.push(y), y.pos = p, y.index = d;
+          }
+          const h = c.vertices.length - 1;
+          for (let d = 0; d < h; ++d) {
+            const p = c.vertices[d], y = c.vertices[d + 1], m = new _t(c, p, y);
+            c.edges.push(m);
+          }
+          r.components.push(c);
+        }
+        break;
+      }
+      case "point": {
+        const o = new Me(s, e);
+        o.index = 0;
+        const a = new Ft(o);
+        a.index = 0, a.pos = i.pointToVector(t), o.vertices.push(a), r.components.push(o);
+        break;
+      }
+    }
+    return r;
+  }
+};
+var gt;
+(function(n) {
+  n[n.NEW_STEP = 0] = "NEW_STEP", n[n.ACCUMULATE_STEPS = 1] = "ACCUMULATE_STEPS";
+})(gt || (gt = {}));
+let or = class {
+  constructor(t, e, s) {
+    this._editGeometry = t, this._component = e, this._pos = s, this._addedVertex = null, this._originalEdge = null, this._left = null, this._right = null;
+  }
+  apply() {
+    let t = "redo";
+    this._addedVertex == null && (t = "apply", this._addedVertex = new Ft(this._component));
+    const e = this._component.getLastVertex();
+    if (e == null)
+      this._component.vertices.push(this._addedVertex), this._addedVertex.pos = this._pos, this._addedVertex.index = 0;
+    else {
+      let s = null;
+      e.rightEdge && (this._originalEdge = e.rightEdge, s = this._originalEdge.rightVertex, this._component.edges.splice(this._component.edges.indexOf(this._originalEdge), 1)), this._component.vertices.push(this._addedVertex), this._addedVertex.pos = this._pos, this._left == null && (this._left = new _t(this._component, e, this._addedVertex)), this._component.edges.push(this._left), e.rightEdge = this._left, this._originalEdge != null && s != null && (this._right == null && (this._right = new _t(this._component, this._addedVertex, s)), this._component.edges.push(this._right), s.leftEdge = this._right), this._component.updateVertexIndex(this._addedVertex, e.index + 1);
+    }
+    this._editGeometry.notifyChanges({ operation: t, addedVertices: [this._addedVertex] });
+  }
+  undo() {
+    this._addedVertex != null && (this._component.vertices.splice(this._component.vertices.indexOf(this._addedVertex), 1), this._left != null && (this._component.edges.splice(this._component.edges.indexOf(this._left), 1), this._left.leftVertex.rightEdge = null), this._right != null && (this._component.edges.splice(this._component.edges.indexOf(this._right), 1), this._right.rightVertex.leftEdge = null), this._originalEdge != null && (this._component.edges.push(this._originalEdge), this._originalEdge.leftVertex.rightEdge = this._originalEdge, this._originalEdge.rightVertex.leftEdge = this._originalEdge), this._left != null ? this._component.updateVertexIndex(this._left.leftVertex, this._left.leftVertex.index) : this._component.updateVertexIndex(this._addedVertex, 0), this._editGeometry.notifyChanges({ operation: "undo", removedVertices: [this._addedVertex] }));
+  }
+  accumulate() {
+    return !1;
+  }
+}, ar = class Qn {
+  constructor(t, e, s) {
+    this._editGeometry = t, this._vertices = e, this.operation = s, this._undone = !1;
+  }
+  apply() {
+    this._vertices.forEach((t) => this.operation.apply(t)), this._editGeometry.components.forEach((t) => t.unnormalizeVertexPositions()), this._editGeometry.notifyChanges({ operation: this._undone ? "redo" : "apply", updatedVertices: this._vertices });
+  }
+  undo() {
+    this._vertices.forEach((t) => this.operation.undo(t)), this._editGeometry.notifyChanges({ operation: "undo", updatedVertices: this._vertices }), this._undone = !0;
+  }
+  canAccumulate(t) {
+    if (this._undone || t._vertices.length !== this._vertices.length)
+      return !1;
+    for (let e = 0; e < t._vertices.length; ++e)
+      if (t._vertices[e] !== this._vertices[e])
+        return !1;
+    return this.operation.canAccumulate(t.operation);
+  }
+  accumulate(t) {
+    return !!(t instanceof Qn && this.canAccumulate(t)) && (this._vertices.forEach((e) => this.operation.accumulate(e, t.operation)), this.operation.accumulateParams(t.operation), this._editGeometry.components.forEach((e) => e.unnormalizeVertexPositions()), this._editGeometry.notifyChanges({ operation: "apply", updatedVertices: this._vertices }), !0);
+  }
+};
+var ht;
+(function(n) {
+  n[n.CUMULATIVE = 0] = "CUMULATIVE", n[n.REPLACE = 1] = "REPLACE";
+})(ht || (ht = {}));
+let lr = class {
+  constructor(t, e, s = 0) {
+    this._editGeometry = t, this._vertices = e, this._minNumberOfVertices = s, this.removedVertices = null;
+  }
+  apply() {
+    let t = "redo";
+    if (this.removedVertices == null) {
+      const e = this.removedVertices = [];
+      this._vertices.forEach((s) => {
+        const i = this._removeVertex(s);
+        i != null && e.push(i);
+      }), t = "apply";
+    } else
+      this.removedVertices.forEach((e) => {
+        this._removeVertex(e.removedVertex);
+      });
+    this._editGeometry.notifyChanges({ operation: t, removedVertices: this._vertices });
+  }
+  undo() {
+    var t;
+    (t = this.removedVertices) == null || t.forEach((e) => {
+      this._undoRemoveVertex(e);
+    }), this._editGeometry.notifyChanges({ operation: "undo", addedVertices: this._vertices });
+  }
+  accumulate() {
+    return !1;
+  }
+  _removeVertex(t) {
+    const e = t.component;
+    if (e.vertices.length <= this._minNumberOfVertices)
+      return null;
+    const s = { removedVertex: t, createdEdge: null }, i = t.leftEdge, r = t.rightEdge;
+    return e.vertices.splice(e.vertices.indexOf(t), 1), i && (e.edges.splice(e.edges.indexOf(i), 1), i.leftVertex.rightEdge = null), r && (e.edges.splice(e.edges.indexOf(r), 1), r.rightVertex.leftEdge = null), t.index === 0 && r && this._vertices.length > 0 && e.swapVertices(e.vertices.indexOf(r.rightVertex), 0), i && r && (s.createdEdge = new _t(e, i.leftVertex, r.rightVertex), e.edges.push(s.createdEdge)), r && e.updateVertexIndex(r.rightVertex, r.rightVertex.index - 1), s;
+  }
+  _undoRemoveVertex(t) {
+    const e = t.removedVertex, s = t.removedVertex.component, i = e.leftEdge, r = e.rightEdge;
+    t.createdEdge && s.edges.splice(s.edges.indexOf(t.createdEdge), 1), s.vertices.push(e), i && (s.edges.push(i), i.leftVertex.rightEdge = i), r && (s.edges.push(r), r.rightVertex.leftEdge = r), s.updateVertexIndex(e, e.index);
+  }
+}, cr = class {
+  constructor(t, e, s) {
+    this._editGeometry = t, this._edge = e, this._t = s, this.createdVertex = null, this._left = null, this._right = null;
+  }
+  apply() {
+    let t = "redo";
+    const e = this._edge, s = e.component, i = e.leftVertex, r = e.rightVertex;
+    s.edges.splice(s.edges.indexOf(e), 1), this.createdVertex == null && (t = "apply", this.createdVertex = new Ft(e.component)), s.vertices.push(this.createdVertex), this.createdVertex.pos = this._editGeometry.coordinateHelper.lerp(e.leftVertex.pos, e.rightVertex.pos, this._t, this._editGeometry.coordinateHelper.createVector()), this._left == null && (this._left = new _t(s, i, this.createdVertex)), this._left.leftVertex.leftEdge ? s.edges.push(this._left) : s.edges.unshift(this._left), i.rightEdge = this._left, this._right == null && (this._right = new _t(s, this.createdVertex, r)), s.edges.push(this._right), r.leftEdge = this._right, s.updateVertexIndex(this.createdVertex, i.index + 1), this._editGeometry.notifyChanges({ operation: t, addedVertices: [this.createdVertex] });
+  }
+  undo() {
+    if (this.createdVertex == null || this._left == null || this._right == null)
+      return null;
+    const t = this._edge, e = t.component, s = this.createdVertex.leftEdge, i = this.createdVertex.rightEdge, r = s == null ? void 0 : s.leftVertex, o = i == null ? void 0 : i.rightVertex;
+    e.vertices.splice(e.vertices.indexOf(this.createdVertex), 1), e.edges.splice(e.edges.indexOf(this._left), 1), e.edges.splice(e.edges.indexOf(this._right), 1), this._edge.leftVertex.leftEdge ? e.edges.push(this._edge) : e.edges.unshift(this._edge), r && (r.rightEdge = t), o && (o.leftEdge = t), r && e.updateVertexIndex(r, r.index), this._editGeometry.notifyChanges({ operation: "undo", removedVertices: [this.createdVertex] });
+  }
+  accumulate() {
+    return !1;
+  }
+}, hr = class Kn {
+  constructor(t, e, s) {
+    this._editGeometry = t, this._vertex = e, this._pos = s;
+  }
+  apply() {
+    const t = this._originalPosition == null;
+    t && (this._originalPosition = this._vertex.pos), this._apply(t ? "apply" : "redo");
+  }
+  undo() {
+    this._vertex.pos = this._originalPosition, this._editGeometry.notifyChanges({ operation: "undo", updatedVertices: [this._vertex] });
+  }
+  accumulate(t) {
+    return t instanceof Kn && t._vertex === this._vertex && (this._pos = t._pos, this._apply("apply"), !0);
+  }
+  _apply(t) {
+    this._vertex.pos = this._pos, this._editGeometry.components.forEach((e) => e.unnormalizeVertexPositions()), this._editGeometry.notifyChanges({ operation: t, updatedVertices: [this._vertex] });
+  }
+}, ur = class {
+  constructor(t, e) {
+    this._editGeometry = t, this._component = e, this._createdEdge = null;
+  }
+  apply() {
+    let t = "redo";
+    if (this._createdEdge == null) {
+      t = "apply";
+      const e = this._component.getFirstVertex(), s = this._component.getLastVertex();
+      if (this._component.isClosed() || this._component.vertices.length < 3 || e == null || s == null)
+        return;
+      this._createdEdge = new _t(this._component, s, e);
+    }
+    this._createdEdge.leftVertex.rightEdge = this._createdEdge, this._createdEdge.rightVertex.leftEdge = this._createdEdge, this._component.edges.push(this._createdEdge), this._editGeometry.notifyChanges({ operation: t });
+  }
+  undo() {
+    this._createdEdge != null && (Us(this._component.edges, this._createdEdge), this._createdEdge.leftVertex.rightEdge = null, this._createdEdge.rightVertex.leftEdge = null, this._editGeometry.notifyChanges({ operation: "undo" }));
+  }
+  accumulate() {
+    return !1;
+  }
+}, pr = class ts {
+  constructor(t, e, s, i) {
+    this._helper = t, this.dx = e, this.dy = s, this.dz = i;
+  }
+  _move(t, e, s, i) {
+    this._helper.addDelta(t.pos, e, s, i);
+  }
+  apply(t) {
+    this._move(t, this.dx, this.dy, this.dz);
+  }
+  undo(t) {
+    this._move(t, -this.dx, -this.dy, -this.dz);
+  }
+  canAccumulate(t) {
+    return t instanceof ts;
+  }
+  accumulate(t, e) {
+    this._move(t, e.dx, e.dy, e.dz);
+  }
+  accumulateParams(t) {
+    this.dx += t.dx, this.dy += t.dy, this.dz += t.dz;
+  }
+};
+function we(n, t) {
+  return n[0] * t[1] - n[1] * t[0];
+}
+function dr(n, t, e) {
+  const s = kt(e, t) / Pt(e);
+  return Hs(n, e, s);
+}
+function ca(n, t, e, s, i = e) {
+  return C(Lt, s, e), C(le, t, i), dr(Ct, le, Lt), qs(n, i, Ct);
+}
+function ha(n, t, e, s) {
+  C(Lt, t, e);
+  const i = s / kn(Lt);
+  return ct(n, e, Lt, i);
+}
+function fr(n, t) {
+  const e = n.start, s = n.end, i = t.start, r = t.end, o = C(Lt, s, e), a = C(es, r, i), l = we(o, a);
+  if (Math.abs(l) <= _r)
+    return [];
+  const c = C(le, e, i), u = we(a, c) / l, h = we(o, c) / l;
+  if (u >= 0) {
+    if (h >= 0 || t.type === w.LINE)
+      return [ct(Ct, e, o, u)];
+  } else if (n.type === w.LINE && (h >= 0 || t.type === w.LINE))
+    return [ct(Ct, e, o, u)];
+  return [];
+}
+function gr(n, t, e) {
+  const s = [], i = C(Lt, n.end, n.start), r = C(es, n.start, t), o = Pt(i), a = 2 * kt(i, r), l = a * a - 4 * o * (Pt(r) - e * e);
+  if (l === 0) {
+    const c = -a / (2 * o);
+    (n.type === w.LINE || c >= 0) && s.push(ct(Ct, n.start, i, c));
+  } else if (l > 0) {
+    const c = Math.sqrt(l), u = (-a + c) / (2 * o);
+    (n.type === w.LINE || u >= 0) && s.push(ct(Ct, n.start, i, u));
+    const h = (-a - c) / (2 * o);
+    (n.type === w.LINE || h >= 0) && s.push(ct(le, n.start, i, h));
+  }
+  return s;
+}
+var w;
+(function(n) {
+  n[n.RAY = 0] = "RAY", n[n.LINE = 1] = "LINE";
+})(w || (w = {}));
+const _r = 1e-6, Lt = R(), es = R(), le = R(), Ct = R();
+let mr = class ke {
+  get plane() {
+    return this._plane;
+  }
+  get requiresSplitEdgeLeft() {
+    return !this._left.isOriginalDirection;
+  }
+  get requiresSplitEdgeRight() {
+    return !this._right.isOriginalDirection;
+  }
+  get edgeDirection() {
+    return this._edgeDirection;
+  }
+  constructor(t, e, s, i = 0, r = Gt.IMMEDIATE) {
+    this._helper = t, this._planeType = e, this._edge = s, this.distance = i, this._plane = F(), this._offsetPlane = F(), this._minDistance = -1 / 0, this._maxDistance = 1 / 0, this._selectedArrow = 1, r === Gt.IMMEDIATE && this._initialize();
+  }
+  _initialize() {
+    this._initializeNeighbors(), this._initializePlane(), this._initializeDistanceConstraints();
+  }
+  _initializeNeighbors() {
+    var r, o, a, l;
+    const t = this._toXYZ(this._edge.leftVertex.pos), e = this._toXYZ((o = (r = this._edge.leftVertex.leftEdge) == null ? void 0 : r.leftVertex) == null ? void 0 : o.pos), s = this._toXYZ(this._edge.rightVertex.pos), i = this._toXYZ((l = (a = this._edge.rightVertex.rightEdge) == null ? void 0 : a.rightVertex) == null ? void 0 : l.pos);
+    this._edgeDirection = sn(g(), t, s), e ? (this._left = this._computeNeighbor(t, e, this._edgeDirection), this._right = this._computeNeighbor(s, i, this._edgeDirection, this._left)) : (this._right = this._computeNeighbor(s, i, this._edgeDirection), this._left = this._computeNeighbor(t, e, this._edgeDirection, this._right));
+  }
+  _toXYZ(t) {
+    return t != null ? this._helper.toXYZ(t) : null;
+  }
+  _pointToXYZ(t) {
+    return this._toXYZ(this._helper.pointToVector(t));
+  }
+  _computeNeighbor(t, e, s, i) {
+    const r = g();
+    if (e) {
+      sn(r, t, e);
+      const o = !this._passesBisectingAngleThreshold(r, s);
+      return { start: t, end: e, direction: o ? this._bisectVectorsPerpendicular(s, r) : r, isOriginalDirection: !o };
+    }
+    return this._helper.hasZ() ? i && (et(r, s, i.direction), et(r, r, s), Et(r, r), Math.sign(r[1]) !== Math.sign(s[0]) && rn(r, r, -1)) : P(r, -s[1], s[0], 0), { start: t, end: e, direction: r, isOriginalDirection: !0 };
+  }
+  _passesBisectingAngleThreshold(t, e) {
+    const s = Math.abs(Ri(e, t));
+    return s >= pn && s <= Math.PI - pn;
+  }
+  _bisectVectorsPerpendicular(t, e) {
+    const s = z(t, e) < 0 ? t : on(g(), t), i = Math.abs(z(s, e));
+    if (!(i < dn || i > 1 - dn))
+      return this._bisectDirection(s, e);
+    const r = et(g(), s, [0, 0, 1]);
+    return Et(r, r);
+  }
+  _bisectDirection(t, e) {
+    const s = Ot(g(), t, e);
+    return Et(s, s);
+  }
+  _initializePlane() {
+    const t = this._computeNormalDirection(this._left), e = this._computeNormalDirection(this._right);
+    z(t, e) < 0 && on(e, e), Jt(this._left.start, this._bisectDirection(t, e), this._plane);
+  }
+  _computeNormalDirection(t) {
+    const e = et(g(), t.direction, this._edgeDirection);
+    Et(e, e);
+    const s = et(g(), this._edgeDirection, e);
+    return this._planeType === Ne.XY && (s[2] = 0), Et(s, s);
+  }
+  _initializeDistanceConstraints() {
+    this._left.end == null || this.requiresSplitEdgeLeft || this._updateDistanceConstraint(qt(this._plane, this._left.end)), this._right.end == null || this.requiresSplitEdgeRight || this._updateDistanceConstraint(qt(this._plane, this._right.end)), this._updateIntersectDistanceConstraint(this._plane);
+  }
+  _updateDistanceConstraint(t) {
+    t <= 0 && (this._minDistance = Math.max(this._minDistance, t)), t >= 0 && (this._maxDistance = Math.min(this._maxDistance, t));
+  }
+  _updateIntersectDistanceConstraint(t) {
+    const e = Ht(t), s = this._edgeDirection, i = Ot(g(), this._left.start, this._left.direction), r = Ot(g(), this._right.start, this._right.direction), o = this._pointInBasis2D(R(), e, s, this._left.start), a = this._pointInBasis2D(R(), e, s, i), l = this._pointInBasis2D(R(), e, s, this._right.start), c = this._pointInBasis2D(R(), e, s, r), [u] = fr({ start: a, end: o, type: w.LINE }, { start: c, end: l, type: w.LINE });
+    if (!u)
+      return;
+    const h = C(R(), o, a);
+    Fs(h, h);
+    const d = C(R(), u, a), p = kt(h, d), y = Ot(g(), i, rn(g(), this._left.direction, -p)), m = qt(t, y);
+    this._updateDistanceConstraint(m);
+  }
+  _pointInBasis2D(t, e, s, i) {
+    return t[0] = ln(e, i), t[1] = ln(s, i), t;
+  }
+  _offset(t, e) {
+    Number.isFinite(this._minDistance) && (e = Math.max(this._minDistance, e)), Number.isFinite(this._maxDistance) && (e = Math.min(this._maxDistance, e)), $e(this._offsetPlane, this._plane), this._offsetPlane[3] -= e;
+    const s = (r, o, a) => o != null && qe(this._offsetPlane, r, Ot(g(), r, o), a), i = g();
+    (t === this._edge.leftVertex ? s(this._left.start, this._left.direction, i) : s(this._right.start, this._right.direction, i)) && this._helper.copy(this._helper.fromXYZ(i, void 0, this._helper.getM(t.pos)), t.pos);
+  }
+  selectArrowFromStartPoint(t) {
+    this._selectedArrow = qn(this.plane, this._pointToXYZ(t)) ? 1 : -1;
+  }
+  get selectedArrow() {
+    return this._selectedArrow;
+  }
+  signedDistanceToPoint(t) {
+    return qt(this.plane, this._pointToXYZ(t));
+  }
+  apply(t) {
+    this._offset(t, this.distance);
+  }
+  undo(t) {
+    this._offset(t, 0);
+  }
+  canAccumulate(t) {
+    return t instanceof ke && this._edge.leftVertex.index === t._edge.leftVertex.index && this._edge.rightVertex.index === t._edge.rightVertex.index && this._edge.component === t._edge.component && this._maybeEqualsVec3(this._left.direction, t._left.direction) && this._maybeEqualsVec3(this._right.direction, t._right.direction) && oe(Ht(this._plane), Ht(t._plane));
+  }
+  accumulate(t, e) {
+    const s = this._plane[3] - e._plane[3] + e.distance;
+    this._offset(t, s);
+  }
+  accumulateParams(t) {
+    const e = t.distance - t._plane[3];
+    this.distance = e + this._plane[3];
+  }
+  clone() {
+    const t = new ke(this._helper, this._planeType, this._edge, this.distance, Gt.DEFERRED);
+    return $e(t._plane, this._plane), $e(t._offsetPlane, this._offsetPlane), t._maxDistance = this._maxDistance, t._minDistance = this._minDistance, t._left = this._cloneNeighbor(this._left), t._right = this._cloneNeighbor(this._right), t._edgeDirection = $t(g(), this._edgeDirection), t;
+  }
+  _maybeEqualsVec3(t, e) {
+    return t == null && e == null || t != null && e != null && oe(t, e);
+  }
+  _cloneNeighbor({ start: t, end: e, direction: s, isOriginalDirection: i }) {
+    return { start: $t(g(), t), end: e != null ? $t(g(), e) : null, direction: $t(g(), s), isOriginalDirection: i };
+  }
+};
+const pn = Gs(15), dn = 1e-3;
+var Ne, Gt;
+(function(n) {
+  n[n.XYZ = 0] = "XYZ", n[n.XY = 1] = "XY";
+})(Ne || (Ne = {})), function(n) {
+  n[n.IMMEDIATE = 0] = "IMMEDIATE", n[n.DEFERRED = 1] = "DEFERRED";
+}(Gt || (Gt = {}));
+let yr = class ns {
+  constructor(t, e, s = ht.CUMULATIVE) {
+    this.origin = t, this.angle = e, this._accumulationType = s;
+  }
+  _rotate(t, e) {
+    js(t.pos, t.pos, this.origin, e);
+  }
+  apply(t) {
+    this._rotate(t, this.angle);
+  }
+  undo(t) {
+    this._rotate(t, -this.angle);
+  }
+  canAccumulate(t) {
+    return t instanceof ns && Xt(this.origin, t.origin);
+  }
+  accumulate(t, e) {
+    const s = e._accumulationType === ht.REPLACE;
+    this._rotate(t, s ? e.angle - this.angle : e.angle);
+  }
+  accumulateParams(t) {
+    const e = t._accumulationType === ht.REPLACE;
+    this.angle = e ? t.angle : this.angle + t.angle;
+  }
+};
+class Ge {
+  constructor(t, e, s, i, r = ht.CUMULATIVE) {
+    this.origin = t, this.axis1 = e, this.factor1 = s, this.factor2 = i, this._accumulationType = r, this.axis2 = Mt(e[1], -e[0]);
+  }
+  _scale(t, e, s) {
+    an(t.pos, t.pos, this.origin, this.axis1, e), an(t.pos, t.pos, this.origin, this.axis2, s);
+  }
+  apply(t) {
+    this._scale(t, this.factor1, this.factor2);
+  }
+  undo(t) {
+    this._scale(t, 1 / this.factor1, 1 / this.factor2);
+  }
+  canAccumulate(t) {
+    return t instanceof Ge && Xt(this.origin, t.origin) && Xt(this.axis1, t.axis1);
+  }
+  accumulate(t, e) {
+    e._accumulationType === ht.REPLACE ? this._scale(t, e.factor1 / this.factor1, e.factor2 / this.factor2) : this._scale(t, e.factor1, e.factor2);
+  }
+  accumulateParams(t) {
+    const e = t._accumulationType === ht.REPLACE;
+    this.factor1 = e ? t.factor1 : this.factor1 * t.factor1, this.factor2 = e ? t.factor2 : this.factor2 * t.factor2;
+  }
+}
+let vr = class {
+  constructor() {
+    this._operations = [], this._closed = !1;
+  }
+  close() {
+    this._closed = !0;
+  }
+  apply() {
+    for (const t of this._operations)
+      t.apply();
+  }
+  undo() {
+    for (let t = this._operations.length - 1; t >= 0; t--)
+      this._operations[t].undo();
+  }
+  accumulate(t) {
+    if (this._closed)
+      return !1;
+    const e = this._operations.length ? this._operations[this._operations.length - 1] : null;
+    return e && e.accumulate(t) || (this._operations.push(t), t.apply()), !0;
+  }
+};
+class ss extends Sn {
+  constructor(t) {
+    super(), this.data = t, this._undoStack = [], this._redoStack = [], this._listener = this.data.on("change", (e) => {
+      e.addedVertices && this.emit("vertex-add", { type: "vertex-add", vertices: e.addedVertices, operation: e.operation }), e.removedVertices && this.emit("vertex-remove", { type: "vertex-remove", vertices: e.removedVertices, operation: e.operation }), e.updatedVertices && this.emit("vertex-update", { type: "vertex-update", vertices: e.updatedVertices, operation: e.operation });
+    });
+  }
+  destroy() {
+    this._listener.remove();
+  }
+  splitEdge(t, e) {
+    return this._apply(new cr(this.data, t, e));
+  }
+  updateVertices(t, e, s = gt.ACCUMULATE_STEPS) {
+    return this._apply(new ar(this.data, t, e), s);
+  }
+  moveVertices(t, e, s, i, r = gt.ACCUMULATE_STEPS) {
+    return this.updateVertices(t, new pr(this.data.coordinateHelper, e, s, i), r);
+  }
+  scaleVertices(t, e, s, i, r, o = gt.ACCUMULATE_STEPS, a = ht.CUMULATIVE) {
+    return this.updateVertices(t, new Ge(e, s, i, r, a), o);
+  }
+  rotateVertices(t, e, s, i = gt.ACCUMULATE_STEPS, r = ht.CUMULATIVE) {
+    return this.updateVertices(t, new yr(e, s, r), i);
+  }
+  removeVertices(t) {
+    return this._apply(new lr(this.data, t, this._minNumVerticesPerType));
+  }
+  appendVertex(t) {
+    return this.data.components.length === 0 ? null : this._apply(new or(this.data, this.data.components[0], t));
+  }
+  setVertexPosition(t, e) {
+    return this._apply(new hr(this.data, t, e));
+  }
+  offsetEdge(t, e, s, i = gt.ACCUMULATE_STEPS) {
+    return this.updateVertices([e.leftVertex, e.rightVertex], new mr(this.data.coordinateHelper, t, e, s), i);
+  }
+  closeComponent(t) {
+    return this.data.components.includes(t) ? this._apply(new ur(this.data, t)) : null;
+  }
+  canRemoveVertex(t) {
+    return t.vertices.length > this._minNumVerticesPerType;
+  }
+  createUndoGroup() {
+    const t = new vr();
+    return this._apply(t), Xs(() => t.close());
+  }
+  undo() {
+    if (this._undoStack.length > 0) {
+      const t = this._undoStack.pop();
+      return t.undo(), this._redoStack.push(t), t;
+    }
+    return null;
+  }
+  redo() {
+    if (this._redoStack.length > 0) {
+      const t = this._redoStack.pop();
+      return t.apply(), this._undoStack.push(t), t;
+    }
+    return null;
+  }
+  get canUndo() {
+    return this._undoStack.length > 0;
+  }
+  get canRedo() {
+    return this._redoStack.length > 0;
+  }
+  get lastOperation() {
+    return this._undoStack.length > 0 ? this._undoStack[this._undoStack.length - 1] : null;
+  }
+  get _minNumVerticesPerType() {
+    switch (this.data.type) {
+      case "point":
+        return 1;
+      case "polyline":
+        return 2;
+      case "polygon":
+        return 3;
+      default:
+        return 0;
+    }
+  }
+  _apply(t, e = gt.ACCUMULATE_STEPS) {
+    return e !== gt.NEW_STEP && this.lastOperation != null && this.lastOperation.accumulate(t) || (t.apply(), this._undoStack.push(t), this._redoStack = []), t;
+  }
+  static fromGeometry(t, e) {
+    return new ss(rr.fromGeometry(t, e));
+  }
+}
+let xr = class {
+  constructor(t) {
+    this.vertexHandle = null, this.excludeFeature = null, this.visualizer = null, this.selfSnappingZ = null, this.editGeometryOperations = t.editGeometryOperations, this.elevationInfo = t.elevationInfo, this.pointer = t.pointer, this.vertexHandle = t.vertexHandle, this.excludeFeature = t.excludeFeature, this.feature = t.feature, this.visualizer = t.visualizer, this.selfSnappingZ = t.selfSnappingZ;
+  }
+  get coordinateHelper() {
+    return this.editGeometryOperations.data.coordinateHelper;
+  }
+  get spatialReference() {
+    return this.coordinateHelper.spatialReference;
+  }
+};
+const da = { redo: "r", undo: "z", center: "Alt", constraint: "Shift", cancel: "Escape", delete: ["Backspace", "Delete"], complete: "Enter", vertexAdd: "f", pan: " " }, fn = { toggle: "Control" };
+function fa(n) {
+  let t, e, s = [], i = !1;
+  function r(...o) {
+    return i && t === this && Er(o, s) || (e = n.apply(this, o), t = this, s = o, i = !0), e;
+  }
+  return r;
+}
+function Er(n, t) {
+  if (n.length !== t.length)
+    return !1;
+  for (let e = 0; e < n.length; ++e)
+    if (n[e] !== t[e])
+      return !1;
+  return !0;
+}
+function $r(n) {
+  return "declaredClass" in n;
+}
+function gn(n) {
+  return "declaredClass" in n;
+}
+function ga(n) {
+  return n == null ? null : $r(n) ? n : Ys(Mr(n));
+}
+function Mr(n) {
+  const { wkid: t, wkt: e, wkt2: s, latestWkid: i } = n.spatialReference, r = { wkid: t, wkt: e, wkt2: s, latestWkid: i };
+  switch (n.type) {
+    case "point": {
+      const { x: o, y: a, z: l, m: c } = n;
+      return { x: o, y: a, z: l, m: c, spatialReference: r };
+    }
+    case "polygon": {
+      const { rings: o, hasZ: a, hasM: l } = n;
+      return { rings: _n(o), hasZ: a, hasM: l, spatialReference: r };
+    }
+    case "polyline": {
+      const { paths: o, hasZ: a, hasM: l } = n;
+      return { paths: _n(o), hasZ: a, hasM: l, spatialReference: r };
+    }
+    case "extent": {
+      const { xmin: o, xmax: a, ymin: l, ymax: c, zmin: u, zmax: h, mmin: d, mmax: p, hasZ: y, hasM: m } = n;
+      return { xmin: o, xmax: a, ymin: l, ymax: c, zmin: u, zmax: h, mmin: d, mmax: p, hasZ: y, hasM: m, spatialReference: r };
+    }
+    case "multipoint": {
+      const { points: o, hasZ: a, hasM: l } = n;
+      return { points: rs(o) ? is(o) : o, hasZ: a, hasM: l, spatialReference: r };
+    }
+    default:
+      return;
+  }
+}
+function _n(n) {
+  return wr(n) ? n.map((t) => is(t)) : n;
+}
+function is(n) {
+  return n.map((t) => Array.from(t));
+}
+function wr(n) {
+  for (const t of n)
+    if (t.length !== 0)
+      return rs(t);
+  return !1;
+}
+function rs(n) {
+  return n.length > 0 && (Ws(n[0]) || Bs(n[0]));
+}
+function br(n, t) {
+  if (!n)
+    return null;
+  let e;
+  if (gn(n)) {
+    if (t == null)
+      return n.clone();
+    if (gn(t))
+      return t.copy(n);
+  }
+  return t != null ? (e = t, e.x = n.x, e.y = n.y, e.spatialReference = n.spatialReference, n.hasZ ? (e.z = n.z, e.hasZ = n.hasZ) : (e.z = void 0, e.hasZ = !1), n.hasM ? (e.m = n.m, e.hasM = !0) : (e.m = void 0, e.hasM = !1)) : (e = Qt(n.x, n.y, n.z, n.spatialReference), n.hasM && (e.m = n.m, e.hasM = !0)), e;
+}
+function Tr(n) {
+  const { wkid: t, wkt: e, wkt2: s, latestWkid: i } = n, r = { wkid: t, wkt: e, wkt2: s, latestWkid: i };
+  return An.fromJSON(r);
+}
+var ze;
+(function(n) {
+  n[n.EnableFastUpdates = 0] = "EnableFastUpdates", n[n.DisableFastUpdates = 1] = "DisableFastUpdates", n[n.UpdateFastLocalOrigin = 2] = "UpdateFastLocalOrigin";
+})(ze || (ze = {}));
+function os(n, t, e, s) {
+  if (s == null || n.hasZ || (s = void 0), n.type === "point")
+    return n.x += t, n.y += e, n.hasZ && s != null && (n.z += s), n;
+  if (n.type === "multipoint") {
+    const o = n.points;
+    for (let a = 0; a < o.length; a++)
+      o[a] = mn(o[a], t, e, s);
+    return n;
+  }
+  if (n.type === "extent")
+    return n.xmin += t, n.xmax += t, n.ymin += e, n.ymax += e, s != null && (n.zmin ?? (n.zmin = 0), n.zmin += s, n.zmax ?? (n.zmax = 0), n.zmax += s), n;
+  const i = Js(n), r = n.type === "polyline" ? n.paths : n.rings;
+  for (let o = 0; o < i.length; o++) {
+    const a = i[o];
+    for (let l = 0; l < a.length; l++)
+      a[l] = mn(a[l], t, e, s);
+  }
+  return "paths" in n ? n.paths = r : n.rings = r, n;
+}
+function mn(n, t, e, s) {
+  return Vr(n, n[0] + t, n[1] + e, n[2] != null && s != null ? n[2] + s : void 0);
+}
+function Vr(n, t, e, s) {
+  const i = [t, e];
+  return n.length > 2 && i.push(s ?? n[2]), n.length > 3 && i.push(n[3]), i;
+}
+function Ar(n, t) {
+  let e = null, s = null;
+  return (i) => {
+    if (i.action === "cancel")
+      return void (s != null && (s.execute({ action: "cancel" }), e = null, s = null));
+    const r = { action: i.action, screenStart: i.start, screenEnd: i.screenPoint };
+    i.action === "start" && e == null && (e = new Wt(), s = new Wt(), t(n, e, s, i.pointerType, r)), e != null && e.execute(r), i.action === "end" && e != null && (e = null, s = null);
+  };
+}
+function _a(n, t) {
+  return n.events.on("drag", Ar(n, t));
+}
+function ma(n) {
+  let t = null;
+  return (e) => {
+    if (e.action === "start" && (t = Lr(n, e.mapStart.spatialReference)), t == null)
+      return null;
+    const s = e.mapEnd.x - e.mapStart.x, i = e.mapEnd.y - e.mapStart.y, r = e.mapEnd.z - e.mapStart.z;
+    return t.move(s, i, r, e.action), { ...e, translationX: s, translationY: i, translationZ: r };
+  };
+}
+function as(n, t) {
+  return n == null ? null : n.spatialReference.equals(t) ? n.clone() : pe(n, t);
+}
+function Lr(n, t) {
+  const e = n.geometry, s = Tr(t);
+  if (e == null)
+    return null;
+  if (e.type === "mesh")
+    return Rr(n, e, s);
+  const i = as(e, s), r = e.spatialReference;
+  return i == null ? null : { move: (o, a, l) => {
+    const c = os(i.clone(), o, a, l);
+    c.spatialReference.equals(r) ? n.geometry = c : n.geometry = pe(c, r);
+  } };
+}
+function Rr(n, t, e) {
+  if (Di(t.vertexSpace))
+    return Pr(n, t, t.vertexSpace, e);
+  if (!t.spatialReference.equals(e))
+    return null;
+  let s = 0, i = 0, r = 0;
+  return { move: (o, a, l) => {
+    const c = o - s, u = a - i, h = l - r;
+    if (c || u || h) {
+      const d = new Rt(t.anchor.x + c, t.anchor.y + u, (t.anchor.z ?? 0) + h, t.anchor.spatialReference);
+      t.centerAt(d), n.notifyGeometryChanged(), s = o, i = a, r = l;
+    }
+  } };
+}
+function Pr(n, t, e, s) {
+  const i = as(Zi(t.vertexSpace, t.spatialReference), s), r = t.spatialReference;
+  return i == null ? null : { move: (o, a, l, c) => {
+    const u = os(i.clone(), o, a, l);
+    if (u.spatialReference.equals(r))
+      e.origin = X(u.x, u.y, u.z ?? 0);
+    else {
+      const d = pe(u, r);
+      d != null && (e.origin = X(d.x, d.y, d.z ?? 0));
+    }
+    const h = c === "end";
+    n.notifyMeshTransformChanged(h ? { action: ze.UpdateFastLocalOrigin } : {});
+  } };
+}
+function ya(n, t = null, e) {
+  var o;
+  let s = null;
+  const i = t == null || (o = n.spatialReference) != null && o.equals(t) ? (a) => a : (a) => a != null ? pe(a, t) : a, r = { exclude: [], ...e };
+  return (a) => {
+    if (a.action === "start" && (s = i(n.toMap(a.screenStart, r))), s == null)
+      return null;
+    const l = i(n.toMap(a.screenEnd, r));
+    return l != null ? { ...a, mapStart: s, mapEnd: l } : null;
+  };
+}
+function va(n, t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const s of t)
+    e.set(s, Qs(n[s]));
+  return (s) => (e.forEach((i, r) => {
+    n[r] = i;
+  }), s);
+}
+const Sr = () => {
+};
+class Wt {
+  constructor() {
+    this.execute = Sr;
+  }
+  next(t, e = new Wt()) {
+    return t != null && (this.execute = (s) => {
+      const i = t(s);
+      i != null && e.execute(i);
+    }), e;
+  }
+}
+function xa(n, t, e = []) {
+  if (n.type === "2d")
+    return (i) => i;
+  let s = null;
+  return (i) => {
+    i.action === "start" && (s = n.toMap(i.screenStart, { exclude: e }), s != null && (s.z = cn(s, n, t)));
+    const r = n.toMap(i.screenEnd, { exclude: e });
+    r != null && (r.z = cn(r, n, t));
+    const o = s != null && r != null ? { sceneStart: s, sceneEnd: r } : null;
+    return { ...i, scenePoints: o };
+  };
+}
+function je({ start: n, end: t, type: e }, s, i) {
+  const r = [], o = C(ne, t, n), a = C(ge, n, s), l = Pt(o), c = 2 * kt(o, a), u = c * c - 4 * l * (Pt(a) - i * i);
+  if (u === 0) {
+    const h = -c / (2 * l);
+    (e === Y.PLANE || h >= 0) && r.push(ct(R(), n, o, h));
+  } else if (u > 0) {
+    const h = Math.sqrt(u), d = (-c + h) / (2 * l);
+    (e === Y.PLANE || d >= 0) && r.push(ct(R(), n, o, d));
+    const p = (-c - h) / (2 * l);
+    (e === Y.PLANE || p >= 0) && r.push(ct(R(), n, o, p));
+  }
+  return r;
+}
+function ls(n, t) {
+  const e = n.start, s = n.end, i = C(ne, s, e), r = P(me, -i[1], i[0], 0), o = t.start, a = t.end, l = j(Ye, a, o), c = z(l, r), u = P(_s, e[0], e[1], 0), h = j(ms, u, o), d = z(h, r), p = Yt();
+  if (Math.abs(c) < p)
+    return [];
+  const y = O(ys, o, l, d / c);
+  if (t.type === w.RAY) {
+    const m = j(Ce, y, o);
+    if (z(m, l) < -p)
+      return [];
+  }
+  if (n.type === Y.HALF_PLANE) {
+    const m = Ks(ge, y, e);
+    if (kt(m, i) < -p)
+      return [];
+  }
+  return [bt(y)];
+}
+function kr(n, t) {
+  return zr(ce(We, t[2], n), t);
+}
+function cs(n, t) {
+  return fs(ce(We, 0, n), ce(Zr, 0, t)).map(([s, i]) => Mt(s, i));
+}
+function hs(n, t) {
+  return ps(n, ce(We, n[2], t));
+}
+function us(n, t, e) {
+  const s = C(ne, n, t), i = kn(s), r = i === 0 ? 1 : e / i, o = g();
+  return ct(o, t, s, r), o[2] = n[2], o;
+}
+function ps(n, { start: t, end: e, type: s }, i = g()) {
+  const r = j(_e, n, t), o = j(me, e, t), a = z(r, o) / z(o, o);
+  return O(i, t, o, s === w.RAY ? Math.max(a, 0) : a);
+}
+const Nr = (() => {
+  const n = g(), t = g(), e = g();
+  return ({ start: s, end: i }, { center: r, radius: o, normal: a, slicePlane: l }) => {
+    const c = Jt(r, a, Dr);
+    if ($(Pe(c, s), 0) && $(Pe(c, i), 0)) {
+      Gn(a, n, t);
+      const h = (y, m) => (Oe(e, m, r), Nn(y, z(e, n), z(e, t)), y), d = gr({ start: h(ne, s), end: h(ge, i), type: w.LINE }, ti, o), p = [];
+      for (const [y, m] of d) {
+        const v = $t(g(), r);
+        O(v, v, n, y), O(v, v, t, m), l && !wt(l, v) || p.push(v);
+      }
+      return p;
+    }
+    const u = g();
+    return qe(c, s, i, u) ? !$(ue(u, r), o) || l && !wt(l, u) ? [] : [u] : [];
+  };
+})();
+function ds({ start: n, end: t, type: e }, s, i) {
+  const r = [], o = Oe(_e, t, n), a = C(ge, n, s), l = Pt(o), c = 2 * kt(o, a), u = c * c - 4 * l * (Pt(a) - i * i);
+  if (u === 0) {
+    const h = -c / (2 * l);
+    (e === w.LINE || h >= 0) && r.push(O(g(), n, o, h));
+  } else if (u > 0) {
+    const h = Math.sqrt(u), d = (-c + h) / (2 * l);
+    (e === w.LINE || d >= 0) && r.push(O(g(), n, o, d));
+    const p = (-c - h) / (2 * l);
+    (e === w.LINE || p >= 0) && r.push(O(g(), n, o, p));
+  }
+  return r;
+}
+function fs(n, t) {
+  const e = n.start, s = n.end, i = t.start, r = t.end, o = j(_e, s, e), a = j(me, r, i), l = j(Ye, i, e), c = et(_s, o, a);
+  if (!$(z(l, c), 0))
+    return [];
+  const u = Le(c);
+  if ($(u, 0))
+    return [];
+  const h = et(ms, l, a), d = z(h, c) / u, p = O(ys, e, o, d);
+  if (n.type === w.RAY) {
+    const y = j(Ce, p, e);
+    if (z(o, y) < -Yt())
+      return [];
+  }
+  if (t.type === w.RAY) {
+    const y = j(Ce, p, i);
+    if (z(a, y) < -Yt())
+      return [];
+  }
+  return [bt(p)];
+}
+function zr({ start: n, end: t, type: e }, s) {
+  const i = j(_e, s, n), r = j(me, t, n), o = et(Ye, r, i), a = Le(o) / Le(r), l = Yt();
+  if (a < l)
+    switch (e) {
+      case w.LINE:
+        return [bt(s)];
+      case w.RAY:
+        return z(r, i) < -l ? [] : [bt(s)];
+    }
+  return [];
+}
+function Xe(n, t, e, s) {
+  const [i, r] = n, [o, a] = e, l = o - i, c = a - r, u = l * l + c * c, h = Math.sqrt(u);
+  if (h > t + s)
+    return [];
+  if (h < Math.abs(t - s))
+    return [];
+  if ($(h, 0) && $(t, s))
+    return [];
+  const d = (t * t - s * s + u) / (2 * h), p = Math.sqrt(t * t - d * d), y = p * c / h, m = p * l / h, [v, x] = Rn(ne, n, e, d / h);
+  return $(y, m) ? [Mt(v, x)] : [Mt(v + y, x - m), Mt(v - y, x + m)];
+}
+function ce(n, t, { start: e, end: s, type: i }) {
+  return P(n.start, e[0], e[1], t), P(n.end, s[0], s[1], t), n.type = Ir[i], n;
+}
+function gs(n, t) {
+  return $(n[2], t[2]);
+}
+function $(n, t) {
+  return Ut(Math.abs(n - t), 0, Yt());
+}
+function Cr(n, t) {
+  return t.filter((e) => wt(n, e));
+}
+function wt(n, t) {
+  return qn(n, t);
+}
+var Y;
+(function(n) {
+  n[n.PLANE = 0] = "PLANE", n[n.HALF_PLANE = 1] = "HALF_PLANE";
+})(Y || (Y = {}));
+const Ir = { [Y.PLANE]: w.LINE, [Y.HALF_PLANE]: w.RAY }, ne = R(), ge = R(), _e = g(), me = g(), Ye = g(), _s = g(), ms = g(), ys = g(), Ce = g(), Dr = F(), We = { start: g(), end: g(), type: w.LINE }, Zr = { start: g(), end: g(), type: w.LINE };
+class it {
+  intersect(t) {
+    return ut(this, t);
+  }
+  closestPoints(t) {
+    return [this.closestTo(t)];
+  }
+}
+class se extends it {
+  constructor(t) {
+    super(), this.point = t;
+  }
+  equals(t) {
+    return this === t || tt(t) && V(this.point, t.point);
+  }
+  closestTo() {
+    return Nt(this.point);
+  }
+}
+class Be extends it {
+  constructor(t, e, s) {
+    super(), this.start = t, this.end = e, this.lineLike = { start: t, end: e, type: s };
+  }
+  equals(t) {
+    return this === t || ot(t) && this.lineLike.type === t.lineLike.type && V(this.start, t.start) && V(this.end, t.end);
+  }
+  closestTo(t) {
+    const e = ps(t, this.lineLike);
+    return e;
+  }
+}
+class vs extends Be {
+  constructor(t, e) {
+    super(t, e, w.LINE);
+  }
+}
+class Or extends Be {
+  constructor(t, e) {
+    super(t, e, w.RAY);
+  }
+}
+class xs extends it {
+  constructor(t) {
+    super(), this.constraints = t;
+  }
+  equals(t) {
+    return this === t || Ie(t) && Xt(this.constraints, t.constraints, (e, s) => e.equals(s));
+  }
+  closestTo(t) {
+    let e, s = 1 / 0;
+    for (const i of this.constraints) {
+      const r = i.closestTo(t), o = Re(t, r);
+      o < s && (s = o, e = r);
+    }
+    return e ? Nt(e) : t;
+  }
+  closestPoints(t) {
+    return this.constraints.flatMap((e) => e === this ? [] : e.closestPoints(t));
+  }
+}
+class Ur extends it {
+  constructor(t, e) {
+    super(), this.center = t, this.radius = e;
+  }
+  equals(t) {
+    return this === t || lt(t) && this.center[0] === t.center[0] && this.center[1] === t.center[1] && this.radius === t.radius;
+  }
+  closestTo(t) {
+    const e = us(t, this.center, this.radius);
+    return e;
+  }
+}
+class Je extends it {
+  constructor(t, e) {
+    super(), this.center = t, this.radius = e;
+  }
+  equals(t) {
+    return this === t || dt(t) && V(this.center, t.center) && this.radius === t.radius;
+  }
+  closestTo(t) {
+    const e = us(t, this.center, this.radius);
+    return e[2] = this.center[2], e;
+  }
+  asCircle() {
+    return new Qe(Nt(this.center), this.radius, St(0, 0, 1));
+  }
+}
+class Qe extends it {
+  constructor(t, e, s, i = void 0) {
+    super(), this.center = t, this.radius = e, this.normal = s, this.slicePlane = i;
+  }
+  equals(t) {
+    return this === t || vt(t) && V(this.center, t.center) && V(this.normal, t.normal) && this.radius === t.radius;
+  }
+  closestTo(t) {
+    const { center: e, radius: s } = this;
+    Hn(this.getPlane(qr), t, be);
+    const i = j(be, be, e), r = ni(i);
+    if ($(r, 0))
+      return Nt(t);
+    const o = s / Math.sqrt(r), a = O(g(), e, i, o), { slicePlane: l } = this;
+    if (l && !wt(l, a)) {
+      const c = tn(l, this);
+      return (c == null ? void 0 : c.closestTo(t)) ?? Nt(t);
+    }
+    return a;
+  }
+  getPlane(t = F()) {
+    return Jt(this.center, this.normal, t);
+  }
+}
+const be = g(), qr = F();
+class Hr extends it {
+  constructor(t) {
+    super(), this.z = t;
+  }
+  equals(t) {
+    return this === t || pt(t) && this.z === t.z;
+  }
+  closestTo(t) {
+    return X(t[0], t[1], this.z);
+  }
+  getPlane(t = F()) {
+    return P(yn, 0, 0, this.z), Jt(yn, ii, t);
+  }
+}
+const yn = g();
+class Ke extends it {
+  constructor(t, e, s) {
+    super(), this.start = t, this.end = e, this.planeLike = { start: t, end: e, type: s };
+  }
+  equals(t) {
+    return this === t || at(t) && this.planeLike.type === t.planeLike.type && V(this.start, t.start) && V(this.end, t.end);
+  }
+  closestTo(t) {
+    return hs(t, this.planeLike);
+  }
+  closestEndTo(t) {
+    const { start: e, end: s } = this.planeLike;
+    return Math.sign(kt(C(Fr, s, e), C(Gr, t, e))) > 0 ? this.end : this.start;
+  }
+  getPlane(t = F()) {
+    const e = $t(vn, this.end);
+    return e[2] += 1, Li(this.start, this.end, e, t);
+  }
+  getSlicePlane(t = F()) {
+    const { start: e, end: s, type: i } = this.planeLike;
+    if (i === Y.PLANE)
+      return;
+    const r = P(vn, e[0], e[1], 0), o = P(xn, s[0], s[1], 0), a = Oe(xn, o, r);
+    return Jt(r, a, t), t;
+  }
+}
+const Fr = R(), Gr = R(), vn = g(), xn = g();
+class Ea extends Ke {
+  constructor(t, e) {
+    super(t, e, Y.HALF_PLANE);
+  }
+}
+class $a extends Ke {
+  constructor(t, e) {
+    super(t, e, Y.PLANE);
+  }
+}
+class jr extends it {
+  constructor(t, e) {
+    super(), this.sphere = Si(t, e);
+  }
+  equals(t) {
+    return this === t || ft(t) && ki(this.sphere, t.sphere);
+  }
+  closestTo(t) {
+    const e = Ni(this.sphere, t, g());
+    return e;
+  }
+  get center() {
+    return zi(this.sphere);
+  }
+  get radius() {
+    return this.sphere[3];
+  }
+}
+class Xr extends it {
+  constructor(t, e, s) {
+    super(), this.start = t, this.end = e, this.getZ = s, this.planeLike = { start: t, end: e, type: Y.PLANE };
+  }
+  equals(t) {
+    return this === t || he(t) && V(this.start, t.start) && V(this.end, t.end) && this.getZ === t.getZ;
+  }
+  closestTo(t) {
+    return Qr(this, t);
+  }
+  addIfOnTheGround(t, e) {
+    for (const s of e) {
+      const i = this.getZ(s[0], s[1]) ?? 0;
+      $(s[2], i) && (s[2] = i, t.push(s));
+    }
+  }
+}
+class Yr extends it {
+  constructor(t, e, s, i, r) {
+    super(), this._origin = t, this._spatialReference = e, this._distanceMeters = s, this._elevationMeters = i, this._directionDegrees = r;
+  }
+  equals(t) {
+    return this === t || fo(t) && ri(this._origin, t._origin) && this._distanceMeters === t._distanceMeters && this._elevationMeters === t._elevationMeters && this._directionDegrees === t._directionDegrees;
+  }
+  closestTo([t, e, s]) {
+    if (Nn(mt, t, e), this._directionDegrees != null && this._distanceMeters != null)
+      At(mt, this._origin, this._directionDegrees, this._distanceMeters, this._spatialReference);
+    else if (this._directionDegrees != null)
+      Br(mt, this._origin, this._directionDegrees, mt, this._spatialReference);
+    else if (this._distanceMeters != null) {
+      const { azimuth: i } = te(Wr, this._origin, mt, this._spatialReference);
+      At(mt, this._origin, i ?? 0, this._distanceMeters, this._spatialReference);
+    }
+    return Xi(mt[0], mt[1], this._elevationMeters ?? s);
+  }
+}
+const mt = [0, 0], Wr = new Kt();
+function Br(n, t, e, s, i) {
+  let { azimuth: r, distance: o } = te(Jr, t, s, i);
+  r ?? (r = 0);
+  let a = o * Math.cos((r - e) * q);
+  a = Math.max(0, a), At(n, t, e, a, i);
+}
+const Jr = new Kt();
+function Qr(n, t) {
+  const e = hs(t, n.planeLike);
+  return e[2] = n.getZ(e[0], e[1]) ?? $s, e;
+}
+function ut(n, t) {
+  if (Ie(n)) {
+    const e = [];
+    for (const s of n.constraints) {
+      const i = s.intersect(t);
+      i && e.push(i);
+    }
+    return en(e);
+  }
+  if (Ie(t))
+    return ut(t, n);
+  if (he(n))
+    return En(n, t);
+  if (he(t))
+    return En(t, n);
+  if (tt(n)) {
+    const { point: e } = n;
+    if (tt(t))
+      return V(e, t.point) ? n : void 0;
+    const s = t.closestTo(e);
+    return oe(s, e) ? n : void 0;
+  }
+  if (ot(n)) {
+    if (tt(t))
+      return ut(t, n);
+    if (ot(t))
+      return st(fs(n.lineLike, t.lineLike));
+    if (pt(t))
+      return Kr(n, t);
+    if (at(t))
+      return st(ls(t.planeLike, n.lineLike));
+    if (lt(t))
+      return st(ds(n.lineLike, t.center, t.radius));
+    if (vt(t))
+      return st(Nr(n.lineLike, t));
+    if (dt(t))
+      return to(n, t);
+    if (ft(t))
+      return eo(n, t);
+  } else if (pt(n)) {
+    if (tt(t) || ot(t))
+      return ut(t, n);
+    if (pt(t))
+      return no(n, t);
+    if (at(t))
+      return so(n, t);
+    if (lt(t))
+      return io(n, t);
+    if (vt(t))
+      return oo(n, t);
+    if (dt(t))
+      return ro(n, t);
+    if (ft(t))
+      return ao(n, t);
+  } else if (at(n)) {
+    if (tt(t) || ot(t) || pt(t))
+      return ut(t, n);
+    if (at(t))
+      return Te(cs(n.planeLike, t.planeLike));
+    if (lt(t))
+      return Te(je(n.planeLike, t.center, t.radius));
+    if (vt(t))
+      return co(n, t);
+    if (dt(t))
+      return lo(n, t);
+    if (ft(t))
+      return ho(n, t);
+  } else if (lt(n)) {
+    if (tt(t) || ot(t) || pt(t) || at(t))
+      return ut(t, n);
+    if (lt(t))
+      return Te(Xe(n.center, n.radius, t.center, t.radius));
+    if (vt(t))
+      return void 0;
+    if (dt(t))
+      return uo(n, t);
+    if (ft(t))
+      return void 0;
+  } else if (vt(n)) {
+    if (tt(t) || ot(t) || pt(t) || at(t) || lt(t))
+      return ut(t, n);
+    if (vt(t))
+      return void 0;
+    if (dt(t))
+      return t.asCircle(), void 0;
+    if (ft(t))
+      return void 0;
+  } else if (dt(n)) {
+    if (tt(t) || ot(t) || pt(t) || at(t) || lt(t) || vt(t))
+      return ut(t, n);
+    if (dt(t))
+      return po(t, n);
+    if (ft(t))
+      return void 0;
+  } else if (ft(n)) {
+    if (tt(t) || ot(t) || pt(t) || at(t) || lt(t) || dt(t))
+      return ut(t, n);
+    if (ft(t))
+      return void 0;
+  }
+}
+const Kr = (() => {
+  const n = F();
+  return (t, e) => {
+    const { start: s, end: i } = t;
+    if (gs(s, i) && $(s[2], e.z))
+      return t;
+    const r = g();
+    return qe(e.getPlane(n), s, i, r) ? new se(r) : void 0;
+  };
+})();
+function to({ lineLike: n }, { center: t, radius: e }) {
+  const s = t[2];
+  return st(ds(n, t, e).filter((i) => $(i[2], s)));
+}
+function eo({ lineLike: n }, { sphere: t }) {
+  return st(Pi(t, n.start, n.end));
+}
+const tn = (() => {
+  const n = Un(), t = g(), e = g();
+  return (s, i, r) => {
+    const { normal: o, center: a, radius: l } = i;
+    Gn(o, t, e);
+    const c = Ht(s), u = l * z(c, t), h = l * z(c, e);
+    Ti(n, a[0], a[1], a[2], 1);
+    const d = Vi(s, n), p = Math.hypot(u, h), y = $(p, 0);
+    if ($(Pe(s, a), 0)) {
+      if (y)
+        return i;
+      if ($(l, 0))
+        return !r || wt(r, a) ? new se(Nt(a)) : void 0;
+      et(t, c, o), Et(t, t);
+      const E = new Array(), k = bt(a);
+      O(k, k, t, l), r && !wt(r, k) || E.push(k);
+      const U = bt(a);
+      return O(U, U, t, -l), r && !wt(r, U) || E.push(U), st(E);
+    }
+    if (y)
+      return;
+    const m = -d / p;
+    if (Math.abs(m) > 1 || $(m, 1))
+      return;
+    const v = Math.atan(u / h), x = si(m) - v, b = Math.PI - x, S = new Array(), I = g();
+    O(I, a, t, l * Math.cos(x)), O(I, I, e, l * Math.sin(x)), S.push(I);
+    const A = g();
+    return O(A, a, t, l * Math.cos(b)), O(A, A, e, l * Math.sin(b)), S.push(A), st(r ? Cr(r, S) : S);
+  };
+})();
+function no(n, t) {
+  return $(n.z, t.z) ? n : void 0;
+}
+function so({ z: n }, { planeLike: t }) {
+  const [e, s] = t.start, [i, r] = t.end, o = St(e, s, n), a = St(i, r, n);
+  return t.type === Y.PLANE ? new vs(o, a) : new Or(o, a);
+}
+function io(n, t) {
+  const [e, s] = t.center;
+  return new Je(St(e, s, n.z), t.radius);
+}
+function ro(n, t) {
+  return $(t.center[2], n.z) ? t : void 0;
+}
+const oo = (() => {
+  const n = F();
+  return (t, e) => tn(t.getPlane(n), e, e.slicePlane);
+})();
+function ao(n, { center: t, radius: e }) {
+  const s = Math.abs(t[2] - n.z);
+  if (s > e && !$(s, e))
+    return;
+  const i = St(t[0], t[1], n.z), r = Math.sqrt(e ** 2 - s ** 2);
+  return $(r, 0) ? void 0 : new Je(i, r);
+}
+const lo = (() => {
+  const n = F();
+  return (t, { center: e, radius: s }) => {
+    const i = je(t.planeLike, e, s), r = e[2];
+    t.getSlicePlane(n);
+    const o = new Array();
+    for (const [a, l] of i) {
+      const c = [a, l, r];
+      wt(n, c) && o.push(c);
+    }
+    return st(o);
+  };
+})(), co = (() => {
+  const n = F(), t = F();
+  return (e, s) => tn(e.getPlane(n), s, e.getSlicePlane(t));
+})(), ho = (() => {
+  const n = F();
+  return (t, { center: e, radius: s }) => {
+    const i = t.getPlane(n), r = qt(i, e), o = Math.abs(r);
+    if (o > s && !$(o, s))
+      return;
+    const a = bt(Ht(i)), l = O(g(), e, a, r), c = Math.sqrt(s ** 2 - r ** 2);
+    return $(c, 0) ? new se(Hn(i, e, g())) : new Qe(l, c, a, t.getSlicePlane());
+  };
+})();
+function uo(n, t) {
+  const e = zn(n.center, t.center);
+  return $(e, 0) && $(n.radius, t.radius) ? t : Es(Xe(n.center, n.radius, t.center, t.radius), t.center[2]);
+}
+function po(n, t) {
+  if (!gs(n.center, t.center))
+    return;
+  const e = zn(n.center, t.center);
+  return $(e, 0) && $(n.radius, t.radius) ? n : Es(Xe(n.center, n.radius, t.center, t.radius), n.center[2]);
+}
+function En(n, t) {
+  const { planeLike: e, getZ: s } = n, i = new Array();
+  if (tt(t))
+    n.addIfOnTheGround(i, kr(e, t.point));
+  else if (ot(t))
+    n.addIfOnTheGround(i, ls(e, t.lineLike));
+  else if (lt(t))
+    for (const [r, o] of je(e, t.center, t.radius)) {
+      const a = s(r, o);
+      a != null && i.push(X(r, o, a));
+    }
+  else if (at(t) || he(t))
+    for (const [r, o] of cs(e, t.planeLike)) {
+      const a = s(r, o) ?? $s;
+      i.push(X(r, o, a));
+    }
+  return st(i);
+}
+function Te(n) {
+  return en(n.map(([t, e]) => {
+    const s = St(t, e, 0), i = St(t, e, 1);
+    return new vs(s, i);
+  }));
+}
+function st(n) {
+  return en(n.map((t) => t ? new se(t) : void 0));
+}
+function Es(n, t) {
+  return st(n.map(([e, s]) => [e, s, t]));
+}
+function en(n) {
+  if (n.length !== 0)
+    return n.length === 1 ? n[0] ?? void 0 : new xs(n.filter(ei));
+}
+function Ie(n) {
+  return n instanceof xs;
+}
+function tt(n) {
+  return n instanceof se;
+}
+function ot(n) {
+  return n instanceof Be;
+}
+function pt(n) {
+  return n instanceof Hr;
+}
+function at(n) {
+  return n instanceof Ke;
+}
+function lt(n) {
+  return n instanceof Ur;
+}
+function dt(n) {
+  return n instanceof Je;
+}
+function vt(n) {
+  return n instanceof Qe;
+}
+function ft(n) {
+  return n instanceof jr;
+}
+function he(n) {
+  return n instanceof Xr;
+}
+function fo(n) {
+  return n instanceof Yr;
+}
+const $s = 0;
+function Ma({ predicate: n = () => !0, snappingManager: t, snappingContext: e, updatingHandles: s, useZ: i = !0 }) {
+  const r = new Wt();
+  if (t == null)
+    return { snappingStep: [$n, r], cancelSnapping: $n };
+  let o, a = null, l = null, c = null;
+  const u = () => {
+    a = oi(a), t.doneSnapping(), l == null || l.frameTask.remove(), l = null, o = ai(o), c = null;
+  }, h = go(t, i, r);
+  let d = null, p = null, y = null;
+  return { snappingStep: [(m) => {
+    if (!n(m))
+      return m;
+    const { action: v } = m;
+    if (v === "start") {
+      const { info: x } = m, b = _o(t.view);
+      if (l = mo(e, m, b), l.context.selfSnappingZ = null, !i && x != null) {
+        const S = vo(e.coordinateHelper, x.handle.component);
+        S != null && (l.context.selfSnappingZ = { value: S, elevationInfo: e.elevationInfo ?? He });
+      }
+    }
+    if (l != null) {
+      const { context: x, originalScenePos: b, originalPos: S } = l, { mapEnd: I, mapStart: A, scenePoints: E } = m, k = Ms(S, De(I, A)), U = De(A, S), D = { ...m, action: "update" }, G = l.context, L = yo(b, E), rt = t.update({ point: k, scenePoint: L, context: x });
+      if (y = rt, ws(I, rt, U, i), d = k, p = L, v !== "end") {
+        const { frameTask: W } = l;
+        a == null && (a = new AbortController()), c = (H) => {
+          s.addPromise(li(h({ frameTask: W, event: D, context: G, point: k, scenePoint: L, delta: U, getLastState: () => ({ point: d, scenePoint: p, updatePoint: H.forceUpdate ? null : y }) }, a.signal)));
+        }, c({ forceUpdate: !1 }), o == null && (o = Ue(() => t.options.effectiveEnabled, () => c == null ? void 0 : c({ forceUpdate: !0 })));
+      }
+    }
+    return v === "end" && u(), m;
+  }, r], cancelSnapping: (m) => (u(), m) };
+}
+function go(n, t, e) {
+  return ci(async ({ frameTask: s, point: i, scenePoint: r, context: o, event: a, delta: l, getLastState: c }, u) => {
+    const h = await s.schedule(() => n.snap({ point: i, scenePoint: r, context: o, signal: u }), u);
+    if (h.valid) {
+      let d = await s.schedule(() => h.apply(), u);
+      const p = c();
+      p.point != null && i !== p.point && (d = n.update({ point: p.point, scenePoint: p.scenePoint, context: o })), p.updatePoint != null && Hi(d, p.updatePoint) || (ws(a.mapEnd, d, l, t), e.execute(a));
+    }
+  });
+}
+function _o(n) {
+  return n.type === "3d" ? n.resourceController.scheduler.registerTask(Oi.SNAPPING) : Ui;
+}
+function mo(n, t, e) {
+  return { context: new xr({ editGeometryOperations: n.editGeometryOperations, elevationInfo: n.elevationInfo, pointer: n.pointer, vertexHandle: t.info != null ? t.info.handle : null, excludeFeature: n.excludeFeature, feature: n.feature, visualizer: n.visualizer }), originalPos: t.snapOrigin != null ? n.coordinateHelper.vectorToDehydratedPoint(t.snapOrigin) : t.mapStart, originalScenePos: t.scenePoints != null ? t.scenePoints.sceneStart : null, frameTask: e };
+}
+function Ms(n, [t, e, s]) {
+  const i = br(n);
+  return i.x += t, i.y += e, i.hasZ && (i.z += s), i;
+}
+function yo(n, t) {
+  return n == null || t == null ? null : Ms(n, De(t.sceneEnd, t.sceneStart));
+}
+function De(n, t) {
+  const e = n.hasZ && t.hasZ ? n.z - t.z : 0;
+  return [n.x - t.x, n.y - t.y, e];
+}
+function ws(n, t, [e, s, i], r) {
+  n.x = t.x + e, n.y = t.y + s, r && n.hasZ && t.hasZ && (n.z = t.z + i);
+}
+function vo(n, t) {
+  if (!n.hasZ())
+    return null;
+  const e = t.vertices;
+  let s = null;
+  for (const i of e) {
+    const r = n.getZ(i.pos);
+    if (s != null && r != null && Math.abs(r - s) > 1e-6)
+      return null;
+    s == null && (s = r);
+  }
+  return s;
+}
+function $n(n) {
+  return n;
+}
+function xo(n, t) {
+  const e = n.x - t.x, s = n.y - t.y;
+  return e * e + s * s;
+}
+function wa(n, t) {
+  return Math.sqrt(xo(n, t));
+}
+function ba(n, t) {
+  t.sort((e, s) => Re(e.targetPoint, n) - Re(s.targetPoint, n));
+}
+var Mn;
+function Ta({ point: n, distance: t, returnEdge: e, vertexMode: s, coordinateHelper: { spatialReference: i }, filter: r }, o, a) {
+  return a = a != null ? a.clone() : new hi({ where: "1=1" }), r && (a.geometry = r.geometry, a.distance = r.distance, a.spatialRelationship = r.spatialRelationship, a.where = ui(a.where, r.where), a.timeExtent = pi(a.timeExtent, r.timeExtent), a.objectIds = Eo(a.objectIds, r.objectIds)), { point: Qt(n[0], n[1], n[2], i.toJSON()), mode: o, distance: t, returnEdge: e, vertexMode: s, query: a.toJSON() };
+}
+function Eo(n, t) {
+  return n || t ? t ? n ? Array.from(di(new Set(n), new Set(t))) : t : n : null;
+}
+function Va(n, t, e) {
+  return { left: hn(n.leftVertex.pos, t, e), right: hn(n.rightVertex.pos, t, e) };
+}
+function Aa(n) {
+  return n.createQuery();
+}
+(function(n) {
+  n[n.TARGET = 0] = "TARGET", n[n.REFERENCE = 1] = "REFERENCE", n[n.REFERENCE_EXTENSION = 2] = "REFERENCE_EXTENSION";
+})(Mn || (Mn = {}));
+const wn = Symbol("snapping-toggle");
+function La(n, t = () => {
+}) {
+  const e = Ue(() => ({ view: n.view, snappingOptions: n.snappingOptions }), ({ view: s, snappingOptions: i }) => {
+    if (n.removeHandles(wn), !s || !i)
+      return;
+    const r = fi.TOOL, o = [s.on("key-down", (a) => {
+      a.key !== fn.toggle || a.repeat || (i.enabledToggled = !0, t());
+    }, r), s.on("key-up", (a) => {
+      a.key === fn.toggle && (i.enabledToggled = !1, t());
+    }, r), s.on("pointer-move", (a) => {
+      const l = a.native.ctrlKey;
+      i.enabledToggled !== l && (i.enabledToggled = l, t());
+    }, r)];
+    n.addHandles(o, wn);
+  }, Cn);
+  n.addHandles(e);
+}
+function Ra(n) {
+  var t;
+  return gi(n) && "utilityNetworks" in n && !!((t = n.utilityNetworks) != null && t.length);
+}
+var bn;
+function Pa(n, t) {
+  if (n == null || t == null)
+    return;
+  const e = $o(n, t);
+  return e != null ? qi(e, "radians", "geographic") : void 0;
+}
+(function(n) {
+  n.Absolute = "absolute", n.Relative = "relative", n.RelativeBilateral = "relative-bilateral";
+})(bn || (bn = {}));
+const $o = (() => {
+  const n = g(), t = g();
+  return (e, s) => (P(n, e.x, e.y, e.z ?? 0), P(t, s.x, s.y, s.z ?? 0), Mo(n, t, e.spatialReference, s.spatialReference));
+})(), Mo = (() => {
+  const n = R(), t = g(), e = g();
+  return (s, i, r, o) => {
+    if (V(s, i))
+      return;
+    const a = Se(r), l = Se(o);
+    if (a && l && Ze(a, l) && ae(s, r, t, a) && ae(i, o, e, l)) {
+      const { azimuth: u } = te(bo, t, e, a);
+      return u != null ? Bt(u, "degrees", "radians") : void 0;
+    }
+    n[0] = i[0] - s[0], n[1] = i[1] - s[1];
+    let c = _i(mi, n);
+    return n[0] < 0 && (c = To - c), c;
+  };
+})(), Sa = (() => {
+  const n = g();
+  return (t, e, s, i, r, o = "geodesic") => {
+    $t(n, e);
+    const a = wo(r);
+    if (o === "geodesic") {
+      const p = Se(s);
+      if (p && ae(n, s, n, p))
+        return At(t, n, a, i, p), t[2] = e[2], !!ae(t, p, t, s);
+    }
+    const l = Fn(a, "geographic", "arithmetic"), c = Bt(l, "degrees", "radians"), u = e[0] + i * Math.cos(c), h = e[1] + i * Math.sin(c), d = e[2];
+    return P(t, u, h, d), !0;
+  };
+})();
+function wo(n) {
+  return n != null ? Fn(Bt(n.value, n.unit, "degrees"), n.rotationType, "geographic") : void 0;
+}
+const bo = new Kt(), To = 2 * Math.PI;
+var Vt;
+(function(n) {
+  n[n.WhenToolEditable = 0] = "WhenToolEditable", n[n.WhenToolNotEditable = 1] = "WhenToolNotEditable", n[n.Always = 2] = "Always";
+})(Vt || (Vt = {}));
+class Vo {
+  constructor() {
+    this._isToolEditable = !0, this._manipulators = new yi(), this._resourceContexts = { manipulator3D: {} }, this._attached = !1;
+  }
+  set isToolEditable(t) {
+    this._isToolEditable = t;
+  }
+  get length() {
+    return this._manipulators.length;
+  }
+  add(t, e = Vt.WhenToolEditable) {
+    this.addMany([t], e);
+  }
+  addMany(t, e = Vt.WhenToolEditable) {
+    for (const s of t) {
+      const i = { manipulator: s, visibilityPredicate: e, attached: !1 };
+      this._manipulators.add(i), this._attached && this._updateManipulatorAttachment(i);
+    }
+  }
+  remove(t) {
+    for (let e = 0; e < this._manipulators.length; e++)
+      if (this._manipulators.at(e).manipulator === t) {
+        const s = this._manipulators.splice(e, 1)[0];
+        this._detachManipulator(s);
+        break;
+      }
+  }
+  removeAll() {
+    this._manipulators.forEach((t) => {
+      this._detachManipulator(t);
+    }), this._manipulators.removeAll();
+  }
+  attach() {
+    this._manipulators.forEach((t) => {
+      this._updateManipulatorAttachment(t);
+    }), this._attached = !0;
+  }
+  detach() {
+    this._manipulators.forEach((t) => {
+      this._detachManipulator(t);
+    }), this._attached = !1;
+  }
+  destroy() {
+    this.detach(), this._manipulators.forEach(({ manipulator: t }) => t.destroy()), this._manipulators.destroy(), this._resourceContexts = null;
+  }
+  on(t, e) {
+    return this._manipulators.on(t, (s) => {
+      e(s);
+    });
+  }
+  forEach(t) {
+    for (const e of this._manipulators.items)
+      t(e);
+  }
+  some(t) {
+    return this._manipulators.items.some(t);
+  }
+  toArray() {
+    const t = [];
+    return this.forEach((e) => t.push(e.manipulator)), t;
+  }
+  intersect(t, e) {
+    let s = null, i = Number.MAX_VALUE;
+    return this._manipulators.forEach(({ manipulator: r, attached: o }) => {
+      if (!o || !r.interactive)
+        return;
+      const a = r.intersectionDistance(t, e);
+      a != null && a < i && (i = a, s = r);
+    }), s;
+  }
+  _updateManipulatorAttachment(t) {
+    this._isManipulatorItemVisible(t) ? this._attachManipulator(t) : this._detachManipulator(t);
+  }
+  _attachManipulator(t) {
+    t.attached || (t.manipulator.attach && t.manipulator.attach(this._resourceContexts), t.attached = !0);
+  }
+  _detachManipulator(t) {
+    if (!t.attached)
+      return;
+    const e = t.manipulator;
+    e.grabbing = !1, e.dragging = !1, e.hovering = !1, e.selected = !1, e.detach && e.detach(this._resourceContexts), t.attached = !1;
+  }
+  _isManipulatorItemVisible(t) {
+    return t.visibilityPredicate === Vt.Always || (this._isToolEditable ? t.visibilityPredicate === Vt.WhenToolEditable : t.visibilityPredicate === Vt.WhenToolNotEditable);
+  }
+}
+let Z = class extends In {
+  constructor(t) {
+    super(t), this.manipulators = new Vo(), this.automaticManipulatorSelection = !0, this.hasGrabbedManipulators = !1, this.hasHoveredManipulators = !1, this.firstGrabbedManipulator = null, this.created = !1, this.removeIncompleteOnCancel = !0, this._editableFlags = /* @__PURE__ */ new Map([[Tt.MANAGER, !0], [Tt.USER, !0]]), this._creationFinishedResolver = vi();
+  }
+  get active() {
+    return this.view != null && this.view.activeTool === this;
+  }
+  set visible(t) {
+    this._get("visible") !== t && (this._set("visible", t), this._syncVisible());
+  }
+  get editable() {
+    return this.getEditableFlag(Tt.USER);
+  }
+  set editable(t) {
+    this.setEditableFlag(Tt.USER, t);
+  }
+  get updating() {
+    return !1;
+  }
+  get cursor() {
+    return null;
+  }
+  get hasFocusedManipulators() {
+    return this.hasGrabbedManipulators || this.hasHoveredManipulators;
+  }
+  destroy() {
+    this.manipulators.destroy(), this._set("view", null);
+  }
+  onAdd() {
+    this._syncVisible();
+  }
+  activate() {
+    this.view != null ? (this.view.focus(), this.onActivate()) : Dn.getLogger(this).error("Can't activate tool if view is not defined.");
+  }
+  deactivate() {
+    this.onDeactivate();
+  }
+  handleInputEvent(t) {
+    this.onInputEvent(t);
+  }
+  handleInputEventAfter(t) {
+    this.onInputEventAfter(t);
+  }
+  setEditableFlag(t, e) {
+    this._editableFlags.set(t, e), this.manipulators.isToolEditable = this.internallyEditable, this._updateManipulatorAttachment(), t === Tt.USER && this.notifyChange("editable"), this.onEditableChange(), this.onManipulatorSelectionChanged();
+  }
+  getEditableFlag(t) {
+    return this._editableFlags.get(t) ?? !1;
+  }
+  whenCreated() {
+    return this._creationFinishedResolver.promise;
+  }
+  onManipulatorSelectionChanged() {
+  }
+  onActivate() {
+  }
+  onDeactivate() {
+  }
+  onShow() {
+  }
+  onHide() {
+  }
+  onEditableChange() {
+  }
+  onInputEvent(t) {
+  }
+  onInputEventAfter(t) {
+  }
+  get internallyEditable() {
+    return this.getEditableFlag(Tt.USER) && this.getEditableFlag(Tt.MANAGER);
+  }
+  finishToolCreation() {
+    this.created || this._creationFinishedResolver.resolve(this), this._set("created", !0);
+  }
+  _syncVisible() {
+    if (this.initialized) {
+      if (this.visible)
+        this._show();
+      else if (this._hide(), this.active)
+        return void (this.view.activeTool = null);
+    }
+  }
+  _show() {
+    this._updateManipulatorAttachment(), this.onShow();
+  }
+  _hide() {
+    this._updateManipulatorAttachment(), this.onHide();
+  }
+  _updateManipulatorAttachment() {
+    this.visible ? this.manipulators.attach() : this.manipulators.detach();
+  }
+};
+f([_({ constructOnly: !0 })], Z.prototype, "view", void 0), f([_({ readOnly: !0 })], Z.prototype, "active", null), f([_({ value: !0 })], Z.prototype, "visible", null), f([_({ value: !0 })], Z.prototype, "editable", null), f([_({ readOnly: !0 })], Z.prototype, "manipulators", void 0), f([_({ readOnly: !0 })], Z.prototype, "updating", null), f([_()], Z.prototype, "cursor", null), f([_({ readOnly: !0 })], Z.prototype, "automaticManipulatorSelection", void 0), f([_()], Z.prototype, "hasFocusedManipulators", null), f([_()], Z.prototype, "hasGrabbedManipulators", void 0), f([_()], Z.prototype, "hasHoveredManipulators", void 0), f([_()], Z.prototype, "firstGrabbedManipulator", void 0), f([_({ readOnly: !0 })], Z.prototype, "created", void 0), f([_({ readOnly: !0 })], Z.prototype, "removeIncompleteOnCancel", void 0), Z = f([It("esri.views.interactive.InteractiveToolBase")], Z);
+let yt = class extends In {
+  constructor(t) {
+    super(t), this.tool = null, this._loggedUnsupportedErrorOnce = !1, this.logger = Dn.getLogger(this), (t == null ? void 0 : t.visible) != null && (this.visible = t.visible);
+  }
+  initialize() {
+    this.addHandles(Ue(() => ({ ready: this.view != null && this.view.ready, supported: this.supported }), ({ ready: t, supported: e }) => {
+      !t || e || this._loggedUnsupportedErrorOnce || (this.logError(this.unsupportedErrorMessage), this._loggedUnsupportedErrorOnce = !0);
+    }, Cn));
+  }
+  destroy() {
+    this.removeTool(), this.view = null;
+  }
+  get active() {
+    return this.tool != null && this.tool.active;
+  }
+  get disabled() {
+    return this.view == null || !this.view.ready || !this.supported;
+  }
+  get supported() {
+    return this.view == null || this.view.type === this.supportedViewType;
+  }
+  get view() {
+    return this._get("view");
+  }
+  set view(t) {
+    if (t === this.view)
+      return;
+    this.removeTool(), this._set("view", t);
+    const e = "tools";
+    this.removeHandles(e), t != null && this.addHandles(t.tools.on("after-remove", (s) => {
+      s.item === this.tool && this._set("tool", null);
+    }), e);
+  }
+  set visible(t) {
+    this._set("visible", t), this.tool != null && (this.tool.visible = t);
+  }
+  createTool(t = { interactive: !1 }) {
+    if (this.removeTool(), this.view == null || !this.view.ready || !this.supported)
+      return;
+    const e = this.constructTool();
+    e.created ? (this._set("tool", e), this.view.tools.add(e)) : t.interactive ? (this._set("tool", e), this.view.addAndActivateTool(e), xi(() => e.created, () => {
+      e.active && this.view != null && (this.view.activeTool = null);
+    }, { initial: !0, once: !0 })) : e.destroy();
+  }
+  removeTool() {
+    var s;
+    const t = this.tool;
+    if (t == null)
+      return;
+    const e = (s = this.view) == null ? void 0 : s.tools;
+    e != null ? e.remove(t) : t.destroy(), this._set("tool", null);
+  }
+  logError(...t) {
+    this.logger.error(...t);
+  }
+};
+f([_({ constructOnly: !0 })], yt.prototype, "tool", void 0), f([_()], yt.prototype, "active", null), f([_()], yt.prototype, "disabled", null), f([_()], yt.prototype, "supported", null), f([_({ value: null })], yt.prototype, "view", null), f([_({ type: Boolean, value: !0 })], yt.prototype, "visible", null), yt = f([It("esri.widgets.support.InteractiveToolViewModel")], yt);
+const Ve = "esri-unit-select", Ae = { base: Ve, label: `${Ve}__label`, select: `${Ve}__select` };
+let xt = class extends Zn {
+  constructor(n, t) {
+    super(n, t), this._onSelectChange = (e) => {
+      this.onChange(e.target.value);
+    };
+  }
+  loadDependencies() {
+    return On({ label: () => import("./calcite-label-10d65c11.js"), option: () => import("./calcite-option-c7d00181.js"), select: () => import("./calcite-select-a96a55a3.js") });
+  }
+  render() {
+    const { messages: n, options: t, selectLabel: e, value: s, _onSelectChange: i } = this;
+    return N("div", { class: Ae.base, key: "units" }, N("calcite-label", { class: Ae.label }, e, N("calcite-select", { class: Ae.select, label: e, onCalciteSelectChange: i }, t.map((r) => {
+      var o;
+      return N("calcite-option", { key: r, selected: r === s, value: r }, $i(r) ? n.systems[r] : (o = n.units[r]) == null ? void 0 : o.pluralCapitalized);
+    }))));
+  }
+};
+f([_()], xt.prototype, "options", void 0), f([_()], xt.prototype, "onChange", void 0), f([_()], xt.prototype, "selectLabel", void 0), f([_()], xt.prototype, "value", void 0), f([_(), Ei("esri/core/t9n/Units")], xt.prototype, "messages", void 0), xt = f([It("esri.widgets.support.UnitSelect")], xt);
+const B = "esri-measurement-widget-content", K = { base: B, actions: `${B}__actions`, error: `${B}__error`, hint: `${B}__hint`, hintText: `${B}__hint-text`, panelError: `${B}__panel--error`, settings: `${B}__settings`, measurement: `${B}__measurement`, measurementItem: `${B}__measurement-item`, measurementItemDisabled: `${B}__measurement-item--disabled`, measurementItemTitle: `${B}__measurement-item__title`, measurementItemValue: `${B}__measurement-item__value` };
+let J = class extends Zn {
+  constructor(n, t) {
+    super(n, t);
+  }
+  loadDependencies() {
+    return On({ button: () => import("./calcite-button-8979d383.js") });
+  }
+  render() {
+    return N("div", { class: K.base }, this._renderContent());
+  }
+  _renderContent() {
+    const { supported: n, active: t, state: e } = this;
+    switch (e) {
+      case "disabled":
+      case "ready":
+        return n ? t ? this._renderHint() : this._renderActions() : this._renderUnsupportedMessage();
+      case "measuring":
+      case "measured":
+        return [this._renderSettings(), this._renderMeasurement(), this._renderActions()];
+    }
+  }
+  _renderUnsupportedMessage() {
+    return N("section", { class: K.error, key: "unsupported" }, N("p", null, this.messages.unsupported));
+  }
+  _renderHint() {
+    const { messages: n } = this;
+    return N("section", { class: K.hint, key: "hint" }, N("p", { class: K.hintText }, n.hint));
+  }
+  _renderSettings() {
+    return N("div", { class: K.settings, key: "settings" }, N(xt, { options: this.unitOptions, selectLabel: this.messages.unit, value: this.unit, onChange: this.onUnitChange }));
+  }
+  _renderMeasurement() {
+    return N("section", { class: K.measurement, key: "measurement" }, this.measurementItems.map((n) => this._renderMeasurementItem(n)));
+  }
+  _renderMeasurementItem({ key: n, title: t, value: e }) {
+    return N("div", { class: this.classes(K.measurementItem, e == null && K.measurementItemDisabled), key: n }, N("span", { class: K.measurementItemTitle }, t), N("span", { "aria-live": "polite", class: K.measurementItemValue }, e ?? this.messages.notApplicable));
+  }
+  _renderActions() {
+    const { messages: n } = this;
+    return N("div", { class: K.actions }, N("calcite-button", { class: this.newMeasurementButtonClass, disabled: this.state === "disabled", onclick: this.onNewMeasurementClick }, n.newMeasurement));
+  }
+};
+f([_()], J.prototype, "active", void 0), f([_()], J.prototype, "measurementItems", void 0), f([_()], J.prototype, "messages", void 0), f([_()], J.prototype, "newMeasurementButtonClass", void 0), f([_()], J.prototype, "onNewMeasurementClick", void 0), f([_()], J.prototype, "onUnitChange", void 0), f([_()], J.prototype, "state", void 0), f([_()], J.prototype, "supported", void 0), f([_()], J.prototype, "unit", void 0), f([_()], J.prototype, "unitOptions", void 0), J = f([It("esri.widgets.support.MeasurementWidgetContent")], J);
+export {
+  Xi as $,
+  da as A,
+  Yi as B,
+  jo as C,
+  Ur as D,
+  wo as E,
+  bn as F,
+  en as G,
+  Sa as H,
+  Ea as I,
+  Pa as J,
+  tt as K,
+  Hi as L,
+  va as M,
+  La as N,
+  Do as O,
+  nr as P,
+  Zo as Q,
+  ji as R,
+  ma as S,
+  Hr as T,
+  Yr as U,
+  ss as V,
+  ga as W,
+  Ji as X,
+  Go as Y,
+  xa as Z,
+  Mn as _,
+  Oo as a,
+  zt as a0,
+  Tr as a1,
+  Xr as a2,
+  vs as a3,
+  Fe as a4,
+  hn as a5,
+  wa as a6,
+  xo as a7,
+  $a as a8,
+  te as a9,
+  Kt as aa,
+  Va as ab,
+  Mo as ac,
+  ps as ad,
+  w as ae,
+  Qi as af,
+  ca as ag,
+  ha as ah,
+  Bi as ai,
+  ya as b,
+  Ho as c,
+  br as d,
+  xr as e,
+  ba as f,
+  rr as g,
+  Ma as h,
+  Vo as i,
+  Aa as j,
+  Ra as k,
+  Z as l,
+  se as m,
+  Ki as n,
+  Fo as o,
+  yt as p,
+  Wo as q,
+  Jo as r,
+  St as s,
+  fa as t,
+  J as u,
+  Uo as v,
+  fe as w,
+  _a as x,
+  Ta as y,
+  Me as z
+};