@hybridcore/ui 1.6.13 → 1.6.14

package/dist/math-Bvt2Ubuz.js

@@ -0,0 +1,704 @@
+class m {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(e) {
+    this.propagationStopped, this.defaultPrevented, this.type = e, 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 A = {
+  /**
+   * Triggered when a property is changed.
+   * @event module:ol/Object.ObjectEvent#propertychange
+   * @api
+   */
+  PROPERTYCHANGE: "propertychange"
+};
+class w {
+  constructor() {
+    this.disposed = !1;
+  }
+  /**
+   * Clean up.
+   */
+  dispose() {
+    this.disposed || (this.disposed = !0, this.disposeInternal());
+  }
+  /**
+   * Extension point for disposable objects.
+   * @protected
+   */
+  disposeInternal() {
+  }
+}
+function N(n, e, s) {
+  let t, i;
+  s = s || y;
+  let r = 0, a = n.length, o = !1;
+  for (; r < a; )
+    t = r + (a - r >> 1), i = +s(n[t], e), i < 0 ? r = t + 1 : (a = t, o = !i);
+  return o ? r : ~r;
+}
+function y(n, e) {
+  return n > e ? 1 : n < e ? -1 : 0;
+}
+function U(n, e, s) {
+  if (n[0] <= e)
+    return 0;
+  const t = n.length;
+  if (e <= n[t - 1])
+    return t - 1;
+  if (typeof s == "function") {
+    for (let i = 1; i < t; ++i) {
+      const r = n[i];
+      if (r === e)
+        return i;
+      if (r < e)
+        return s(e, n[i - 1], r) > 0 ? i - 1 : i;
+    }
+    return t - 1;
+  }
+  if (s > 0) {
+    for (let i = 1; i < t; ++i)
+      if (n[i] < e)
+        return i - 1;
+    return t - 1;
+  }
+  if (s < 0) {
+    for (let i = 1; i < t; ++i)
+      if (n[i] <= e)
+        return i;
+    return t - 1;
+  }
+  for (let i = 1; i < t; ++i) {
+    if (n[i] == e)
+      return i;
+    if (n[i] < e)
+      return n[i - 1] - e < e - n[i] ? i - 1 : i;
+  }
+  return t - 1;
+}
+function D(n, e, s) {
+  for (; e < s; ) {
+    const t = n[e];
+    n[e] = n[s], n[s] = t, ++e, --s;
+  }
+}
+function B(n, e) {
+  const s = Array.isArray(e) ? e : [e], t = s.length;
+  for (let i = 0; i < t; i++)
+    n[n.length] = s[i];
+}
+function R(n, e) {
+  const s = n.length;
+  if (s !== e.length)
+    return !1;
+  for (let t = 0; t < s; t++)
+    if (n[t] !== e[t])
+      return !1;
+  return !0;
+}
+function G(n, e, s) {
+  const t = e || y;
+  return n.every(function(i, r) {
+    if (r === 0)
+      return !0;
+    const a = t(n[r - 1], i);
+    return !(a > 0 || a === 0);
+  });
+}
+function V() {
+  return !0;
+}
+function k() {
+  return !1;
+}
+function f() {
+}
+function j(n) {
+  let e = !1, s, t, i;
+  return function() {
+    const r = Array.prototype.slice.call(arguments);
+    return (!e || this !== i || !R(r, t)) && (e = !0, i = this, t = r, s = n.apply(this, arguments)), s;
+  };
+}
+function E(n) {
+  for (const e in n)
+    delete n[e];
+}
+function L(n) {
+  let e;
+  for (e in n)
+    return !1;
+  return !e;
+}
+class S extends w {
+  /**
+   * @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, s) {
+    if (!e || !s)
+      return;
+    const t = this.listeners_ || (this.listeners_ = {}), i = t[e] || (t[e] = []);
+    i.includes(s) || i.push(s);
+  }
+  /**
+   * 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 s = typeof e == "string", t = s ? e : e.type, i = this.listeners_ && this.listeners_[t];
+    if (!i)
+      return;
+    const r = s ? new m(e) : (
+      /** @type {Event} */
+      e
+    );
+    r.target || (r.target = this.eventTarget_ || this);
+    const a = this.dispatching_ || (this.dispatching_ = {}), o = this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    t in a || (a[t] = 0, o[t] = 0), ++a[t];
+    let l;
+    for (let u = 0, b = i.length; u < b; ++u)
+      if ("handleEvent" in i[u] ? l = /** @type {import("../events.js").ListenerObject} */
+      i[u].handleEvent(r) : l = /** @type {import("../events.js").ListenerFunction} */
+      i[u].call(this, r), l === !1 || r.propagationStopped) {
+        l = !1;
+        break;
+      }
+    if (--a[t] === 0) {
+      let u = o[t];
+      for (delete o[t]; u--; )
+        this.removeEventListener(t, f);
+      delete a[t];
+    }
+    return l;
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.listeners_ && E(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, s) {
+    const t = this.listeners_ && this.listeners_[e];
+    if (t) {
+      const i = t.indexOf(s);
+      i !== -1 && (this.pendingRemovals_ && e in this.pendingRemovals_ ? (t[i] = f, ++this.pendingRemovals_[e]) : (t.splice(i, 1), t.length === 0 && delete this.listeners_[e]));
+    }
+  }
+}
+const I = {
+  /**
+   * 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"
+};
+function h(n, e, s, t, i) {
+  if (t && t !== n && (s = s.bind(t)), i) {
+    const a = s;
+    s = function() {
+      n.removeEventListener(e, s), a.apply(this, arguments);
+    };
+  }
+  const r = {
+    target: n,
+    type: e,
+    listener: s
+  };
+  return n.addEventListener(e, s), r;
+}
+function p(n, e, s, t) {
+  return h(n, e, s, t, !0);
+}
+function v(n) {
+  n && n.target && (n.target.removeEventListener(n.type, n.listener), E(n));
+}
+class d extends S {
+  constructor() {
+    super(), this.on = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onInternal, this.once = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onceInternal, this.un = /** @type {ObservableOnSignature<void>} */
+    this.unInternal, this.revision_ = 0;
+  }
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_, this.dispatchEvent(I.CHANGE);
+  }
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(e, s) {
+    if (Array.isArray(e)) {
+      const t = e.length, i = new Array(t);
+      for (let r = 0; r < t; ++r)
+        i[r] = h(this, e[r], s);
+      return i;
+    }
+    return h(
+      this,
+      /** @type {string} */
+      e,
+      s
+    );
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(e, s) {
+    let t;
+    if (Array.isArray(e)) {
+      const i = e.length;
+      t = new Array(i);
+      for (let r = 0; r < i; ++r)
+        t[r] = p(this, e[r], s);
+    } else
+      t = p(
+        this,
+        /** @type {string} */
+        e,
+        s
+      );
+    return s.ol_key = t, t;
+  }
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(e, s) {
+    const t = (
+      /** @type {Object} */
+      s.ol_key
+    );
+    if (t)
+      T(t);
+    else if (Array.isArray(e))
+      for (let i = 0, r = e.length; i < r; ++i)
+        this.removeEventListener(e[i], s);
+    else
+      this.removeEventListener(e, s);
+  }
+}
+d.prototype.on;
+d.prototype.once;
+d.prototype.un;
+function T(n) {
+  if (Array.isArray(n))
+    for (let e = 0, s = n.length; e < s; ++e)
+      v(n[e]);
+  else
+    v(
+      /** @type {import("./events.js").EventsKey} */
+      n
+    );
+}
+function q() {
+  throw new Error("Unimplemented abstract method.");
+}
+let O = 0;
+function C(n) {
+  return n.ol_uid || (n.ol_uid = String(++O));
+}
+class g extends m {
+  /**
+   * @param {string} type The event type.
+   * @param {string} key The property name.
+   * @param {*} oldValue The old value for `key`.
+   */
+  constructor(e, s, t) {
+    super(e), this.key = s, this.oldValue = t;
+  }
+}
+class K extends d {
+  /**
+   * @param {Object<string, *>} [values] An object with key-value pairs.
+   */
+  constructor(e) {
+    super(), this.on, this.once, this.un, C(this), this.values_ = null, e !== void 0 && this.setProperties(e);
+  }
+  /**
+   * Gets a value.
+   * @param {string} key Key name.
+   * @return {*} Value.
+   * @api
+   */
+  get(e) {
+    let s;
+    return this.values_ && this.values_.hasOwnProperty(e) && (s = this.values_[e]), s;
+  }
+  /**
+   * Get a list of object property names.
+   * @return {Array<string>} List of property names.
+   * @api
+   */
+  getKeys() {
+    return this.values_ && Object.keys(this.values_) || [];
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>} Object.
+   * @api
+   */
+  getProperties() {
+    return this.values_ && Object.assign({}, this.values_) || {};
+  }
+  /**
+   * @return {boolean} The object has properties.
+   */
+  hasProperties() {
+    return !!this.values_;
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {*} oldValue Old value.
+   */
+  notify(e, s) {
+    let t;
+    t = `change:${e}`, this.hasListener(t) && this.dispatchEvent(new g(t, e, s)), t = A.PROPERTYCHANGE, this.hasListener(t) && this.dispatchEvent(new g(t, e, s));
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  addChangeListener(e, s) {
+    this.addEventListener(`change:${e}`, s);
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  removeChangeListener(e, s) {
+    this.removeEventListener(`change:${e}`, s);
+  }
+  /**
+   * Sets a value.
+   * @param {string} key Key name.
+   * @param {*} value Value.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  set(e, s, t) {
+    const i = this.values_ || (this.values_ = {});
+    if (t)
+      i[e] = s;
+    else {
+      const r = i[e];
+      i[e] = s, r !== s && this.notify(e, r);
+    }
+  }
+  /**
+   * Sets a collection of key-value pairs.  Note that this changes any existing
+   * properties and adds new ones (it does not remove any existing properties).
+   * @param {Object<string, *>} values Values.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  setProperties(e, s) {
+    for (const t in e)
+      this.set(t, e[t], s);
+  }
+  /**
+   * Apply any properties from another object without triggering events.
+   * @param {BaseObject} source The source object.
+   * @protected
+   */
+  applyProperties(e) {
+    e.values_ && Object.assign(this.values_ || (this.values_ = {}), e.values_);
+  }
+  /**
+   * Unsets a property.
+   * @param {string} key Key name.
+   * @param {boolean} [silent] Unset without triggering an event.
+   * @api
+   */
+  unset(e, s) {
+    if (this.values_ && e in this.values_) {
+      const t = this.values_[e];
+      delete this.values_[e], L(this.values_) && (this.values_ = null), s || this.notify(e, t);
+    }
+  }
+}
+const c = typeof navigator < "u" && typeof navigator.userAgent < "u" ? navigator.userAgent.toLowerCase() : "", W = c.includes("firefox"), x = c.includes("safari") && !c.includes("chrom"), z = x && (c.includes("version/15.4") || /cpu (os|iphone os) 15_4 like mac os x/.test(c)), H = c.includes("webkit") && !c.includes("edge"), Y = c.includes("macintosh"), J = typeof devicePixelRatio < "u" ? devicePixelRatio : 1, X = typeof WorkerGlobalScope < "u" && typeof OffscreenCanvas < "u" && self instanceof WorkerGlobalScope, $ = typeof Image < "u" && Image.prototype.decode, Q = function() {
+  let n = !1;
+  try {
+    const e = Object.defineProperty({}, "passive", {
+      get: function() {
+        n = !0;
+      }
+    });
+    window.addEventListener("_", null, e), window.removeEventListener("_", null, e);
+  } catch {
+  }
+  return n;
+}(), P = {
+  1: "The view center is not defined",
+  2: "The view resolution is not defined",
+  3: "The view rotation is not defined",
+  4: "`image` and `src` cannot be provided at the same time",
+  5: "`imgSize` must be set when `image` is provided",
+  7: "`format` must be set when `url` is set",
+  8: "Unknown `serverType` configured",
+  9: "`url` must be configured or set using `#setUrl()`",
+  10: "The default `geometryFunction` can only handle `Point` geometries",
+  11: "`options.featureTypes` must be an Array",
+  12: "`options.geometryName` must also be provided when `options.bbox` is set",
+  13: "Invalid corner",
+  14: "Invalid color",
+  15: "Tried to get a value for a key that does not exist in the cache",
+  16: "Tried to set a value for a key that is used already",
+  17: "`resolutions` must be sorted in descending order",
+  18: "Either `origin` or `origins` must be configured, never both",
+  19: "Number of `tileSizes` and `resolutions` must be equal",
+  20: "Number of `origins` and `resolutions` must be equal",
+  22: "Either `tileSize` or `tileSizes` must be configured, never both",
+  24: "Invalid extent or geometry provided as `geometry`",
+  25: "Cannot fit empty extent provided as `geometry`",
+  26: "Features must have an id set",
+  27: "Features must have an id set",
+  28: '`renderMode` must be `"hybrid"` or `"vector"`',
+  30: "The passed `feature` was already added to the source",
+  31: "Tried to enqueue an `element` that was already added to the queue",
+  32: "Transformation matrix cannot be inverted",
+  33: "Invalid units",
+  34: "Invalid geometry layout",
+  36: "Unknown SRS type",
+  37: "Unknown geometry type found",
+  38: "`styleMapValue` has an unknown type",
+  39: "Unknown geometry type",
+  40: "Expected `feature` to have a geometry",
+  41: "Expected an `ol/style/Style` or an array of `ol/style/Style.js`",
+  42: "Question unknown, the answer is 42",
+  43: "Expected `layers` to be an array or a `Collection`",
+  47: "Expected `controls` to be an array or an `ol/Collection`",
+  48: "Expected `interactions` to be an array or an `ol/Collection`",
+  49: "Expected `overlays` to be an array or an `ol/Collection`",
+  50: "`options.featureTypes` should be an Array",
+  51: "Either `url` or `tileJSON` options must be provided",
+  52: "Unknown `serverType` configured",
+  53: "Unknown `tierSizeCalculation` configured",
+  55: "The {-y} placeholder requires a tile grid with extent",
+  56: "mapBrowserEvent must originate from a pointer event",
+  57: "At least 2 conditions are required",
+  59: "Invalid command found in the PBF",
+  60: "Missing or invalid `size`",
+  61: "Cannot determine IIIF Image API version from provided image information JSON",
+  62: "A `WebGLArrayBuffer` must either be of type `ELEMENT_ARRAY_BUFFER` or `ARRAY_BUFFER`",
+  64: "Layer opacity must be a number",
+  66: "`forEachFeatureAtCoordinate` cannot be used on a WebGL layer if the hit detection logic has not been enabled. This is done by providing adequate shaders using the `hitVertexShader` and `hitFragmentShader` properties of `WebGLPointsLayerRenderer`",
+  67: "A layer can only be added to the map once. Use either `layer.setMap()` or `map.addLayer()`, not both",
+  68: "A VectorTile source can only be rendered if it has a projection compatible with the view projection",
+  69: "`width` or `height` cannot be provided together with `scale`"
+};
+class F extends Error {
+  /**
+   * @param {number} code Error code.
+   */
+  constructor(e) {
+    const s = P[e];
+    super(s), this.code = e, this.name = "AssertionError", this.message = s;
+  }
+}
+function Z(n, e) {
+  if (!n)
+    throw new F(e);
+}
+function ee(n, e, s) {
+  return Math.min(Math.max(n, e), s);
+}
+function te(n, e, s, t, i, r) {
+  const a = i - s, o = r - t;
+  if (a !== 0 || o !== 0) {
+    const l = ((n - s) * a + (e - t) * o) / (a * a + o * o);
+    l > 1 ? (s = i, t = r) : l > 0 && (s += a * l, t += o * l);
+  }
+  return M(n, e, s, t);
+}
+function M(n, e, s, t) {
+  const i = s - n, r = t - e;
+  return i * i + r * r;
+}
+function ne(n) {
+  const e = n.length;
+  for (let t = 0; t < e; t++) {
+    let i = t, r = Math.abs(n[t][t]);
+    for (let o = t + 1; o < e; o++) {
+      const l = Math.abs(n[o][t]);
+      l > r && (r = l, i = o);
+    }
+    if (r === 0)
+      return null;
+    const a = n[i];
+    n[i] = n[t], n[t] = a;
+    for (let o = t + 1; o < e; o++) {
+      const l = -n[o][t] / n[t][t];
+      for (let u = t; u < e + 1; u++)
+        t == u ? n[o][u] = 0 : n[o][u] += l * n[t][u];
+    }
+  }
+  const s = new Array(e);
+  for (let t = e - 1; t >= 0; t--) {
+    s[t] = n[t][e] / n[t][t];
+    for (let i = t - 1; i >= 0; i--)
+      n[i][e] -= n[i][t] * s[t];
+  }
+  return s;
+}
+function se(n) {
+  return n * Math.PI / 180;
+}
+function ie(n, e) {
+  const s = n % e;
+  return s * e < 0 ? s + e : s;
+}
+function re(n, e, s) {
+  return n + s * (e - n);
+}
+function _(n, e) {
+  const s = Math.pow(10, e);
+  return Math.round(n * s) / s;
+}
+function oe(n, e) {
+  return Math.floor(_(n, e));
+}
+function ae(n, e) {
+  return Math.ceil(_(n, e));
+}
+export {
+  F as A,
+  K as B,
+  j as C,
+  w as D,
+  I as E,
+  k as F,
+  te as G,
+  H,
+  $ as I,
+  W as J,
+  J as K,
+  ne as L,
+  Y as M,
+  d as O,
+  Q as P,
+  z as S,
+  V as T,
+  f as V,
+  X as W,
+  Z as a,
+  q as b,
+  N as c,
+  re as d,
+  B as e,
+  m as f,
+  C as g,
+  A as h,
+  L as i,
+  E as j,
+  R as k,
+  h as l,
+  ee as m,
+  p as n,
+  S as o,
+  G as p,
+  U as q,
+  ae as r,
+  M as s,
+  _ as t,
+  v as u,
+  oe as v,
+  ie as w,
+  D as x,
+  y,
+  se as z
+};