@performant-software/geospatial 3.1.28-beta.0 → 3.1.29

package/dist/index.es274.js

@@ -1,7 +1,5 @@
-function t(n, e) {
-  return n < e ? -1 : n > e ? 1 : n >= e ? 0 : NaN;
-}
+var s = { exports: {} };
 export {
-  t as default
+  s as __module
 };
 //# sourceMappingURL=index.es274.js.map

package/dist/index.es274.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es274.js","sources":["../../../node_modules/d3-geo/node_modules/d3-array/src/ascending.js"],"sourcesContent":["export default function(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n"],"names":["ascending","a","b"],"mappings":"AAAA,SAAAA,EAAwBC,GAAGC,GAAG;AAC5B,SAAOD,IAAIC,IAAI,KAAKD,IAAIC,IAAI,IAAID,KAAKC,IAAI,IAAI;AAC/C;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es274.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/index.es275.js

@@ -1,28 +1,6 @@
-import i from "./index.es274.js";
-function s(e) {
-  return e.length === 1 && (e = l(e)), {
-    left: function(f, u, n, t) {
-      for (n == null && (n = 0), t == null && (t = f.length); n < t; ) {
-        var r = n + t >>> 1;
-        e(f[r], u) < 0 ? n = r + 1 : t = r;
-      }
-      return n;
-    },
-    right: function(f, u, n, t) {
-      for (n == null && (n = 0), t == null && (t = f.length); n < t; ) {
-        var r = n + t >>> 1;
-        e(f[r], u) > 0 ? t = r : n = r + 1;
-      }
-      return n;
-    }
-  };
-}
-function l(e) {
-  return function(f, u) {
-    return i(e(f), u);
-  };
-}
+import t from "./index.es235.js";
+const a = t("Object");
 export {
-  s as default
+  a as default
 };
 //# sourceMappingURL=index.es275.js.map

package/dist/index.es275.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es275.js","sources":["../../../node_modules/d3-geo/node_modules/d3-array/src/bisector.js"],"sourcesContent":["import ascending from \"./ascending\";\n\nexport default function(compare) {\n  if (compare.length === 1) compare = ascendingComparator(compare);\n  return {\n    left: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) < 0) lo = mid + 1;\n        else hi = mid;\n      }\n      return lo;\n    },\n    right: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) > 0) hi = mid;\n        else lo = mid + 1;\n      }\n      return lo;\n    }\n  };\n}\n\nfunction ascendingComparator(f) {\n  return function(d, x) {\n    return ascending(f(d), x);\n  };\n}\n"],"names":["bisector","compare","ascendingComparator","a","x","lo","hi","mid","f","d","ascending"],"mappings":";AAEA,SAAAA,EAAwBC,GAAS;AAC/B,SAAIA,EAAQ,WAAW,MAAGA,IAAUC,EAAoBD,CAAO,IACxD;AAAA,IACL,MAAM,SAASE,GAAGC,GAAGC,GAAIC,GAAI;AAG3B,WAFID,KAAM,SAAMA,IAAK,IACjBC,KAAM,SAAMA,IAAKH,EAAE,SAChBE,IAAKC,KAAI;AACd,YAAIC,IAAMF,IAAKC,MAAO;AACtB,QAAIL,EAAQE,EAAEI,CAAG,GAAGH,CAAC,IAAI,QAAQG,IAAM,IAClCD,IAAKC;AAAA,MACZ;AACA,aAAOF;AAAA,IACT;AAAA,IACA,OAAO,SAASF,GAAGC,GAAGC,GAAIC,GAAI;AAG5B,WAFID,KAAM,SAAMA,IAAK,IACjBC,KAAM,SAAMA,IAAKH,EAAE,SAChBE,IAAKC,KAAI;AACd,YAAIC,IAAMF,IAAKC,MAAO;AACtB,QAAIL,EAAQE,EAAEI,CAAG,GAAGH,CAAC,IAAI,IAAGE,IAAKC,QACvBA,IAAM;AAAA,MAClB;AACA,aAAOF;AAAA,IACT;AAAA,EAAA;AAEJ;AAEA,SAASH,EAAoBM,GAAG;AAC9B,SAAO,SAASC,GAAGL,GAAG;AACpB,WAAOM,EAAUF,EAAEC,CAAC,GAAGL,CAAC;AAAA,EAC1B;AACF;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es275.js","sources":["../node_modules/underscore/modules/_hasObjectTag.js"],"sourcesContent":["import tagTester from './_tagTester.js';\n\nexport default tagTester('Object');\n"],"names":["hasObjectTag","tagTester"],"mappings":";AAEA,MAAAA,IAAeC,EAAU,QAAQ;","x_google_ignoreList":[0]}

package/dist/index.es276.js

@@ -0,0 +1,11 @@
+import { MAX_ARRAY_INDEX as o } from "./index.es37.js";
+function u(e) {
+  return function(t) {
+    var r = e(t);
+    return typeof r == "number" && r >= 0 && r <= o;
+  };
+}
+export {
+  u as default
+};
+//# sourceMappingURL=index.es276.js.map

