@agrotools1/at-components 0.3.4 → 0.3.5

package/dist/MagnifierPrograms-123961a3.js

@@ -1,806 +0,0 @@
-import { c as b } from "./WGLContainer-e9e8616e.js";
-import { t as wt } from "./CircularArray-b2bc1dfd.js";
-import { aO as ot, dc as yt, b as x, S as E, e as _, y as v, c as R, jm as lt, g0 as Mt, b9 as pt, fg as bt, g7 as xt, bo as gt, js as H, a$ as Q, p as vt, jt as X, jl as Tt, bg as $t, fj as st, ju as St, jv as Ct, jw as Dt, aS as B, jx as Vt, jy as nt, jz as zt, jA as Et, x as q, jB as ut } from "./index-3b4c2147.js";
-import { a as Rt } from "./testSVGPremultipliedAlpha-ec1f73c4.js";
-import { u as O, O as Lt, Q as It } from "./definitions-a00a3a6c.js";
-import { t as At } from "./AttributeStore-02f947ea.js";
-import { a as Ft } from "./ProgramTemplate-e5ce3b0f.js";
-const se = { shaders: { vertexShader: b("bitBlit/bitBlit.vert"), fragmentShader: b("bitBlit/bitBlit.frag") }, attributes: /* @__PURE__ */ new Map([["a_pos", 0], ["a_tex", 1]]) }, ne = { shaders: { vertexShader: b("stencil/stencil.vert"), fragmentShader: b("stencil/stencil.frag") }, attributes: /* @__PURE__ */ new Map([["a_pos", 0]]) }, oe = { shaders: { vertexShader: b("highlight/textured.vert"), fragmentShader: b("highlight/highlight.frag") }, attributes: /* @__PURE__ */ new Map([["a_position", 0], ["a_texcoord", 1]]) }, ae = { shaders: { vertexShader: b("highlight/textured.vert"), fragmentShader: b("highlight/blur.frag") }, attributes: /* @__PURE__ */ new Map([["a_position", 0], ["a_texcoord", 1]]) }, w = ot("esri-2d-profiler");
-let re = class {
-  constructor(t, e) {
-    if (this._events = new yt(), this._entries = /* @__PURE__ */ new Map(), this._timings = new wt(10), this._currentContainer = null, this._currentPass = null, this._currentBrush = null, this._currentSummary = null, !w)
-      return;
-    this._ext = Rt(t.gl, {}), this._debugOutput = e;
-    const i = t.gl;
-    if (!this.enableCommandLogging)
-      return;
-    let s;
-    for (s in i)
-      if (typeof i[s] == "function") {
-        const n = i[s], r = s.includes("draw");
-        i[s] = (...h) => (this._events.emit("command", { container: this._currentContainer, pass: this._currentPass, brush: this._currentBrush, method: s, args: h, isDrawCommand: r }), this._currentSummary && (this._currentSummary.commands++, r && this._currentSummary.drawCommands++), n.apply(i, h));
-      }
-  }
-  get enableCommandLogging() {
-    return !(typeof w == "object" && w.disableCommands);
-  }
-  recordContainerStart(t) {
-    w && (this._currentContainer = t);
-  }
-  recordContainerEnd() {
-    w && (this._currentContainer = null);
-  }
-  recordPassStart(t) {
-    w && (this._currentPass = t, this._initSummary());
-  }
-  recordPassEnd() {
-    w && (this._currentPass = null, this._emitSummary());
-  }
-  recordBrushStart(t) {
-    w && (this._currentBrush = t);
-  }
-  recordBrushEnd() {
-    w && (this._currentBrush = null);
-  }
-  recordStart(t) {
-    if (w && this._ext != null) {
-      if (this._entries.has(t)) {
-        const i = this._entries.get(t), s = this._ext.resultAvailable(i.query), n = this._ext.disjoint();
-        if (s && !n) {
-          const r = this._ext.getResult(i.query) / 1e6;
-          let h = 0;
-          if (this._timings.enqueue(r) != null) {
-            const l = this._timings.entries, c = l.length;
-            let p = 0;
-            for (const m of l)
-              p += m;
-            h = p / c;
-          }
-          const o = r.toFixed(2), u = h ? h.toFixed(2) : "--";
-          this.enableCommandLogging ? (console.groupCollapsed(`Frame report for ${t}, ${o} ms (${u} last 10 avg)
-${i.commandsLen} Commands (${i.drawCommands} draw)`), console.log("RenderPass breakdown: "), console.table(i.summaries), console.log("Commands: ", i.commands), console.groupEnd()) : console.log(`Frame report for ${t}, ${o} ms (${u} last 10 avg)`), this._debugOutput.innerHTML = `${o} (${u})`;
-        }
-        for (const r of i.handles)
-          r.remove();
-        this._ext.deleteQuery(i.query), this._entries.delete(t);
-      }
-      const e = { name: t, query: this._ext.createQuery(), commands: [], commandsLen: 0, drawCommands: 0, summaries: [], handles: [] };
-      this.enableCommandLogging && (e.handles.push(this._events.on("command", (i) => {
-        e.commandsLen++, e.commands.push(i), i.isDrawCommand && e.drawCommands++;
-      })), e.handles.push(this._events.on("summary", (i) => {
-        e.summaries.push(i);
-      }))), this._ext.beginTimeElapsed(e.query), this._entries.set(t, e);
-    }
-  }
-  recordEnd(t) {
-    w && this._ext != null && this._entries.has(t) && this._ext.endTimeElapsed();
-  }
-  _initSummary() {
-    this.enableCommandLogging && (this._currentSummary = { container: this._currentContainer, pass: this._currentPass, drawCommands: 0, commands: 0 });
-  }
-  _emitSummary() {
-    this.enableCommandLogging && this._currentSummary && this._events.emit("summary", this._currentSummary);
-  }
-};
-const y = 1, Y = 0, k = 1, N = 2;
-let Pt = class {
-  constructor(t, e, i) {
-    this._debugMap = /* @__PURE__ */ new Map(), this._width = t * i, this._height = e * i, this._pixelRatio = i;
-    const s = Math.ceil(this._width / y), n = Math.ceil(this._height / y);
-    this._cols = s, this._rows = n, this._cells = At.create(s * n);
-  }
-  insertMetrics(t) {
-    this._markMetrics(t);
-  }
-  hasCollision(t) {
-    let e = 0;
-    for (const { computedX: i, computedY: s, width: n, height: r } of t.bounds) {
-      const h = (n + O) * this._pixelRatio, o = (r + O) * this._pixelRatio;
-      switch (this._collide(i, s, h, o)) {
-        case N:
-          return N;
-        case k:
-          e++;
-      }
-    }
-    return e === t.bounds.length ? k : Y;
-  }
-  getCellId(t, e) {
-    return t + e * this._cols;
-  }
-  has(t) {
-    return this._cells.has(t);
-  }
-  hasRange(t, e) {
-    return this._cells.hasRange(t, e);
-  }
-  set(t) {
-    this._cells.set(t);
-  }
-  setRange(t, e) {
-    this._cells.setRange(t, e);
-  }
-  _collide(t, e, i, s) {
-    const n = t - i / 2, r = e - s / 2, h = n + i, o = r + s;
-    if (h < 0 || o < 0 || n > this._width || r > this._height)
-      return k;
-    const u = x(Math.floor(n / y), 0, this._cols), l = x(Math.floor(r / y), 0, this._rows), c = x(Math.ceil(h / y), 0, this._cols), p = x(Math.ceil(o / y), 0, this._rows);
-    for (let m = l; m <= p; m++)
-      for (let d = u; d <= c; d++) {
-        const g = this.getCellId(d, m);
-        if (this.has(g))
-          return N;
-      }
-    return Y;
-  }
-  _mark(t, e, i, s, n) {
-    const r = t - i / 2, h = e - s / 2, o = r + i, u = h + s, l = x(Math.floor(r / y), 0, this._cols), c = x(Math.floor(h / y), 0, this._rows), p = x(Math.ceil(o / y), 0, this._cols), m = x(Math.ceil(u / y), 0, this._rows);
-    for (let d = c; d <= m; d++)
-      for (let g = l; g <= p; g++) {
-        const L = this.getCellId(g, d);
-        this._debugMap.set(L, n), this.set(L);
-      }
-    return !1;
-  }
-  _markMetrics(t) {
-    for (const { computedX: e, computedY: i, width: s, height: n } of t.bounds) {
-      const r = (s + O) * this._pixelRatio, h = (n + O) * this._pixelRatio;
-      this._mark(e, i, r, h, t.entityTexel);
-    }
-  }
-};
-const I = 254, U = 255, A = 0;
-function C(a, t) {
-  const e = a.children.slice();
-  e.sort((i, s) => i.tileAge - s.tileAge), e.forEach((i) => {
-    i.labelMetrics != null && i.isReady && t(i, i.labelMetrics);
-  });
-}
-function mt(a, t) {
-  return (!a.minScale || a.minScale >= t) && (!a.maxScale || a.maxScale <= t);
-}
-let Zt = class {
-  run(t, e, i, s) {
-    var r;
-    const n = [];
-    for (let h = t.length - 1; h >= 0; h--) {
-      const o = t[h];
-      (r = o.labelingCollisionInfos) != null && r.length && n.push(...o.labelingCollisionInfos);
-    }
-    ot("esri-2d-update-debug") && n.length && console.debug("CollisionEngine.run"), this._transformMetrics(n), this._runCollision(n, e, i, s);
-    for (const h of n)
-      h.container.requestRender();
-  }
-  _runCollision(t, e, i, s) {
-    const [n, r] = e.state.size, h = new Pt(n, r, e.pixelRatio);
-    for (const { container: o, deconflictionEnabled: u, visible: l } of t) {
-      const c = o.attributeView;
-      u ? l ? (this._prepare(o), this._collideVisible(h, o, i, s), this._collideInvisible(h, o)) : C(o, (p, m) => {
-        for (const d of m)
-          c.setLabelMinZoom(d.entityTexel, U);
-      }) : C(o, (p, m) => {
-        for (const d of m)
-          mt(d, i) ? (c.setLabelMinZoom(d.entityTexel, A), l && h.insertMetrics(d)) : c.setLabelMinZoom(d.entityTexel, I);
-      });
-    }
-  }
-  _isFiltered(t, e, i) {
-    const s = e.getFilterFlags(t), n = !i.hasFilter || !!(s & Lt), r = i.featureEffect == null || i.featureEffect.excludedLabelsVisible || !!(s & It);
-    return !(n && r);
-  }
-  _prepare(t) {
-    const e = t.attributeView, i = /* @__PURE__ */ new Set();
-    C(t, (s, n) => {
-      for (const r of n) {
-        const h = r.entityTexel;
-        if (!i.has(h)) {
-          if (i.add(h), this._isFiltered(h, e, t.layerView)) {
-            e.setLabelMinZoom(h, I);
-            continue;
-          }
-          e.getLabelMinZoom(h) !== A ? e.setLabelMinZoom(h, U) : e.setLabelMinZoom(h, A);
-        }
-      }
-    });
-  }
-  _collideVisible(t, e, i, s) {
-    const n = e.attributeView, r = /* @__PURE__ */ new Set();
-    C(e, (h, o) => {
-      for (let u = 0; u < o.length; u++) {
-        const l = o[u].entityTexel;
-        if (r.has(l))
-          continue;
-        if (h.key.level !== s) {
-          n.setLabelMinZoom(l, I), r.add(l);
-          continue;
-        }
-        if (!mt(o[u], i)) {
-          n.setLabelMinZoom(l, I), r.add(l);
-          continue;
-        }
-        if (n.getLabelMinZoom(l) !== 0) {
-          r.add(l);
-          continue;
-        }
-        let c = !1, p = !0;
-        const m = u;
-        let d = u;
-        for (; d < o.length; d++) {
-          const g = o[d];
-          if (g.entityTexel !== l)
-            break;
-          if (!c)
-            switch (t.hasCollision(g)) {
-              case k:
-                break;
-              case N:
-                c = !0, p = !1;
-                break;
-              case Y:
-                p = !1;
-            }
-        }
-        if (!c)
-          for (let g = m; g < d; g++)
-            t.insertMetrics(o[g]);
-        u = d - 1, p || (r.add(l), n.setLabelMinZoom(l, c ? I : A));
-      }
-    });
-  }
-  _collideInvisible(t, e) {
-    const i = e.attributeView, s = /* @__PURE__ */ new Set();
-    C(e, (n, r) => {
-      for (let h = 0; h < r.length; h++) {
-        const o = r[h].entityTexel;
-        if (s.has(o))
-          continue;
-        if (i.getLabelMinZoom(o) !== U) {
-          s.add(o);
-          continue;
-        }
-        let u = !1, l = !0;
-        const c = h;
-        let p = h;
-        for (; p < r.length; p++) {
-          const m = r[p];
-          if (m.entityTexel !== o)
-            break;
-          if (!u)
-            switch (t.hasCollision(m)) {
-              case k:
-                break;
-              case N:
-                u = !0, l = !1;
-                break;
-              case Y:
-                l = !1;
-            }
-        }
-        if (!u)
-          for (let m = c; m < p; m++)
-            t.insertMetrics(r[m]);
-        h = p - 1, l || (s.add(o), i.setLabelMinZoom(o, u ? U : A));
-      }
-    });
-  }
-  _transformMetrics(t) {
-    for (const { container: e, geometryType: i, vvEvaluators: s } of t)
-      C(e, (n, r) => {
-        var l;
-        const h = e.attributeView, o = n.transforms.labelMat2d;
-        o[4] = Math.round(o[4]), o[5] = Math.round(o[5]);
-        const u = i === "polyline";
-        for (const c of r) {
-          const { entityTexel: p, anchorX: m, anchorY: d } = c;
-          let g = ((l = c.referenceBounds) == null ? void 0 : l.size) ?? 0;
-          const L = s[0];
-          if (L != null) {
-            const f = L(h.getVVSize(p));
-            g = isNaN(f) || f == null || f === 1 / 0 ? g : f;
-          }
-          const rt = c.directionX * (g / 2), ht = c.directionY * (g / 2);
-          for (const f of c.bounds) {
-            let J = m, K = d;
-            if (u) {
-              let $ = J + f.x + rt, S = K + f.y + ht;
-              $ = o[0] * $ + o[2] * S + o[4], S = o[1] * $ + o[3] * S + o[5], f.computedX = Math.floor($), f.computedY = Math.floor(S);
-            } else {
-              J = o[0] * m + o[2] * d + o[4], K = o[1] * m + o[3] * d + o[5];
-              const $ = J + f.x + rt, S = K + f.y + ht;
-              f.computedX = $, f.computedY = S;
-            }
-          }
-        }
-      });
-  }
-};
-const kt = 32;
-let F = class extends E {
-  constructor(t) {
-    super(t), this._lastUpdate = 0, this.collisionEngine = new Zt(), this.lastUpdateId = -1, this.updateRequested = !1, this.view = null;
-  }
-  get updating() {
-    return ot("esri-2d-log-updating") && console.log(`Updating LabelManager ${this.updateRequested}:
--> updateRequested: ${this.updateRequested}`), this.updateRequested;
-  }
-  update(t) {
-    const e = performance.now();
-    e - this._lastUpdate >= kt ? (this._lastUpdate = e, this.doUpdate(t)) : this.requestUpdate();
-  }
-  viewChange() {
-    this.requestUpdate();
-  }
-  requestUpdate() {
-    var t;
-    this.updateRequested || (this.updateRequested = !0, (t = this.view) == null || t.requestUpdate());
-  }
-  processUpdate(t) {
-    this.updateRequested && (this.updateRequested = !1, this.update(t));
-  }
-  doUpdate(t) {
-    const e = this.view;
-    if (e)
-      try {
-        const i = t.state.scale, s = e.featuresTilingScheme.getClosestInfoForScale(i).level;
-        this.collisionEngine.run(e.allLayerViews.items, t, i, s);
-      } catch {
-      }
-  }
-};
-_([v()], F.prototype, "updateRequested", void 0), _([v()], F.prototype, "updating", null), _([v()], F.prototype, "view", void 0), F = _([R("esri.views.2d.LabelManager")], F);
-const j = "esri-zoom-box", G = { container: `${j}__container`, overlay: `${j}__overlay`, background: `${j}__overlay-background`, box: `${j}__outline` }, W = { zoom: "Shift", counter: "Ctrl" };
-let P = class extends E {
-  constructor(t) {
-    super(t), this._container = null, this._overlay = null, this._backgroundShape = null, this._boxShape = null, this._box = { x: 0, y: 0, width: 0, height: 0 }, this._rafId = null, this._redraw = this._redraw.bind(this);
-  }
-  destroy() {
-    this.view = null;
-  }
-  set view(t) {
-    this.removeAllHandles(), this._destroyOverlay(), this._set("view", t), t && this.addHandles([t.on("drag", [W.zoom], (e) => this._handleDrag(e, 1), lt.INTERNAL), t.on("drag", [W.zoom, W.counter], (e) => this._handleDrag(e, -1), lt.INTERNAL)]);
-  }
-  _start() {
-    this._createContainer(), this._createOverlay(), this.navigation.begin();
-  }
-  _update(t, e, i, s) {
-    this._box.x = t, this._box.y = e, this._box.width = i, this._box.height = s, this._rafId || (this._rafId = requestAnimationFrame(this._redraw));
-  }
-  _end(t, e, i, s, n) {
-    const r = this.view, h = r.toMap(Mt(t + 0.5 * i, e + 0.5 * s));
-    let o = Math.max(i / r.width, s / r.height);
-    n === -1 && (o = 1 / o), this._destroyOverlay(), this.navigation.end(), r.goTo({ center: h, scale: r.scale * o });
-  }
-  _updateBox(t, e, i, s) {
-    const n = this._boxShape;
-    n.setAttributeNS(null, "x", "" + t), n.setAttributeNS(null, "y", "" + e), n.setAttributeNS(null, "width", "" + i), n.setAttributeNS(null, "height", "" + s), n.setAttributeNS(null, "class", G.box);
-  }
-  _updateBackground(t, e, i, s) {
-    this._backgroundShape.setAttributeNS(null, "d", this._toSVGPath(t, e, i, s, this.view.width, this.view.height));
-  }
-  _createContainer() {
-    const t = document.createElement("div");
-    t.className = G.container, this.view.root.appendChild(t), this._container = t;
-  }
-  _createOverlay() {
-    const t = this.view.width, e = this.view.height, i = document.createElementNS("http://www.w3.org/2000/svg", "path");
-    i.setAttributeNS(null, "d", "M 0 0 L " + t + " 0 L " + t + " " + e + " L 0 " + e + " Z"), i.setAttributeNS(null, "class", G.background);
-    const s = document.createElementNS("http://www.w3.org/2000/svg", "rect"), n = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-    n.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink"), n.setAttributeNS(null, "class", G.overlay), n.appendChild(i), n.appendChild(s), this._container.appendChild(n), this._backgroundShape = i, this._boxShape = s, this._overlay = n;
-  }
-  _destroyOverlay() {
-    this._container && this._container.parentNode && this._container.parentNode.removeChild(this._container), this._container = this._backgroundShape = this._boxShape = this._overlay = null;
-  }
-  _toSVGPath(t, e, i, s, n, r) {
-    const h = t + i, o = e + s;
-    return "M 0 0 L " + n + " 0 L " + n + " " + r + " L 0 " + r + " ZM " + t + " " + e + " L " + t + " " + o + " L " + h + " " + o + " L " + h + " " + e + " Z";
-  }
-  _handleDrag(t, e) {
-    const i = t.x, s = t.y, n = t.origin.x, r = t.origin.y;
-    let h, o, u, l;
-    switch (i > n ? (h = n, u = i - n) : (h = i, u = n - i), s > r ? (o = r, l = s - r) : (o = s, l = r - s), t.action) {
-      case "start":
-        this._start();
-        break;
-      case "update":
-        this._update(h, o, u, l);
-        break;
-      case "end":
-        this._end(h, o, u, l, e);
-    }
-    t.stopPropagation();
-  }
-  _redraw() {
-    if (!this._rafId || (this._rafId = null, !this._overlay))
-      return;
-    const { x: t, y: e, width: i, height: s } = this._box;
-    this._updateBox(t, e, i, s), this._updateBackground(t, e, i, s), this._rafId = requestAnimationFrame(this._redraw);
-  }
-};
-_([v()], P.prototype, "navigation", void 0), _([v()], P.prototype, "view", null), P = _([R("esri.views.2d.navigation.ZoomBox")], P);
-const Nt = P;
-let T = class {
-  constructor(t) {
-    this._gain = t, this.lastValue = void 0, this.filteredDelta = void 0;
-  }
-  update(t) {
-    if (this.hasLastValue()) {
-      const e = this.computeDelta(t);
-      this._updateDelta(e);
-    }
-    this.lastValue = t;
-  }
-  reset() {
-    this.lastValue = void 0, this.filteredDelta = void 0;
-  }
-  hasLastValue() {
-    return this.lastValue !== void 0;
-  }
-  hasFilteredDelta() {
-    return this.filteredDelta !== void 0;
-  }
-  computeDelta(t) {
-    return this.lastValue === void 0 ? NaN : t - this.lastValue;
-  }
-  _updateDelta(t) {
-    this.filteredDelta !== void 0 ? this.filteredDelta = (1 - this._gain) * this.filteredDelta + this._gain * t : this.filteredDelta = t;
-  }
-}, at = class {
-  constructor(t, e, i) {
-    this._initialVelocity = t, this._stopVelocity = e, this._friction = i, this._duration = Math.abs(Math.log(Math.abs(this._initialVelocity) / this._stopVelocity) / Math.log(1 - this._friction));
-  }
-  get duration() {
-    return this._duration;
-  }
-  isFinished(t) {
-    return t > this.duration;
-  }
-  get friction() {
-    return this._friction;
-  }
-  value(t) {
-    return this.valueFromInitialVelocity(this._initialVelocity, t);
-  }
-  valueDelta(t, e) {
-    const i = this.value(t);
-    return this.value(t + e) - i;
-  }
-  valueFromInitialVelocity(t, e) {
-    e = Math.min(e, this.duration);
-    const i = 1 - this.friction;
-    return t * (i ** e - 1) / Math.log(i);
-  }
-};
-class Bt extends at {
-  constructor(t, e, i, s, n) {
-    super(t, e, i), this._sceneVelocity = s, this.direction = n;
-  }
-  value(t) {
-    return super.valueFromInitialVelocity(this._sceneVelocity, t);
-  }
-}
-class qt {
-  constructor(t = 300, e = 12, i = 0.84) {
-    this._minimumInitialVelocity = t, this._stopVelocity = e, this._friction = i, this.enabled = !0, this._time = new T(0.6), this._screen = [new T(0.4), new T(0.4)], this._scene = [new T(0.6), new T(0.6), new T(0.6)], this._tmpDirection = pt();
-  }
-  add(t, e, i) {
-    if (this.enabled) {
-      if (this._time.hasLastValue() && this._time.computeDelta(i) < 0.015)
-        return;
-      this._screen[0].update(t[0]), this._screen[1].update(t[1]), this._scene[0].update(e[0]), this._scene[1].update(e[1]), this._scene[2].update(e[2]), this._time.update(i);
-    }
-  }
-  reset() {
-    this._screen[0].reset(), this._screen[1].reset(), this._scene[0].reset(), this._scene[1].reset(), this._scene[2].reset(), this._time.reset();
-  }
-  evaluateMomentum() {
-    if (!this.enabled || !this._screen[0].hasFilteredDelta() || !this._time.hasFilteredDelta())
-      return null;
-    const t = this._screen[0].filteredDelta, e = this._screen[1].filteredDelta, i = t == null || e == null ? 0 : Math.sqrt(t * t + e * e), s = this._time.filteredDelta, n = s == null || i == null ? 0 : i / s;
-    return Math.abs(n) < this._minimumInitialVelocity ? null : this.createMomentum(n, this._stopVelocity, this._friction);
-  }
-  createMomentum(t, e, i) {
-    bt(this._tmpDirection, this._scene[0].filteredDelta ?? 0, this._scene[1].filteredDelta ?? 0, this._scene[2].filteredDelta ?? 0);
-    const s = xt(this._tmpDirection);
-    s > 0 && gt(this._tmpDirection, this._tmpDirection, 1 / s);
-    const n = this._time.filteredDelta;
-    return new Bt(t, e, i, n == null ? 0 : s / n, this._tmpDirection);
-  }
-}
-let V = class extends E {
-  constructor(t) {
-    super(t), this.animationTime = 0, this.momentumEstimator = new qt(500, 6, 0.92), this.momentum = null, this.tmpMomentum = pt(), this.momentumFinished = !1, this.viewpoint = new H({ targetGeometry: new Q(), scale: 0, rotation: 0 }), this._previousDrag = null, vt(() => this.momentumFinished, () => this.navigation.stop());
-  }
-  begin(t, e) {
-    this.navigation.begin(), this.momentumEstimator.reset(), this.addToEstimator(e), this._previousDrag = e;
-  }
-  update(t, e) {
-    this.addToEstimator(e);
-    let i = e.center.x, s = e.center.y;
-    const n = this._previousDrag;
-    i = n ? n.center.x - i : -i, s = n ? s - n.center.y : s, t.viewpoint = X(this.viewpoint, t.viewpoint, [i || 0, s || 0]), this._previousDrag = e;
-  }
-  end(t, e) {
-    this.addToEstimator(e);
-    const i = t.navigation.momentumEnabled;
-    this.momentum = i ? this.momentumEstimator.evaluateMomentum() : null, this.animationTime = 0, this.momentum && this.onAnimationUpdate(t), this._previousDrag = null, this.navigation.end();
-  }
-  addToEstimator(t) {
-    const e = t.center.x, i = t.center.y, s = Tt(-e, i), n = $t(-e, i, 0);
-    this.momentumEstimator.add(s, n, 1e-3 * t.timestamp);
-  }
-  onAnimationUpdate(t) {
-    var e;
-    (e = this.navigation.animationManager) == null || e.animateContinous(t.viewpoint, (i, s) => {
-      const { momentum: n, animationTime: r, tmpMomentum: h } = this, o = 1e-3 * s;
-      if (!(this.momentumFinished = !n || n.isFinished(r))) {
-        const u = n.valueDelta(r, o);
-        gt(h, n.direction, u), X(i, i, h), t.constraints.constrainByGeometry(i);
-      }
-      this.animationTime += o;
-    });
-  }
-  stopMomentumNavigation() {
-    this.momentum && (this.momentumEstimator.reset(), this.momentum = null, this.navigation.stop());
-  }
-};
-_([v()], V.prototype, "momentumFinished", void 0), _([v()], V.prototype, "viewpoint", void 0), _([v()], V.prototype, "navigation", void 0), V = _([R("esri.views.2d.navigation.actions.Pan")], V);
-const Ot = V;
-let ft = class {
-  constructor(t = 2.5, e = 0.01, i = 0.95, s = 12) {
-    this._minimumInitialVelocity = t, this._stopVelocity = e, this._friction = i, this._maxVelocity = s, this.enabled = !0, this.value = new T(0.8), this.time = new T(0.3);
-  }
-  add(t, e) {
-    if (this.enabled && e != null) {
-      if (this.time.hasLastValue()) {
-        if (this.time.computeDelta(e) < 0.01)
-          return;
-        if (this.value.hasFilteredDelta()) {
-          const i = this.value.computeDelta(t);
-          this.value.filteredDelta * i < 0 && this.value.reset();
-        }
-      }
-      this.time.update(e), this.value.update(t);
-    }
-  }
-  reset() {
-    this.value.reset(), this.time.reset();
-  }
-  evaluateMomentum() {
-    if (!this.enabled || !this.value.hasFilteredDelta() || !this.time.hasFilteredDelta())
-      return null;
-    let t = this.value.filteredDelta / this.time.filteredDelta;
-    return t = x(t, -this._maxVelocity, this._maxVelocity), Math.abs(t) < this._minimumInitialVelocity ? null : this.createMomentum(t, this._stopVelocity, this._friction);
-  }
-  createMomentum(t, e, i) {
-    return new at(t, e, i);
-  }
-}, Ut = class extends ft {
-  constructor(t = 3, e = 0.01, i = 0.95, s = 12) {
-    super(t, e, i, s);
-  }
-  add(t, e) {
-    const i = this.value.lastValue;
-    if (i != null) {
-      let s = t - i;
-      for (; s > Math.PI; )
-        s -= 2 * Math.PI;
-      for (; s < -Math.PI; )
-        s += 2 * Math.PI;
-      t = i + s;
-    }
-    super.add(t, e);
-  }
-};
-class jt extends at {
-  constructor(t, e, i) {
-    super(t, e, i);
-  }
-  value(t) {
-    const e = super.value(t);
-    return Math.exp(e);
-  }
-  valueDelta(t, e) {
-    const i = super.value(t), s = super.value(t + e) - i;
-    return Math.exp(s);
-  }
-}
-class Gt extends ft {
-  constructor(t = 2.5, e = 0.01, i = 0.95, s = 12) {
-    super(t, e, i, s);
-  }
-  add(t, e) {
-    super.add(Math.log(t), e);
-  }
-  createMomentum(t, e, i) {
-    return new jt(t, e, i);
-  }
-}
-let z = class extends E {
-  constructor(t) {
-    super(t), this._animationTime = 0, this._momentumFinished = !1, this._previousAngle = 0, this._previousRadius = 0, this._previousCenter = null, this._rotationMomentumEstimator = new Ut(0.6, 0.15, 0.95), this._rotationDirection = 1, this._startAngle = 0, this._startRadius = 0, this._updateTimestamp = null, this._zoomDirection = 1, this._zoomMomentumEstimator = new Gt(), this._zoomOnly = null, this.zoomMomentum = null, this.rotateMomentum = null, this.viewpoint = new H({ targetGeometry: new Q(), scale: 0, rotation: 0 }), this.addHandles(vt(() => this._momentumFinished, () => this.navigation.stop()));
-  }
-  begin(t, e) {
-    this.navigation.begin(), this._rotationMomentumEstimator.reset(), this._zoomMomentumEstimator.reset(), this._zoomOnly = null, this._previousAngle = this._startAngle = e.angle, this._previousRadius = this._startRadius = e.radius, this._previousCenter = e.center, this._updateTimestamp = null, t.constraints.rotationEnabled && this.addToRotateEstimator(0, e.timestamp), this.addToZoomEstimator(e, 1);
-  }
-  update(t, e) {
-    this._updateTimestamp === null && (this._updateTimestamp = e.timestamp);
-    const i = e.angle, s = e.radius, n = e.center, r = Math.abs(180 * (i - this._startAngle) / Math.PI), h = Math.abs(s - this._startRadius), o = this._startRadius / s;
-    if (this._previousRadius && this._previousCenter) {
-      const u = s / this._previousRadius;
-      let l = 180 * (i - this._previousAngle) / Math.PI;
-      this._rotationDirection = l >= 0 ? 1 : -1, this._zoomDirection = u >= 1 ? 1 : -1, t.constraints.rotationEnabled ? (this._zoomOnly === null && e.timestamp - this._updateTimestamp > 200 && (this._zoomOnly = h - r > 0), this._zoomOnly === null || this._zoomOnly ? l = 0 : this.addToRotateEstimator(i - this._startAngle, e.timestamp)) : l = 0, this.addToZoomEstimator(e, o), this.navigation.setViewpoint([n.x, n.y], 1 / u, l, [this._previousCenter.x - n.x, n.y - this._previousCenter.y]);
-    }
-    this._previousAngle = i, this._previousRadius = s, this._previousCenter = n;
-  }
-  end(t) {
-    this.rotateMomentum = this._rotationMomentumEstimator.evaluateMomentum(), this.zoomMomentum = this._zoomMomentumEstimator.evaluateMomentum(), this._animationTime = 0, (this.rotateMomentum || this.zoomMomentum) && this.onAnimationUpdate(t), this.navigation.end();
-  }
-  addToRotateEstimator(t, e) {
-    this._rotationMomentumEstimator.add(t, 1e-3 * e);
-  }
-  addToZoomEstimator(t, e) {
-    this._zoomMomentumEstimator.add(e, 1e-3 * t.timestamp);
-  }
-  canZoomIn(t) {
-    const e = t.scale, i = t.constraints.effectiveMaxScale;
-    return i === 0 || e > i;
-  }
-  canZoomOut(t) {
-    const e = t.scale, i = t.constraints.effectiveMinScale;
-    return i === 0 || e < i;
-  }
-  onAnimationUpdate(t) {
-    var e;
-    (e = this.navigation.animationManager) == null || e.animateContinous(t.viewpoint, (i, s) => {
-      const n = !this.canZoomIn(t) && this._zoomDirection > 1 || !this.canZoomOut(t) && this._zoomDirection < 1, r = !this.rotateMomentum || this.rotateMomentum.isFinished(this._animationTime), h = n || !this.zoomMomentum || this.zoomMomentum.isFinished(this._animationTime), o = 1e-3 * s;
-      if (this._momentumFinished = r && h, !this._momentumFinished) {
-        const u = this.rotateMomentum ? Math.abs(this.rotateMomentum.valueDelta(this._animationTime, o)) * this._rotationDirection * 180 / Math.PI : 0;
-        let l = this.zoomMomentum ? Math.abs(this.zoomMomentum.valueDelta(this._animationTime, o)) : 1;
-        const c = B(), p = B();
-        if (this._previousCenter) {
-          st(c, this._previousCenter.x, this._previousCenter.y), St(p, t.size, t.padding), Ct(c, c, p);
-          const { constraints: m, scale: d } = t, g = d * l;
-          l < 1 && !m.canZoomInTo(g) ? (l = d / m.effectiveMaxScale, this.zoomMomentum = null, this.rotateMomentum = null) : l > 1 && !m.canZoomOutTo(g) && (l = d / m.effectiveMinScale, this.zoomMomentum = null, this.rotateMomentum = null), Dt(i, t.viewpoint, l, u, c, t.size), t.constraints.constrainByGeometry(i);
-        }
-      }
-      this._animationTime += o;
-    });
-  }
-  stopMomentumNavigation() {
-    (this.rotateMomentum || this.zoomMomentum) && (this.rotateMomentum && (this._rotationMomentumEstimator.reset(), this.rotateMomentum = null), this.zoomMomentum && (this._zoomMomentumEstimator.reset(), this.zoomMomentum = null), this.navigation.stop());
-  }
-};
-_([v()], z.prototype, "_momentumFinished", void 0), _([v()], z.prototype, "viewpoint", void 0), _([v()], z.prototype, "navigation", void 0), z = _([R("esri.views.2d.navigation.actions.Pinch")], z);
-const Xt = z, tt = B(), ct = B();
-let Z = class extends E {
-  constructor(a) {
-    super(a), this._previousCenter = B(), this.viewpoint = new H({ targetGeometry: new Q(), scale: 0, rotation: 0 });
-  }
-  begin(a, t) {
-    this.navigation.begin(), st(this._previousCenter, t.center.x, t.center.y);
-  }
-  update(a, t) {
-    const { state: { size: e, padding: i } } = a;
-    st(tt, t.center.x, t.center.y), Vt(ct, e, i), a.viewpoint = nt(this.viewpoint, a.state.paddedViewState.viewpoint, zt(ct, this._previousCenter, tt)), Et(this._previousCenter, tt);
-  }
-  end() {
-    this.navigation.end();
-  }
-};
-_([v()], Z.prototype, "viewpoint", void 0), _([v()], Z.prototype, "navigation", void 0), Z = _([R("esri.views.2d.actions.Rotate")], Z);
-const Yt = Z, D = 10, dt = 1, et = new H({ targetGeometry: new Q() }), it = [0, 0], _t = 250;
-let M = class extends E {
-  constructor(a) {
-    super(a), this._endTimer = null, this._lastEventTimestamp = null, this.animationManager = null, this.interacting = !1;
-  }
-  initialize() {
-    this.pan = new Ot({ navigation: this }), this.rotate = new Yt({ navigation: this }), this.pinch = new Xt({ navigation: this }), this.zoomBox = new Nt({ view: this.view, navigation: this });
-  }
-  destroy() {
-    this.pan = q(this.pan), this.rotate = q(this.rotate), this.pinch = q(this.pinch), this.zoomBox = q(this.zoomBox), this.animationManager = null;
-  }
-  begin() {
-    this.stop(), this._set("interacting", !0);
-  }
-  end() {
-    this._lastEventTimestamp = performance.now(), this._startTimer(_t);
-  }
-  async zoom(a, t = this._getDefaultAnchor()) {
-    if (this.begin(), this.view.constraints.snapToZoom && this.view.constraints.effectiveLODs)
-      return a < 1 ? this.zoomIn(t) : this.zoomOut(t);
-    this.setViewpoint(t, a, 0, [0, 0]);
-  }
-  async zoomIn(a) {
-    const t = this.view, e = t.constraints.snapToNextScale(t.scale);
-    return this._zoomToScale(e, a);
-  }
-  async zoomOut(a) {
-    const t = this.view, e = t.constraints.snapToPreviousScale(t.scale);
-    return this._zoomToScale(e, a);
-  }
-  setViewpoint(a, t, e, i) {
-    this.begin(), this.view.stateManager.state.viewpoint = this._scaleRotateTranslateViewpoint(this.view.viewpoint, a, t, e, i), this.end();
-  }
-  setViewpointImmediate(a, t = 0, e = [0, 0], i = this._getDefaultAnchor()) {
-    this.view.stateManager.state.viewpoint = this._scaleRotateTranslateViewpoint(this.view.viewpoint, i, a, t, e);
-  }
-  continousRotateClockwise() {
-    var t;
-    const a = this.view.viewpoint;
-    (t = this.animationManager) == null || t.animateContinous(a, (e) => {
-      nt(e, e, -dt);
-    });
-  }
-  continousRotateCounterclockwise() {
-    var t;
-    const a = this.view.viewpoint;
-    (t = this.animationManager) == null || t.animateContinous(a, (e) => {
-      nt(e, e, dt);
-    });
-  }
-  resetRotation() {
-    this.view.constraints.rotationEnabled && (this.view.rotation = 0);
-  }
-  continousPanLeft() {
-    this._continuousPan([-D, 0]);
-  }
-  continousPanRight() {
-    this._continuousPan([D, 0]);
-  }
-  continousPanUp() {
-    this._continuousPan([0, D]);
-  }
-  continousPanDown() {
-    this._continuousPan([0, -D]);
-  }
-  continuousPanVector({ x: a, y: t }) {
-    this._continuousPan([a * D, t * D]);
-  }
-  stop() {
-    var a;
-    this.pan.stopMomentumNavigation(), (a = this.animationManager) == null || a.stop(), this.end(), this._endTimer !== null && (clearTimeout(this._endTimer), this._endTimer = null, this._set("interacting", !1));
-  }
-  _continuousPan(a) {
-    var e;
-    const t = this.view.viewpoint;
-    (e = this.animationManager) == null || e.animateContinous(t, (i) => {
-      X(i, i, a), this.view.constraints.constrainByGeometry(i);
-    });
-  }
-  _startTimer(a) {
-    return this._endTimer !== null || (this._endTimer = setTimeout(() => {
-      this._endTimer = null;
-      const t = performance.now() - (this._lastEventTimestamp ?? 0);
-      t < _t ? this._endTimer = this._startTimer(t) : this._set("interacting", !1);
-    }, a)), this._endTimer;
-  }
-  _getDefaultAnchor() {
-    const { size: a, padding: { left: t, right: e, top: i, bottom: s } } = this.view;
-    return it[0] = 0.5 * (a[0] - e + t), it[1] = 0.5 * (a[1] - s + i), it;
-  }
-  async _zoomToScale(a, t = this._getDefaultAnchor()) {
-    const { view: e } = this, { constraints: i, scale: s, viewpoint: n, size: r, padding: h } = e, o = i.canZoomInTo(a), u = i.canZoomOutTo(a);
-    if (!(a < s && !o || a > s && !u))
-      return ut(et, n, a / s, 0, t, r, h), i.constrainByGeometry(et), e.goTo(et, { animate: !0, pickClosestTarget: !1 });
-  }
-  _scaleRotateTranslateViewpoint(a, t, e, i, s) {
-    const { view: n } = this, { size: r, padding: h, constraints: o, scale: u, viewpoint: l } = n, c = u * e, p = o.canZoomInTo(c), m = o.canZoomOutTo(c);
-    return (e < 1 && !p || e > 1 && !m) && (e = 1), X(l, l, s), ut(a, l, e, i, t, r, h), o.constrainByGeometry(a);
-  }
-};
-_([v()], M.prototype, "animationManager", void 0), _([v({ type: Boolean, readOnly: !0 })], M.prototype, "interacting", void 0), _([v()], M.prototype, "pan", void 0), _([v()], M.prototype, "pinch", void 0), _([v()], M.prototype, "rotate", void 0), _([v()], M.prototype, "view", void 0), _([v()], M.prototype, "zoomBox", void 0), M = _([R("esri.views.2d.navigation.MapViewNavigation")], M);
-const we = M, Ht = { shaders: { vertexShader: b("magnifier/magnifier.vert"), fragmentShader: b("magnifier/magnifier.frag") }, attributes: /* @__PURE__ */ new Map([["a_pos", 0]]) };
-function ye(a) {
-  return Ft(a, Ht);
-}
-export {
-  ae as a,
-  ye as b,
-  Ht as c,
-  F as d,
-  se as e,
-  we as f,
-  re as n,
-  ne as r,
-  oe as t
-};