gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/control/defaults.mjs

@@ -0,0 +1,12 @@
+import r from "../Collection.mjs";
+import e from "./Attribution.mjs";
+import n from "./Rotate.mjs";
+import u from "./Zoom.mjs";
+function C(t) {
+  t = t || {};
+  const o = new r();
+  return (t.zoom !== void 0 ? t.zoom : !0) && o.push(new u(t.zoomOptions)), (t.rotate !== void 0 ? t.rotate : !0) && o.push(new n(t.rotateOptions)), (t.attribution !== void 0 ? t.attribution : !0) && o.push(new e(t.attributionOptions)), o;
+}
+export {
+  C as defaults
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/coordinate.mjs

@@ -0,0 +1,42 @@
+import { getWidth as l } from "./extent.mjs";
+function A(t, n) {
+  return t[0] += +n[0], t[1] += +n[1], t;
+}
+function h(t, n) {
+  let f = !0;
+  for (let s = t.length - 1; s >= 0; --s)
+    if (t[s] != n[s]) {
+      f = !1;
+      break;
+    }
+  return f;
+}
+function y(t, n) {
+  const f = Math.cos(n), s = Math.sin(n), u = t[0] * f - t[1] * s, r = t[1] * f + t[0] * s;
+  return t[0] = u, t[1] = r, t;
+}
+function e(t, n) {
+  return t[0] *= n, t[1] *= n, t;
+}
+function p(t, n) {
+  if (n.canWrapX()) {
+    const f = l(n.getExtent()), s = w(t, n, f);
+    s && (t[0] -= s * f);
+  }
+  return t;
+}
+function w(t, n, f) {
+  const s = n.getExtent();
+  let u = 0;
+  return n.canWrapX() && (t[0] < s[0] || t[0] > s[2]) && (f = f || l(s), u = Math.floor(
+    (t[0] - s[0]) / f
+  )), u;
+}
+export {
+  A as add,
+  h as equals,
+  w as getWorldsAway,
+  y as rotate,
+  e as scale,
+  p as wrapX
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/css.mjs

@@ -0,0 +1,49 @@
+const m = "ol-hidden", c = "ol-unselectable", g = "ol-control", h = "ol-collapsed", r = new RegExp(
+  [
+    "^\\s*(?=(?:(?:[-a-z]+\\s*){0,2}(italic|oblique))?)",
+    "(?=(?:(?:[-a-z]+\\s*){0,2}(small-caps))?)",
+    "(?=(?:(?:[-a-z]+\\s*){0,2}(bold(?:er)?|lighter|[1-9]00 ))?)",
+    "(?:(?:normal|\\1|\\2|\\3)\\s*){0,3}((?:xx?-)?",
+    "(?:small|large)|medium|smaller|larger|[\\.\\d]+(?:\\%|in|[cem]m|ex|p[ctx]))",
+    "(?:\\s*\\/\\s*(normal|[\\.\\d]+(?:\\%|in|[cem]m|ex|p[ctx])?))",
+    `?\\s*([-,\\"\\'\\sa-z0-9]+?)\\s*$`
+  ].join(""),
+  "i"
+), n = [
+  "style",
+  "variant",
+  "weight",
+  "size",
+  "lineHeight",
+  "family"
+], s = {
+  normal: 400,
+  bold: 700
+}, f = function(o) {
+  const l = o.match(r);
+  if (!l)
+    return null;
+  const e = (
+    /** @type {FontParameters} */
+    {
+      lineHeight: "normal",
+      size: "1.2em",
+      style: "normal",
+      weight: "400",
+      variant: "normal"
+    }
+  );
+  for (let t = 0, a = n.length; t < a; ++t) {
+    const i = l[t + 1];
+    i !== void 0 && (e[n[t]] = typeof i == "string" ? i.trim() : i);
+  }
+  return isNaN(Number(e.weight)) && e.weight in s && (e.weight = s[e.weight]), e.families = e.family.split(/,\s?/).map((t) => t.trim().replace(/^['"]|['"]$/g, "")), e;
+};
+export {
+  h as CLASS_COLLAPSED,
+  g as CLASS_CONTROL,
+  m as CLASS_HIDDEN,
+  c as CLASS_UNSELECTABLE,
+  s as fontWeights,
+  f as getFontParameters
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/dom.mjs

@@ -0,0 +1,112 @@
+var f = Object.defineProperty;
+var l = (n, e, t) => e in n ? f(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var c = (n, e, t) => (l(n, typeof e != "symbol" ? e + "" : e, t), t);
+import { WORKER_OFFSCREEN_CANVAS as d } from "./has.mjs";
+function a(n, e, t, r) {
+  let i;
+  return t && t.length ? i = /** @type {HTMLCanvasElement} */
+  t.shift() : d ? i = new class extends OffscreenCanvas {
+    constructor() {
+      super(...arguments);
+      c(this, "style", {});
+    }
+  }(n ?? 300, e ?? 150) : i = document.createElement("canvas"), n && (i.width = n), e && (i.height = e), /** @type {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} */
+  i.getContext("2d", r);
+}
+let o;
+function C() {
+  return o || (o = a(1, 1)), o;
+}
+function v(n) {
+  const e = n.canvas;
+  e.width = 1, e.height = 1, n.clearRect(0, 0, 1, 1);
+}
+function m(n, e) {
+  const t = e.parentNode;
+  t && t.replaceChild(n, e);
+}
+function p(n) {
+  for (; n.lastChild; )
+    n.lastChild.remove();
+}
+function N(n, e) {
+  const t = n.childNodes;
+  for (let r = 0; ; ++r) {
+    const i = t[r], s = e[r];
+    if (!i && !s)
+      break;
+    if (i !== s) {
+      if (!i) {
+        n.appendChild(s);
+        continue;
+      }
+      if (!s) {
+        n.removeChild(i), --r;
+        continue;
+      }
+      n.insertBefore(s, i);
+    }
+  }
+}
+function x() {
+  return new Proxy(
+    {
+      /**
+       * @type {Array<HTMLElement>}
+       */
+      childNodes: [],
+      /**
+       * @param {HTMLElement} node html node.
+       * @return {HTMLElement} html node.
+       */
+      appendChild: function(e) {
+        return this.childNodes.push(e), e;
+      },
+      /**
+       * dummy function, as this structure is not supposed to have a parent.
+       */
+      remove: function() {
+      },
+      /**
+       * @param {HTMLElement} node html node.
+       * @return {HTMLElement} html node.
+       */
+      removeChild: function(e) {
+        const t = this.childNodes.indexOf(e);
+        if (t === -1)
+          throw new Error("Node to remove was not found");
+        return this.childNodes.splice(t, 1), e;
+      },
+      /**
+       * @param {HTMLElement} newNode new html node.
+       * @param {HTMLElement} referenceNode reference html node.
+       * @return {HTMLElement} new html node.
+       */
+      insertBefore: function(e, t) {
+        const r = this.childNodes.indexOf(t);
+        if (r === -1)
+          throw new Error("Reference node not found");
+        return this.childNodes.splice(r, 0, e), e;
+      },
+      style: {}
+    },
+    {
+      get(e, t, r) {
+        return t === "firstElementChild" ? e.childNodes.length > 0 ? e.childNodes[0] : null : Reflect.get(e, t, r);
+      }
+    }
+  );
+}
+function E(n) {
+  return typeof HTMLCanvasElement < "u" && n instanceof HTMLCanvasElement || typeof OffscreenCanvas < "u" && n instanceof OffscreenCanvas;
+}
+export {
+  a as createCanvasContext2D,
+  x as createMockDiv,
+  C as getSharedCanvasContext2D,
+  E as isCanvas,
+  v as releaseCanvas,
+  p as removeChildren,
+  N as replaceChildren,
+  m as replaceNode
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/easing.mjs

@@ -0,0 +1,18 @@
+function e(n) {
+  return Math.pow(n, 3);
+}
+function r(n) {
+  return 1 - e(1 - n);
+}
+function u(n) {
+  return 3 * n * n - 2 * n * n * n;
+}
+function t(n) {
+  return n;
+}
+export {
+  e as easeIn,
+  r as easeOut,
+  u as inAndOut,
+  t as linear
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events/Event.mjs

@@ -0,0 +1,27 @@
+class e {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(t) {
+    this.propagationStopped, this.defaultPrevented, this.type = t, this.target = null;
+  }
+  /**
+   * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events
+   * will be fired.
+   * @api
+   */
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+  /**
+   * Stop event propagation.
+   * @api
+   */
+  stopPropagation() {
+    this.propagationStopped = !0;
+  }
+}
+const o = e;
+export {
+  o as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events/EventType.mjs

@@ -0,0 +1,32 @@
+const e = {
+  /**
+   * Generic change event. Triggered when the revision counter is increased.
+   * @event module:ol/events/Event~BaseEvent#change
+   * @api
+   */
+  CHANGE: "change",
+  /**
+   * Generic error event. Triggered when an error occurs.
+   * @event module:ol/events/Event~BaseEvent#error
+   * @api
+   */
+  ERROR: "error",
+  BLUR: "blur",
+  CLEAR: "clear",
+  CONTEXTMENU: "contextmenu",
+  CLICK: "click",
+  DBLCLICK: "dblclick",
+  DRAGENTER: "dragenter",
+  DRAGOVER: "dragover",
+  DROP: "drop",
+  FOCUS: "focus",
+  KEYDOWN: "keydown",
+  KEYPRESS: "keypress",
+  LOAD: "load",
+  RESIZE: "resize",
+  TOUCHMOVE: "touchmove",
+  WHEEL: "wheel"
+};
+export {
+  e as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events/Key.mjs

@@ -0,0 +1,9 @@
+const r = {
+  LEFT: "ArrowLeft",
+  UP: "ArrowUp",
+  RIGHT: "ArrowRight",
+  DOWN: "ArrowDown"
+};
+export {
+  r as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events/Target.mjs

@@ -0,0 +1,101 @@
+import p from "../Disposable.mjs";
+import { VOID as a } from "../functions.mjs";
+import { clear as f } from "../obj.mjs";
+import _ from "./Event.mjs";
+class g extends p {
+  /**
+   * @param {*} [target] Default event target for dispatched events.
+   */
+  constructor(e) {
+    super(), this.eventTarget_ = e, this.pendingRemovals_ = null, this.dispatching_ = null, this.listeners_ = null;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  addEventListener(e, i) {
+    if (!e || !i)
+      return;
+    const s = this.listeners_ || (this.listeners_ = {}), t = s[e] || (s[e] = []);
+    t.includes(i) || t.push(i);
+  }
+  /**
+   * Dispatches an event and calls all listeners listening for events
+   * of this type. The event parameter can either be a string or an
+   * Object with a `type` property.
+   *
+   * @param {import("./Event.js").default|string} event Event object.
+   * @return {boolean|undefined} `false` if anyone called preventDefault on the
+   *     event object or if any of the listeners returned false.
+   * @api
+   */
+  dispatchEvent(e) {
+    const i = typeof e == "string", s = i ? e : e.type, t = this.listeners_ && this.listeners_[s];
+    if (!t)
+      return;
+    const r = i ? new _(e) : (
+      /** @type {Event} */
+      e
+    );
+    r.target || (r.target = this.eventTarget_ || this);
+    const l = this.dispatching_ || (this.dispatching_ = {}), o = this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    s in l || (l[s] = 0, o[s] = 0), ++l[s];
+    let h;
+    for (let n = 0, d = t.length; n < d; ++n)
+      if ("handleEvent" in t[n] ? h = /** @type {import("../events.js").ListenerObject} */
+      t[n].handleEvent(r) : h = /** @type {import("../events.js").ListenerFunction} */
+      t[n].call(this, r), h === !1 || r.propagationStopped) {
+        h = !1;
+        break;
+      }
+    if (--l[s] === 0) {
+      let n = o[s];
+      for (delete o[s]; n--; )
+        this.removeEventListener(s, a);
+      delete l[s];
+    }
+    return h;
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.listeners_ && f(this.listeners_);
+  }
+  /**
+   * Get the listeners for a specified event type. Listeners are returned in the
+   * order that they will be called in.
+   *
+   * @param {string} type Type.
+   * @return {Array<import("../events.js").Listener>|undefined} Listeners.
+   */
+  getListeners(e) {
+    return this.listeners_ && this.listeners_[e] || void 0;
+  }
+  /**
+   * @param {string} [type] Type. If not provided,
+   *     `true` will be returned if this event target has any listeners.
+   * @return {boolean} Has listeners.
+   */
+  hasListener(e) {
+    return this.listeners_ ? e ? e in this.listeners_ : Object.keys(this.listeners_).length > 0 : !1;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  removeEventListener(e, i) {
+    if (!this.listeners_)
+      return;
+    const s = this.listeners_[e];
+    if (!s)
+      return;
+    const t = s.indexOf(i);
+    t !== -1 && (this.pendingRemovals_ && e in this.pendingRemovals_ ? (s[t] = a, ++this.pendingRemovals_[e]) : (s.splice(t, 1), s.length === 0 && delete this.listeners_[e]));
+  }
+}
+const R = g;
+export {
+  R as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events/condition.mjs

@@ -0,0 +1,65 @@
+import { TRUE as c } from "../functions.mjs";
+import { WEBKIT as s, MAC as r } from "../has.mjs";
+function E(n) {
+  const t = arguments;
+  return function(e) {
+    let o = !0;
+    for (let i = 0, a = t.length; i < a && (o = o && t[i](e), !!o); ++i)
+      ;
+    return o;
+  };
+}
+const f = function(n) {
+  const t = n.originalEvent;
+  return t.altKey && !(t.metaKey || t.ctrlKey) && t.shiftKey;
+}, l = function(n) {
+  const t = n.map.getTargetElement(), e = t.getRootNode(), o = n.map.getOwnerDocument().activeElement;
+  return e instanceof ShadowRoot ? e.host.contains(o) : t.contains(o);
+}, m = function(n) {
+  const t = n.map.getTargetElement(), e = t.getRootNode();
+  return (e instanceof ShadowRoot ? e.host : t).hasAttribute("tabindex") ? l(n) : !0;
+}, y = c, d = function(n) {
+  const t = n.originalEvent;
+  return "pointerId" in t && t.button == 0 && !(s && r && t.ctrlKey);
+}, K = function(n) {
+  const t = (
+    /** @type {KeyboardEvent|MouseEvent|TouchEvent} */
+    n.originalEvent
+  );
+  return !t.altKey && !(t.metaKey || t.ctrlKey) && !t.shiftKey;
+}, v = function(n) {
+  const t = n.originalEvent;
+  return r ? t.metaKey : t.ctrlKey;
+}, p = function(n) {
+  const t = n.originalEvent;
+  return !t.altKey && !(t.metaKey || t.ctrlKey) && t.shiftKey;
+}, h = function(n) {
+  const t = n.originalEvent, e = (
+    /** @type {Element} */
+    t.target.tagName
+  );
+  return e !== "INPUT" && e !== "SELECT" && e !== "TEXTAREA" && // `isContentEditable` is only available on `HTMLElement`, but it may also be a
+  // different type like `SVGElement`.
+  // @ts-ignore
+  !t.target.isContentEditable;
+}, b = function(n) {
+  const t = n.originalEvent;
+  return "pointerId" in t && t.pointerType == "mouse";
+}, T = function(n) {
+  const t = n.originalEvent;
+  return "pointerId" in t && t.isPrimary && t.button === 0;
+};
+export {
+  E as all,
+  f as altShiftKeysOnly,
+  y as always,
+  l as focus,
+  m as focusWithTabindex,
+  d as mouseActionButton,
+  b as mouseOnly,
+  K as noModifierKeys,
+  v as platformModifierKey,
+  T as primaryAction,
+  p as shiftKeyOnly,
+  h as targetNotEditable
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/events.mjs

@@ -0,0 +1,27 @@
+import { clear as f } from "./obj.mjs";
+function v(n, i, e, t, o) {
+  if (o) {
+    const c = e;
+    e = function(u) {
+      return n.removeEventListener(i, e), c.call(t ?? this, u);
+    };
+  } else
+    t && t !== n && (e = e.bind(t));
+  const r = {
+    target: n,
+    type: i,
+    listener: e
+  };
+  return n.addEventListener(i, e), r;
+}
+function a(n, i, e, t) {
+  return v(n, i, e, t, !0);
+}
+function l(n) {
+  n && n.target && (n.target.removeEventListener(n.type, n.listener), f(n));
+}
+export {
+  v as listen,
+  a as listenOnce,
+  l as unlistenByKey
+};