package/dist/index.es276.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es276.js","sources":["../node_modules/underscore/modules/_createSizePropertyCheck.js"],"sourcesContent":["import { MAX_ARRAY_INDEX } from './_setup.js';\n\n// Common internal logic for `isArrayLike` and `isBufferLike`.\nexport default function createSizePropertyCheck(getSizeProperty) {\n  return function(collection) {\n    var sizeProperty = getSizeProperty(collection);\n    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n  }\n}\n"],"names":["createSizePropertyCheck","getSizeProperty","collection","sizeProperty","MAX_ARRAY_INDEX"],"mappings":";AAGA,SAAwBA,EAAwBC,GAAiB;AAC/D,SAAO,SAASC,GAAY;AAC1B,QAAIC,IAAeF,EAAgBC,CAAU;AAC7C,WAAO,OAAOC,KAAgB,YAAYA,KAAgB,KAAKA,KAAgBC;AAAA,EACjF;AACF;","x_google_ignoreList":[0]}

package/dist/index.es277.js

@@ -0,0 +1,9 @@
+function t(r) {
+  return function(n) {
+    return n?.[r];
+  };
+}
+export {
+  t as default
+};
+//# sourceMappingURL=index.es277.js.map

package/dist/index.es277.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es277.js","sources":["../node_modules/underscore/modules/_shallowProperty.js"],"sourcesContent":["// Internal helper to generate a function to obtain property `key` from `obj`.\nexport default function shallowProperty(key) {\n  return function(obj) {\n    return obj == null ? void 0 : obj[key];\n  };\n}\n"],"names":["shallowProperty","key","obj"],"mappings":"AACA,SAAwBA,EAAgBC,GAAK;AAC3C,SAAO,SAASC,GAAK;AACnB,WAA8BA,IAAID,CAAG;AAAA,EACvC;AACF;","x_google_ignoreList":[0]}

package/dist/index.es278.js

@@ -0,0 +1,24 @@
+import { deepEqual as a } from "./index.es267.js";
+function g(i) {
+  return {
+    longitude: i.center.lng,
+    latitude: i.center.lat,
+    zoom: i.zoom,
+    pitch: i.pitch,
+    bearing: i.bearing,
+    padding: i.padding
+  };
+}
+function c(i, t) {
+  const n = t.viewState || t, e = {};
+  if ("longitude" in n && "latitude" in n && (n.longitude !== i.center.lng || n.latitude !== i.center.lat)) {
+    const o = i.center.constructor;
+    e.center = new o(n.longitude, n.latitude);
+  }
+  return "zoom" in n && n.zoom !== i.zoom && (e.zoom = n.zoom), "bearing" in n && n.bearing !== i.bearing && (e.bearing = n.bearing), "pitch" in n && n.pitch !== i.pitch && (e.pitch = n.pitch), n.padding && i.padding && !a(n.padding, i.padding) && (e.padding = n.padding), e;
+}
+export {
+  c as applyViewStateToTransform,
+  g as transformToViewState
+};
+//# sourceMappingURL=index.es278.js.map

package/dist/index.es278.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es278.js","sources":["../../../node_modules/@vis.gl/react-maplibre/dist/utils/transform.js"],"sourcesContent":["import { deepEqual } from \"./deep-equal.js\";\n/**\n * Capture a transform's current state\n * @param transform\n * @returns descriptor of the view state\n */\nexport function transformToViewState(tr) {\n    return {\n        longitude: tr.center.lng,\n        latitude: tr.center.lat,\n        zoom: tr.zoom,\n        pitch: tr.pitch,\n        bearing: tr.bearing,\n        padding: tr.padding\n    };\n}\n/* eslint-disable complexity */\n/**\n * Applies requested view state to a transform\n * @returns an object containing detected changes\n */\nexport function applyViewStateToTransform(\n/** An object that describes Maplibre's camera state */\ntr, \n/** Props from Map component */\nprops) {\n    const v = props.viewState || props;\n    const changes = {};\n    if ('longitude' in v &&\n        'latitude' in v &&\n        (v.longitude !== tr.center.lng || v.latitude !== tr.center.lat)) {\n        const LngLat = tr.center.constructor;\n        // @ts-expect-error we should not import LngLat class from maplibre-gl because we don't know the source of mapLib\n        changes.center = new LngLat(v.longitude, v.latitude);\n    }\n    if ('zoom' in v && v.zoom !== tr.zoom) {\n        changes.zoom = v.zoom;\n    }\n    if ('bearing' in v && v.bearing !== tr.bearing) {\n        changes.bearing = v.bearing;\n    }\n    if ('pitch' in v && v.pitch !== tr.pitch) {\n        changes.pitch = v.pitch;\n    }\n    if (v.padding && tr.padding && !deepEqual(v.padding, tr.padding)) {\n        changes.padding = v.padding;\n    }\n    return changes;\n}\n//# sourceMappingURL=transform.js.map"],"names":["transformToViewState","tr","applyViewStateToTransform","props","v","changes","LngLat","deepEqual"],"mappings":";AAMO,SAASA,EAAqBC,GAAI;AACrC,SAAO;AAAA,IACH,WAAWA,EAAG,OAAO;AAAA,IACrB,UAAUA,EAAG,OAAO;AAAA,IACpB,MAAMA,EAAG;AAAA,IACT,OAAOA,EAAG;AAAA,IACV,SAASA,EAAG;AAAA,IACZ,SAASA,EAAG;AAAA,EAAA;AAEpB;AAMO,SAASC,EAEhBD,GAEAE,GAAO;AACH,QAAMC,IAAID,EAAM,aAAaA,GACvBE,IAAU,CAAA;AAChB,MAAI,eAAeD,KACf,cAAcA,MACbA,EAAE,cAAcH,EAAG,OAAO,OAAOG,EAAE,aAAaH,EAAG,OAAO,MAAM;AACjE,UAAMK,IAASL,EAAG,OAAO;AAEzB,IAAAI,EAAQ,SAAS,IAAIC,EAAOF,EAAE,WAAWA,EAAE,QAAQ;AAAA,EACvD;AACA,SAAI,UAAUA,KAAKA,EAAE,SAASH,EAAG,SAC7BI,EAAQ,OAAOD,EAAE,OAEjB,aAAaA,KAAKA,EAAE,YAAYH,EAAG,YACnCI,EAAQ,UAAUD,EAAE,UAEpB,WAAWA,KAAKA,EAAE,UAAUH,EAAG,UAC/BI,EAAQ,QAAQD,EAAE,QAElBA,EAAE,WAAWH,EAAG,WAAW,CAACM,EAAUH,EAAE,SAASH,EAAG,OAAO,MAC3DI,EAAQ,UAAUD,EAAE,UAEjBC;AACX;","x_google_ignoreList":[0]}

package/dist/index.es279.js

@@ -0,0 +1,26 @@
+const a = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+function c(r) {
+  if (!r)
+    return null;
+  if (typeof r == "string" || ("toJS" in r && (r = r.toJS()), !r.layers))
+    return r;
+  const t = {};
+  for (const e of r.layers)
+    t[e.id] = e;
+  const f = r.layers.map((e) => {
+    let n = null;
+    "interactive" in e && (n = Object.assign({}, e), delete n.interactive);
+    const o = t[e.ref];
+    if (o) {
+      n = n || Object.assign({}, e), delete n.ref;
+      for (const i of a)
+        i in o && (n[i] = o[i]);
+    }
+    return n || e;
+  });
+  return { ...r, layers: f };
+}
+export {
+  c as normalizeStyle
+};
+//# sourceMappingURL=index.es279.js.map

package/dist/index.es279.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es279.js","sources":["../../../node_modules/@vis.gl/react-maplibre/dist/utils/style-utils.js"],"sourcesContent":["const refProps = ['type', 'source', 'source-layer', 'minzoom', 'maxzoom', 'filter', 'layout'];\n// Prepare a map style object for diffing\n// If immutable - convert to plain object\n// Work around some issues in older styles that would fail Mapbox's diffing\nexport function normalizeStyle(style) {\n    if (!style) {\n        return null;\n    }\n    if (typeof style === 'string') {\n        return style;\n    }\n    if ('toJS' in style) {\n        style = style.toJS();\n    }\n    if (!style.layers) {\n        return style;\n    }\n    const layerIndex = {};\n    for (const layer of style.layers) {\n        layerIndex[layer.id] = layer;\n    }\n    const layers = style.layers.map(layer => {\n        let normalizedLayer = null;\n        if ('interactive' in layer) {\n            normalizedLayer = Object.assign({}, layer);\n            // Breaks style diffing :(\n            // @ts-ignore legacy field not typed\n            delete normalizedLayer.interactive;\n        }\n        // Style diffing doesn't work with refs so expand them out manually before diffing.\n        // @ts-ignore legacy field not typed\n        const layerRef = layerIndex[layer.ref];\n        if (layerRef) {\n            normalizedLayer = normalizedLayer || Object.assign({}, layer);\n            // @ts-ignore\n            delete normalizedLayer.ref;\n            // https://github.com/mapbox/mapbox-gl-js/blob/master/src/style-spec/deref.js\n            for (const propName of refProps) {\n                if (propName in layerRef) {\n                    normalizedLayer[propName] = layerRef[propName];\n                }\n            }\n        }\n        return normalizedLayer || layer;\n    });\n    // Do not mutate the style object provided by the user\n    return { ...style, layers };\n}\n//# sourceMappingURL=style-utils.js.map"],"names":["refProps","normalizeStyle","style","layerIndex","layer","layers","normalizedLayer","layerRef","propName"],"mappings":"AAAA,MAAMA,IAAW,CAAC,QAAQ,UAAU,gBAAgB,WAAW,WAAW,UAAU,QAAQ;AAIrF,SAASC,EAAeC,GAAO;AAClC,MAAI,CAACA;AACD,WAAO;AAQX,MANI,OAAOA,KAAU,aAGjB,UAAUA,MACVA,IAAQA,EAAM,KAAA,IAEd,CAACA,EAAM;AACP,WAAOA;AAEX,QAAMC,IAAa,CAAA;AACnB,aAAWC,KAASF,EAAM;AACtB,IAAAC,EAAWC,EAAM,EAAE,IAAIA;AAE3B,QAAMC,IAASH,EAAM,OAAO,IAAI,CAAAE,MAAS;AACrC,QAAIE,IAAkB;AACtB,IAAI,iBAAiBF,MACjBE,IAAkB,OAAO,OAAO,CAAA,GAAIF,CAAK,GAGzC,OAAOE,EAAgB;AAI3B,UAAMC,IAAWJ,EAAWC,EAAM,GAAG;AACrC,QAAIG,GAAU;AACV,MAAAD,IAAkBA,KAAmB,OAAO,OAAO,CAAA,GAAIF,CAAK,GAE5D,OAAOE,EAAgB;AAEvB,iBAAWE,KAAYR;AACnB,QAAIQ,KAAYD,MACZD,EAAgBE,CAAQ,IAAID,EAASC,CAAQ;AAAA,IAGzD;AACA,WAAOF,KAAmBF;AAAA,EAC9B,CAAC;AAED,SAAO,EAAE,GAAGF,GAAO,QAAAG,EAAA;AACvB;","x_google_ignoreList":[0]}

package/dist/index.es280.js

@@ -0,0 +1,418 @@
+import { createHomogeneousTransform as B, invertHomogeneousTransform as L, applyHomogeneousTransform as u } from "./index.es281.js";
+import { WarpedMapEvent as D, WarpedMapEventType as b } from "./index.es194.js";
+import { TriangulatedWarpedMap as z } from "./index.es282.js";
+import { createBuffer as a } from "./index.es283.js";
+import { getTilesAtOtherScaleFactors as I, tileKey as v } from "./index.es284.js";
+import { subSetArray as V } from "./index.es197.js";
+import { lineStringToLines as _, pointsAndPointsToLines as G } from "./index.es270.js";
+import { hexToFractionalOpaqueRgba as A } from "./index.es285.js";
+import { mergeOptions as S } from "./index.es198.js";
+import "./index.es200.js";
+import { red as x, yellow as X, green as y, darkblue as k, black as P, pink as R, blue as N, white as M } from "./index.es201.js";
+import j from "./index.es286.js";
+var W = 200, K = {
+  leading: !0,
+  trailing: !0
+}, m = {
+  viewportSize: 6,
+  color: P,
+  viewportBorderSize: 0,
+  borderColor: M
+}, g = {
+  viewportSize: 10,
+  color: P,
+  viewportBorderSize: 1,
+  borderColor: M
+}, w = {
+  renderGcps: !1,
+  renderGcpsColor: N,
+  renderTransformedGcps: !1,
+  renderTransformedGcpsColor: R,
+  renderVectors: !1,
+  renderVectorsSize: 4,
+  renderVectorsColor: P,
+  renderFullMask: !1,
+  renderFullMaskSize: 4,
+  renderFullMaskColor: y,
+  renderMask: !1,
+  renderMaskSize: 4,
+  renderMaskColor: R,
+  renderAppliedMask: !1,
+  renderAppliedMaskSize: 4,
+  renderAppliedMaskColor: R,
+  opacity: 1,
+  saturation: 1,
+  removeColor: !1,
+  removeColorColor: P,
+  removeColorThreshold: 0.3,
+  removeColorHardness: 0.7,
+  colorize: !1,
+  colorizeColor: R,
+  renderGrid: !1,
+  renderGridColor: P,
+  distortionColor00: x,
+  distortionColor01: k,
+  distortionColor1: y,
+  distortionColor2: X,
+  distortionColor3: x,
+  debugTiles: !1,
+  debugTriangles: !1
+}, q = { checkOpacity: !1 }, Y = 5, Z = 1;
+function ce(C, e, r, i) {
+  return (h, d, n, o) => new H(h, d, C, e, r, i, n, o);
+}
+var H = class U extends z {
+  gl;
+  mapProgram;
+  linesProgram;
+  pointsProgram;
+  mapVao = null;
+  linesVao = null;
+  pointsVao = null;
+  lineGroups = [];
+  pointGroups = [];
+  cachedTilesByTileKey;
+  cachedTilesByTileUrl;
+  cachedTilesForTexture = [];
+  previousCachedTilesForTexture = [];
+  cachedTilesTextureArray = null;
+  cachedTilesResourceOriginPointsAndSizesTexture = null;
+  cachedTilesScaleFactorsTexture = null;
+  invertedRenderHomogeneousTransform;
+  throttledUpdateTextures;
+  /**
+  * Creates an instance of WebGL2WarpedMap.
+  *
+  * @constructor
+  * @param mapId - ID of the map
+  * @param georeferencedMap - Georeferenced map used to construct the WarpedMap
+  * @param gl - WebGL rendering context
+  * @param mapProgram - WebGL program for map
+  * @param options - WarpedMapOptions
+  */
+  constructor(e, r, i, h, d, n, o, c) {
+    super(e, r, o, c), this.cachedTilesByTileKey = /* @__PURE__ */ new Map(), this.cachedTilesByTileUrl = /* @__PURE__ */ new Map(), this.gl = i, this.initializeWebGL(h, d, n), this.invertedRenderHomogeneousTransform = B(), this.throttledUpdateTextures = j(this.updateTextures.bind(this), W, K);
+  }
+  initializeWebGL(e, r, i) {
+    this.mapProgram = e, this.linesProgram = r, this.pointsProgram = i, this.mapVao = this.gl.createVertexArray(), this.linesVao = this.gl.createVertexArray(), this.pointsVao = this.gl.createVertexArray(), this.cachedTilesTextureArray = this.gl.createTexture(), this.cachedTilesScaleFactorsTexture = this.gl.createTexture(), this.cachedTilesResourceOriginPointsAndSizesTexture = this.gl.createTexture();
+  }
+  /**
+  * Get default options
+  */
+  static getDefaultOptions() {
+    return S(w, super.getDefaultOptions());
+  }
+  /**
+  * Get default options without the options overwritten by the georeferenced map
+  */
+  static getDefaultWithoutGeoreferencedMapOptions() {
+    return S(w, super.getDefaultWithoutGeoreferencedMapOptions());
+  }
+  /**
+  * Set the defaultOptions
+  */
+  setDefaultOptions() {
+    this.defaultOptions = U.getDefaultOptions();
+  }
+  /**
+  * Set the list options
+  *
+  * @param listOptions - list options
+  * @param animationOptions - Animation options
+  */
+  setListOptions(e, r) {
+    return super.setListOptions(e, r);
+  }
+  /**
+  * Set the map-specific options
+  *
+  * @param mapOptions - Map-specific options
+  * @param animationOptions - Animation options
+  */
+  setMapOptions(e, r) {
+    return super.setMapOptions(e, r);
+  }
+  /**
+  * Set the map-specific options, and the list options
+  *
+  * @param mapOptions - Map-specific options
+  * @param listOptions - list options
+  * @param animationOptions - Animation options
+  */
+  setMapAndListOptions(e, r, i) {
+    return super.setMapAndListOptions(e, r, i);
+  }
+  applyOptions(e) {
+    const r = super.applyOptions(e);
+    return this.options.opacity = (this.listOptions?.opacity ?? this.defaultOptions.opacity) * (this.mapOptions?.opacity ?? 1), this.options.saturation = (this.listOptions?.saturation ?? this.defaultOptions.saturation) * (this.mapOptions?.saturation ?? 1), r;
+  }
+  shouldRenderMap(e) {
+    const r = S(q, e);
+    return super.shouldRenderMap(e) && this.options.renderMaps !== !1 && (r.checkOpacity ? this.options.opacity !== 0 : !0);
+  }
+  shouldRenderLines() {
+    return super.shouldRenderLines() && this.options.renderLines !== !1 && (this.options.renderFullMask || this.options.renderMask || this.options.renderAppliedMask || this.options.renderVectors);
+  }
+  shouldRenderPoints() {
+    return super.shouldRenderPoints() && this.options.renderPoints !== !1 && (this.options.renderGcps || this.options.renderTransformedGcps);
+  }
+  /**
+  * Update the vertex buffers of this warped map
+  *
+  * @param projectedGeoToClipHomogeneousTransform - Transform from projected geo coordinates to webgl2 coordinates in the [-1, 1] range. Equivalent to OpenLayers' projectionTransform.
+  */
+  updateVertexBuffers(e) {
+    this.invertedRenderHomogeneousTransform = L(e), this.shouldRenderMap() && this.updateVertexBuffersMap(e), this.shouldRenderLines() && this.updateVertexBuffersLines(e), this.shouldRenderPoints() && this.updateVertexBuffersPoints(e);
+  }
+  /**
+  * Clear textures for this map
+  */
+  clearTextures() {
+  }
+  /**
+  * Add cached tile to the textures of this map and update textures
+  *
+  * @param cachedTile
+  */
+  addCachedTileAndUpdateTextures(e) {
+    this.cachedTilesByTileKey.set(e.fetchableTile.tileKey, e), this.cachedTilesByTileUrl.set(e.fetchableTile.tileUrl, e), this.throttledUpdateTextures();
+  }
+  /**
+  * Remove cached tile from the textures of this map and update textures
+  *
+  * @param tileUrl
+  */
+  removeCachedTileAndUpdateTextures(e) {
+    const r = this.cachedTilesByTileUrl.get(e);
+    r && (this.cachedTilesByTileKey.delete(r.fetchableTile.tileKey), this.cachedTilesByTileUrl.delete(e), this.throttledUpdateTextures());
+  }
+  cancelThrottledFunctions() {
+    this.throttledUpdateTextures.cancel();
+  }
+  destroy() {
+    this.gl.deleteVertexArray(this.mapVao), this.gl.deleteVertexArray(this.linesVao), this.gl.deleteVertexArray(this.pointsVao), this.gl.deleteTexture(this.cachedTilesTextureArray), this.gl.deleteTexture(this.cachedTilesScaleFactorsTexture), this.gl.deleteTexture(this.cachedTilesResourceOriginPointsAndSizesTexture), this.cancelThrottledFunctions(), super.destroy();
+  }
+  setLineGroups() {
+    this.lineGroups = [], this.options.renderFullMask && this.lineGroups.push({
+      projectedGeoLines: _(this.projectedGeoTriangulationFullMask),
+      projectedGeoPreviousLines: _(this.projectedGeoPreviousTriangulationFullMask),
+      viewportSize: this.options.renderFullMaskSize,
+      color: this.options.renderFullMaskColor,
+      viewportBorderSize: this.options.renderFullMaskBorderSize,
+      borderColor: this.options.renderFullMaskBorderColor
+    }), this.options.renderAppliedMask && this.lineGroups.push({
+      projectedGeoLines: _(this.projectedGeoTriangulationAppliedMask),
+      projectedGeoPreviousLines: _(this.projectedGeoPreviousTriangulationAppliedMask),
+      viewportSize: this.options.renderAppliedMaskSize,
+      color: this.options.renderAppliedMaskColor,
+      viewportBorderSize: this.options.renderAppliedMaskBorderSize,
+      borderColor: this.options.renderAppliedMaskBorderColor
+    }), this.options.renderMask && this.lineGroups.push({
+      projectedGeoLines: _(this.projectedGeoTriangulationMask),
+      projectedGeoPreviousLines: _(this.projectedGeoPreviousTriangulationMask),
+      viewportSize: this.options.renderMaskSize,
+      color: this.options.renderMaskColor,
+      viewportBorderSize: this.options.renderMaskBorderSize,
+      borderColor: this.options.renderMaskBorderColor
+    }), this.options.renderVectors && this.lineGroups.push({
+      projectedGeoLines: G(this.projectedGeoPoints, this.projectedGeoTransformedResourcePoints),
+      projectedGeoPreviousLines: G(this.projectedGeoPoints, this.projectedGeoPreviousTransformedResourcePoints),
+      viewportSize: this.options.renderVectorsSize,
+      color: this.options.renderVectorsColor,
+      viewportBorderSize: this.options.renderVectorsBorderSize,
+      borderColor: this.options.renderVectorsBorderColor
+    });
+  }
+  setPointGroups() {
+    this.pointGroups = [], this.options.renderGcps && this.pointGroups.push({
+      projectedGeoPoints: this.projectedGeoPoints,
+      viewportSize: this.options.renderGcpsSize,
+      color: this.options.renderGcpsColor,
+      viewportBorderSize: this.options.renderGcpsBorderSize,
+      borderColor: this.options.renderGcpsBorderColor
+    }), this.options.renderTransformedGcps && this.pointGroups.push({
+      projectedGeoPoints: this.projectedGeoTransformedResourcePoints,
+      projectedGeoPreviousPoints: this.projectedGeoPreviousTransformedResourcePoints,
+      viewportSize: this.options.renderTransformedGcpsSize,
+      color: this.options.renderTransformedGcpsColor,
+      viewportBorderSize: this.options.renderTransformedGcpsBorderSize,
+      borderColor: this.options.renderTransformedGcpsBorderColor
+    });
+  }
+  updateVertexBuffersMap(e) {
+    if (!this.mapVao) return;
+    const r = this.gl, i = this.mapProgram;
+    r.bindVertexArray(this.mapVao), a(r, i, new Float32Array(this.resourceTrianglePoints.flat()), 2, "a_resourceTrianglePoint");
+    const h = this.projectedGeoPreviousTrianglePoints.map((n) => u(e, n));
+    a(r, i, new Float32Array(h.flat()), 2, "a_clipPreviousTrianglePoint");
+    const d = this.projectedGeoTrianglePoints.map((n) => u(e, n));
+    a(r, i, new Float32Array(d.flat()), 2, "a_clipTrianglePoint"), a(r, i, new Float32Array(this.previousTrianglePointsDistortion), 1, "a_previousTrianglePointDistortion"), a(r, i, new Float32Array(this.trianglePointsDistortion), 1, "a_trianglePointDistortion"), a(r, i, new Float32Array(this.resourceTrianglePoints.length).map((n, o) => o), 1, "a_trianglePointIndex"), a(r, i, new Float32Array(this.trianglePointsInside.map((n) => n ? 1 : 0)), 1, "a_trianglePointInside");
+  }
+  updateVertexBuffersLines(e) {
+    if (!this.linesVao) return;
+    const r = this.gl, i = this.linesProgram;
+    r.bindVertexArray(this.linesVao), this.setLineGroups();
+    const h = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines), []).map((t) => [
+      t[0],
+      t[0],
+      t[0],
+      t[1],
+      t[1],
+      t[1]
+    ]).flat().map((t) => u(e, t));
+    a(r, i, new Float32Array(h.flat()), 2, "a_clipPoint");
+    const d = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines), []).map((t) => [
+      t[1],
+      t[1],
+      t[1],
+      t[0],
+      t[0],
+      t[0]
+    ]).flat().map((t) => u(e, t));
+    a(r, i, new Float32Array(d.flat()), 2, "a_clipOtherPoint");
+    const n = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoPreviousLines || s.projectedGeoLines), []).map((t) => [
+      t[0],
+      t[0],
+      t[0],
+      t[1],
+      t[1],
+      t[1]
+    ]).flat().map((t) => u(e, t));
+    a(r, i, new Float32Array(n.flat()), 2, "a_clipPreviousPoint");
+    const o = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoPreviousLines || s.projectedGeoLines), []).map((t) => [
+      t[1],
+      t[1],
+      t[1],
+      t[0],
+      t[0],
+      t[0]
+    ]).flat().map((t) => u(e, t));
+    a(r, i, new Float32Array(o.flat()), 2, "a_clipPreviousOtherPoint");
+    const c = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines.flatMap((E) => [
+      0,
+      0,
+      1,
+      0,
+      0,
+      1
+    ])), []);
+    a(r, i, new Float32Array(c), 1, "a_isOtherPoint");
+    const T = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines.flatMap((E) => [
+      1,
+      -1,
+      1,
+      1,
+      -1,
+      1
+    ])), []);
+    a(r, i, new Float32Array(T), 1, "a_normalSign");
+    const p = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines.flatMap((E) => Array(6).fill(s.viewportSize ?? m.viewportSize))), []);
+    a(r, i, new Float32Array(p), 1, "a_viewportSize");
+    const l = this.lineGroups.reduce((t, s) => {
+      const E = A(s.color ?? m.color);
+      return t.concat(s.projectedGeoLines.flatMap((O) => Array(6).fill(E)));
+    }, []);
+    a(r, i, new Float32Array(l.flat()), 4, "a_color");
+    const f = this.lineGroups.reduce((t, s) => t.concat(s.projectedGeoLines.flatMap((E) => Array(6).fill(s.viewportBorderSize ?? m.viewportBorderSize))), []);
+    a(r, i, new Float32Array(f), 1, "a_viewportBorderSize");
+    const F = this.lineGroups.reduce((t, s) => {
+      const E = A(s.borderColor ?? m.borderColor);
+      return t.concat(s.projectedGeoLines.flatMap((O) => Array(6).fill(E)));
+    }, []);
+    a(r, i, new Float32Array(F.flat()), 4, "a_borderColor");
+  }
+  updateVertexBuffersPoints(e) {
+    if (!this.pointsVao) return;
+    const r = this.gl, i = this.pointsProgram;
+    r.bindVertexArray(this.pointsVao), this.setPointGroups();
+    const h = this.pointGroups.reduce((p, l) => p.concat(l.projectedGeoPoints), []).map((p) => u(e, p));
+    a(r, i, new Float32Array(h.flat()), 2, "a_clipPoint");
+    const d = this.pointGroups.reduce((p, l) => p.concat(l.projectedGeoPreviousPoints || l.projectedGeoPoints), []).map((p) => u(e, p));
+    a(r, i, new Float32Array(d.flat()), 2, "a_clipPreviousPoint");
+    const n = this.pointGroups.reduce((p, l) => p.concat(l.projectedGeoPoints.map((f) => l.viewportSize ?? g.viewportSize)), []);
+    a(r, i, new Float32Array(n), 1, "a_viewportSize");
+    const o = this.pointGroups.reduce((p, l) => {
+      const f = A(l.color ?? g.color);
+      return p.concat(l.projectedGeoPoints.map((F) => f));
+    }, []);
+    a(r, i, new Float32Array(o.flat()), 4, "a_color");
+    const c = this.pointGroups.reduce((p, l) => p.concat(l.projectedGeoPoints.map((f) => l.viewportBorderSize ?? g.viewportBorderSize)), []);
+    a(r, i, new Float32Array(c), 1, "a_viewportBorderSize");
+    const T = this.pointGroups.reduce((p, l) => {
+      const f = A(l.borderColor ?? g.borderColor);
+      return p.concat(l.projectedGeoPoints.map((F) => f));
+    }, []);
+    a(r, i, new Float32Array(T.flat()), 4, "a_borderColor");
+  }
+  async updateTextures() {
+    const e = this.gl;
+    if (this.updateCachedTilesForTextures(), this.cachedTilesForTexture.length == 0 || this.cachedTilesForTexture.length !== 0 && V(this.previousCachedTilesForTexture.map((o) => o.fetchableTile.tileUrl), this.cachedTilesForTexture.map((o) => o.fetchableTile.tileUrl)) || !this.image) return;
+    const r = this.tileSize[0], i = this.tileSize[1], h = this.cachedTilesForTexture.length;
+    e.pixelStorei(e.UNPACK_ALIGNMENT, 4), e.bindTexture(e.TEXTURE_2D_ARRAY, this.cachedTilesTextureArray), e.texImage3D(e.TEXTURE_2D_ARRAY, 0, e.RGBA, r, i, h, 0, e.RGBA, e.UNSIGNED_BYTE, null);
+    for (let o = 0; o < this.cachedTilesForTexture.length; o++) {
+      const c = this.cachedTilesForTexture[o].data;
+      if (c.width > r || c.height > i) throw new Error("Cached tile doesn't fit in texture");
+      const T = e.createBuffer();
+      e.bindBuffer(e.PIXEL_UNPACK_BUFFER, T), e.bufferData(e.PIXEL_UNPACK_BUFFER, c.data, e.STATIC_DRAW), e.texSubImage3D(e.TEXTURE_2D_ARRAY, 0, 0, 0, o, c.width, c.height, 1, e.RGBA, e.UNSIGNED_BYTE, 0), e.bindBuffer(e.PIXEL_UNPACK_BUFFER, null);
+    }
+    e.texParameteri(e.TEXTURE_2D_ARRAY, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D_ARRAY, e.TEXTURE_MAG_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D_ARRAY, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D_ARRAY, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE);
+    const d = this.cachedTilesForTexture.map((o) => {
+      if (o && o.fetchableTile && o.fetchableTile.options && o.fetchableTile.options.imageRequest && o.fetchableTile.options.imageRequest.region) return [
+        o.fetchableTile.options.imageRequest.region.x,
+        o.fetchableTile.options.imageRequest.region.y,
+        o.fetchableTile.options.imageRequest.region.width,
+        o.fetchableTile.options.imageRequest.region.height
+      ];
+      throw new Error("Missing resource origin points and sizes");
+    });
+    e.bindTexture(e.TEXTURE_2D, this.cachedTilesResourceOriginPointsAndSizesTexture), e.texImage2D(e.TEXTURE_2D, 0, e.R32I, 1, this.cachedTilesForTexture.length * 4, 0, e.RED_INTEGER, e.INT, new Int32Array(d.flat())), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE);
+    const n = this.cachedTilesForTexture.map((o) => o.fetchableTile.tile.tileZoomLevel.scaleFactor);
+    e.bindTexture(e.TEXTURE_2D, this.cachedTilesScaleFactorsTexture), e.texImage2D(e.TEXTURE_2D, 0, e.R32I, 1, this.cachedTilesForTexture.length, 0, e.RED_INTEGER, e.INT, new Int32Array(n)), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), this.dispatchEvent(new D(b.TEXTURESUPDATED));
+  }
+  updateCachedTilesForTextures() {
+    const e = [], r = [], i = [], h = [];
+    for (const o of this.fetchableTilesForViewport) {
+      const c = this.cachedTilesByTileUrl.get(o.tileUrl);
+      if (c) e.push(c);
+      else for (const T of this.getCachedTilesAtOtherScaleFactors(o.tile)) r.push(T);
+    }
+    h.push(...Array.from(this.cachedTilesByTileUrl.values()).filter((o) => o.isTileFromSprites()));
+    for (const o of this.overviewFetchableTilesForViewport) {
+      const c = this.cachedTilesByTileUrl.get(o.tileUrl);
+      if (c) {
+        const T = this.tileZoomLevelForViewport ? this.tileZoomLevelForViewport.rows * this.tileZoomLevelForViewport.columns : void 0;
+        (e.length === 0 || T && e.length < T) && i.push(c);
+      }
+    }
+    let d = [
+      ...e,
+      ...r,
+      ...h,
+      ...i
+    ];
+    const n = /* @__PURE__ */ new Map();
+    d.forEach((o) => n.set(o.fetchableTile.tileUrl, o)), d = [...n.values()], this.previousCachedTilesForTexture = this.cachedTilesForTexture, this.cachedTilesForTexture = d;
+  }
+  getCachedTilesAtOtherScaleFactors(e) {
+    if (this.cachedTilesByTileUrl.size === 0) return [];
+    if (!this.tileZoomLevelForViewport) return [];
+    const r = [];
+    for (e of I(e, this.image, this.tileZoomLevelForViewport.scaleFactor, Z, Y, this.tileInCachedTiles.bind(this))) {
+      const i = this.tileToCachedTile(e);
+      if (i) r.push(i);
+      else throw new Error("Tile supposed to be in cache isn't.");
+    }
+    return r;
+  }
+  tileToCachedTile(e) {
+    return this.cachedTilesByTileKey.get(v(e));
+  }
+  tileInCachedTiles(e) {
+    return this.cachedTilesByTileKey.has(v(e));
+  }
+};
+export {
+  H as WebGL2WarpedMap,
+  ce as createWebGL2WarpedMapFactory
+};
+//# sourceMappingURL=index.es280.js.map