@performant-software/geospatial 3.1.25-beta.0 → 3.1.25-beta.2

package/dist/index.es293.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es293.js","sources":["../../../node_modules/d3-geo/src/compose.js"],"sourcesContent":["export default function(a, b) {\n\n  function compose(x, y) {\n    return x = a(x, y), b(x[0], x[1]);\n  }\n\n  if (a.invert && b.invert) compose.invert = function(x, y) {\n    return x = b.invert(x, y), x && a.invert(x[0], x[1]);\n  };\n\n  return compose;\n}\n"],"names":["compose","a","b","x","y"],"mappings":"AAAA,SAAAA,EAAwBC,GAAGC,GAAG;AAE5B,WAASF,EAAQG,GAAGC,GAAG;AACrB,WAAOD,IAAIF,EAAEE,GAAGC,CAAC,GAAGF,EAAEC,EAAE,CAAC,GAAGA,EAAE,CAAC,CAAC;AAAA,EAClC;AAEA,SAAIF,EAAE,UAAUC,EAAE,aAAgB,SAAS,SAASC,GAAGC,GAAG;AACxD,WAAOD,IAAID,EAAE,OAAOC,GAAGC,CAAC,GAAGD,KAAKF,EAAE,OAAOE,EAAE,CAAC,GAAGA,EAAE,CAAC,CAAC;AAAA,EACrD,IAEOH;AACT;","x_google_ignoreList":[0]}

package/dist/index.es294.js

@@ -0,0 +1,7 @@
+function e(t) {
+  return t;
+}
+export {
+  e as default
+};
+//# sourceMappingURL=index.es294.js.map

package/dist/index.es294.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es294.js","sources":["../../../node_modules/d3-geo/src/identity.js"],"sourcesContent":["export default function(x) {\n  return x;\n}\n"],"names":["identity","x"],"mappings":"AAAA,SAAAA,EAAwBC,GAAG;AACzB,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/index.es295.js

@@ -0,0 +1,16 @@
+import c from "./index.es297.js";
+import n from "./index.es340.js";
+function S(l, a, r) {
+  var f = a[1][0] - a[0][0], m = a[1][1] - a[0][1], i = l.clipExtent && l.clipExtent();
+  l.scale(150).translate([0, 0]), i != null && l.clipExtent(null), c(r, l.stream(n));
+  var t = n.result(), u = Math.min(f / (t[1][0] - t[0][0]), m / (t[1][1] - t[0][1])), s = +a[0][0] + (f - u * (t[1][0] + t[0][0])) / 2, E = +a[0][1] + (m - u * (t[1][1] + t[0][1])) / 2;
+  return i != null && l.clipExtent(i), l.scale(u * 150).translate([s, E]);
+}
+function h(l, a, r) {
+  return S(l, [[0, 0], a], r);
+}
+export {
+  S as fitExtent,
+  h as fitSize
+};
+//# sourceMappingURL=index.es295.js.map

package/dist/index.es295.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es295.js","sources":["../../../node_modules/d3-geo/src/projection/fit.js"],"sourcesContent":["import {default as geoStream} from \"../stream\";\nimport boundsStream from \"../path/bounds\";\n\nexport function fitExtent(projection, extent, object) {\n  var w = extent[1][0] - extent[0][0],\n      h = extent[1][1] - extent[0][1],\n      clip = projection.clipExtent && projection.clipExtent();\n\n  projection\n      .scale(150)\n      .translate([0, 0]);\n\n  if (clip != null) projection.clipExtent(null);\n\n  geoStream(object, projection.stream(boundsStream));\n\n  var b = boundsStream.result(),\n      k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n      x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n      y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n\n  if (clip != null) projection.clipExtent(clip);\n\n  return projection\n      .scale(k * 150)\n      .translate([x, y]);\n}\n\nexport function fitSize(projection, size, object) {\n  return fitExtent(projection, [[0, 0], size], object);\n}\n"],"names":["fitExtent","projection","extent","object","w","h","clip","geoStream","boundsStream","b","k","x","y","fitSize","size"],"mappings":";;AAGO,SAASA,EAAUC,GAAYC,GAAQC,GAAQ;AACpD,MAAIC,IAAIF,EAAO,CAAC,EAAE,CAAC,IAAIA,EAAO,CAAC,EAAE,CAAC,GAC9BG,IAAIH,EAAO,CAAC,EAAE,CAAC,IAAIA,EAAO,CAAC,EAAE,CAAC,GAC9BI,IAAOL,EAAW,cAAcA,EAAW,WAAA;AAE/C,EAAAA,EACK,MAAM,GAAG,EACT,UAAU,CAAC,GAAG,CAAC,CAAC,GAEjBK,KAAQ,QAAML,EAAW,WAAW,IAAI,GAE5CM,EAAUJ,GAAQF,EAAW,OAAOO,CAAY,CAAC;AAEjD,MAAIC,IAAID,EAAa,OAAA,GACjBE,IAAI,KAAK,IAAIN,KAAKK,EAAE,CAAC,EAAE,CAAC,IAAIA,EAAE,CAAC,EAAE,CAAC,IAAIJ,KAAKI,EAAE,CAAC,EAAE,CAAC,IAAIA,EAAE,CAAC,EAAE,CAAC,EAAE,GAC7DE,IAAI,CAACT,EAAO,CAAC,EAAE,CAAC,KAAKE,IAAIM,KAAKD,EAAE,CAAC,EAAE,CAAC,IAAIA,EAAE,CAAC,EAAE,CAAC,MAAM,GACpDG,IAAI,CAACV,EAAO,CAAC,EAAE,CAAC,KAAKG,IAAIK,KAAKD,EAAE,CAAC,EAAE,CAAC,IAAIA,EAAE,CAAC,EAAE,CAAC,MAAM;AAExD,SAAIH,KAAQ,QAAML,EAAW,WAAWK,CAAI,GAErCL,EACF,MAAMS,IAAI,GAAG,EACb,UAAU,CAACC,GAAGC,CAAC,CAAC;AACvB;AAEO,SAASC,EAAQZ,GAAYa,GAAMX,GAAQ;AAChD,SAAOH,EAAUC,GAAY,CAAC,CAAC,GAAG,CAAC,GAAGa,CAAI,GAAGX,CAAM;AACrD;","x_google_ignoreList":[0]}

package/dist/index.es296.js

@@ -0,0 +1,63 @@
+import { cartesian as J } from "./index.es282.js";
+import { atan2 as K, asin as O, abs as B, sqrt as Q, cos as R, radians as U, epsilon as H } from "./index.es283.js";
+import { transformer as V } from "./index.es207.js";
+var I = 16, W = R(30 * U);
+function h(e, t) {
+  return +t ? Y(e, t) : X(e);
+}
+function X(e) {
+  return V({
+    point: function(t, D) {
+      t = e(t, D), this.stream.point(t[0], t[1]);
+    }
+  });
+}
+function Y(e, t) {
+  function D(i, P, q, L, M, T, w, $, r, u, l, c, s, n) {
+    var E = w - i, S = $ - P, v = E * E + S * S;
+    if (v > 4 * t && s--) {
+      var p = L + u, a = M + l, g = T + c, y = Q(p * p + a * a + g * g), o = O(g /= y), f = B(B(g) - 1) < H || B(q - r) < H ? (q + r) / 2 : K(a, p), k = e(f, o), N = k[0], A = k[1], C = N - i, F = A - P, G = S * C - E * F;
+      (G * G / v > t || B((E * C + S * F) / v - 0.5) > 0.3 || L * u + M * l + T * c < W) && (D(i, P, q, L, M, T, N, A, f, p /= y, a /= y, g, s, n), n.point(N, A), D(N, A, f, p, a, g, w, $, r, u, l, c, s, n));
+    }
+  }
+  return function(i) {
+    var P, q, L, M, T, w, $, r, u, l, c, s, n = {
+      point: E,
+      lineStart: S,
+      lineEnd: p,
+      polygonStart: function() {
+        i.polygonStart(), n.lineStart = a;
+      },
+      polygonEnd: function() {
+        i.polygonEnd(), n.lineStart = S;
+      }
+    };
+    function E(o, f) {
+      o = e(o, f), i.point(o[0], o[1]);
+    }
+    function S() {
+      r = NaN, n.point = v, i.lineStart();
+    }
+    function v(o, f) {
+      var k = J([o, f]), N = e(o, f);
+      D(r, u, $, l, c, s, r = N[0], u = N[1], $ = o, l = k[0], c = k[1], s = k[2], I, i), i.point(r, u);
+    }
+    function p() {
+      n.point = E, i.lineEnd();
+    }
+    function a() {
+      S(), n.point = g, n.lineEnd = y;
+    }
+    function g(o, f) {
+      v(P = o, f), q = r, L = u, M = l, T = c, w = s, n.point = v;
+    }
+    function y() {
+      D(r, u, $, l, c, s, q, L, P, M, T, w, I, i), n.lineEnd = p, p();
+    }
+    return n;
+  };
+}
+export {
+  h as default
+};
+//# sourceMappingURL=index.es296.js.map

package/dist/index.es296.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es296.js","sources":["../../../node_modules/d3-geo/src/projection/resample.js"],"sourcesContent":["import {cartesian} from \"../cartesian\";\nimport {abs, asin, atan2, cos, epsilon, radians, sqrt} from \"../math\";\nimport {transformer} from \"../transform\";\n\nvar maxDepth = 16, // maximum depth of subdivision\n    cosMinDistance = cos(30 * radians); // cos(minimum angular distance)\n\nexport default function(project, delta2) {\n  return +delta2 ? resample(project, delta2) : resampleNone(project);\n}\n\nfunction resampleNone(project) {\n  return transformer({\n    point: function(x, y) {\n      x = project(x, y);\n      this.stream.point(x[0], x[1]);\n    }\n  });\n}\n\nfunction resample(project, delta2) {\n\n  function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {\n    var dx = x1 - x0,\n        dy = y1 - y0,\n        d2 = dx * dx + dy * dy;\n    if (d2 > 4 * delta2 && depth--) {\n      var a = a0 + a1,\n          b = b0 + b1,\n          c = c0 + c1,\n          m = sqrt(a * a + b * b + c * c),\n          phi2 = asin(c /= m),\n          lambda2 = abs(abs(c) - 1) < epsilon || abs(lambda0 - lambda1) < epsilon ? (lambda0 + lambda1) / 2 : atan2(b, a),\n          p = project(lambda2, phi2),\n          x2 = p[0],\n          y2 = p[1],\n          dx2 = x2 - x0,\n          dy2 = y2 - y0,\n          dz = dy * dx2 - dx * dy2;\n      if (dz * dz / d2 > delta2 // perpendicular projected distance\n          || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end\n          || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance\n        resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);\n        stream.point(x2, y2);\n        resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);\n      }\n    }\n  }\n  return function(stream) {\n    var lambda00, x00, y00, a00, b00, c00, // first point\n        lambda0, x0, y0, a0, b0, c0; // previous point\n\n    var resampleStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },\n      polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }\n    };\n\n    function point(x, y) {\n      x = project(x, y);\n      stream.point(x[0], x[1]);\n    }\n\n    function lineStart() {\n      x0 = NaN;\n      resampleStream.point = linePoint;\n      stream.lineStart();\n    }\n\n    function linePoint(lambda, phi) {\n      var c = cartesian([lambda, phi]), p = project(lambda, phi);\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);\n      stream.point(x0, y0);\n    }\n\n    function lineEnd() {\n      resampleStream.point = point;\n      stream.lineEnd();\n    }\n\n    function ringStart() {\n      lineStart();\n      resampleStream.point = ringPoint;\n      resampleStream.lineEnd = ringEnd;\n    }\n\n    function ringPoint(lambda, phi) {\n      linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;\n      resampleStream.point = linePoint;\n    }\n\n    function ringEnd() {\n      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);\n      resampleStream.lineEnd = lineEnd;\n      lineEnd();\n    }\n\n    return resampleStream;\n  };\n}\n"],"names":["maxDepth","cosMinDistance","cos","radians","resample","project","delta2","resampleNone","transformer","x","y","resampleLineTo","x0","y0","lambda0","a0","b0","c0","x1","y1","lambda1","a1","b1","c1","depth","stream","dx","dy","d2","a","b","c","m","sqrt","phi2","asin","lambda2","abs","epsilon","atan2","p","x2","y2","dx2","dy2","dz","lambda00","x00","y00","a00","b00","c00","resampleStream","point","lineStart","lineEnd","ringStart","linePoint","lambda","phi","cartesian","ringPoint","ringEnd"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es297.js

@@ -0,0 +1,53 @@
+function l(n, i) {
+  n && f.hasOwnProperty(n.type) && f[n.type](n, i);
+}
+var u = {
+  Feature: function(n, i) {
+    l(n.geometry, i);
+  },
+  FeatureCollection: function(n, i) {
+    for (var e = n.features, t = -1, o = e.length; ++t < o; ) l(e[t].geometry, i);
+  }
+}, f = {
+  Sphere: function(n, i) {
+    i.sphere();
+  },
+  Point: function(n, i) {
+    n = n.coordinates, i.point(n[0], n[1], n[2]);
+  },
+  MultiPoint: function(n, i) {
+    for (var e = n.coordinates, t = -1, o = e.length; ++t < o; ) n = e[t], i.point(n[0], n[1], n[2]);
+  },
+  LineString: function(n, i) {
+    a(n.coordinates, i, 0);
+  },
+  MultiLineString: function(n, i) {
+    for (var e = n.coordinates, t = -1, o = e.length; ++t < o; ) a(e[t], i, 0);
+  },
+  Polygon: function(n, i) {
+    h(n.coordinates, i);
+  },
+  MultiPolygon: function(n, i) {
+    for (var e = n.coordinates, t = -1, o = e.length; ++t < o; ) h(e[t], i);
+  },
+  GeometryCollection: function(n, i) {
+    for (var e = n.geometries, t = -1, o = e.length; ++t < o; ) l(e[t], i);
+  }
+};
+function a(n, i, e) {
+  var t = -1, o = n.length - e, r;
+  for (i.lineStart(); ++t < o; ) r = n[t], i.point(r[0], r[1], r[2]);
+  i.lineEnd();
+}
+function h(n, i) {
+  var e = -1, t = n.length;
+  for (i.polygonStart(); ++e < t; ) a(n[e], i, 1);
+  i.polygonEnd();
+}
+function g(n, i) {
+  n && u.hasOwnProperty(n.type) ? u[n.type](n, i) : l(n, i);
+}
+export {
+  g as default
+};
+//# sourceMappingURL=index.es297.js.map

package/dist/index.es297.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es297.js","sources":["../../../node_modules/d3-geo/src/stream.js"],"sourcesContent":["function streamGeometry(geometry, stream) {\n  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n    streamGeometryType[geometry.type](geometry, stream);\n  }\n}\n\nvar streamObjectType = {\n  Feature: function(object, stream) {\n    streamGeometry(object.geometry, stream);\n  },\n  FeatureCollection: function(object, stream) {\n    var features = object.features, i = -1, n = features.length;\n    while (++i < n) streamGeometry(features[i].geometry, stream);\n  }\n};\n\nvar streamGeometryType = {\n  Sphere: function(object, stream) {\n    stream.sphere();\n  },\n  Point: function(object, stream) {\n    object = object.coordinates;\n    stream.point(object[0], object[1], object[2]);\n  },\n  MultiPoint: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n  },\n  LineString: function(object, stream) {\n    streamLine(object.coordinates, stream, 0);\n  },\n  MultiLineString: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamLine(coordinates[i], stream, 0);\n  },\n  Polygon: function(object, stream) {\n    streamPolygon(object.coordinates, stream);\n  },\n  MultiPolygon: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamPolygon(coordinates[i], stream);\n  },\n  GeometryCollection: function(object, stream) {\n    var geometries = object.geometries, i = -1, n = geometries.length;\n    while (++i < n) streamGeometry(geometries[i], stream);\n  }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n  var i = -1, n = coordinates.length - closed, coordinate;\n  stream.lineStart();\n  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n  stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n  var i = -1, n = coordinates.length;\n  stream.polygonStart();\n  while (++i < n) streamLine(coordinates[i], stream, 1);\n  stream.polygonEnd();\n}\n\nexport default function(object, stream) {\n  if (object && streamObjectType.hasOwnProperty(object.type)) {\n    streamObjectType[object.type](object, stream);\n  } else {\n    streamGeometry(object, stream);\n  }\n}\n"],"names":["streamGeometry","geometry","stream","streamGeometryType","streamObjectType","object","features","i","n","coordinates","streamLine","streamPolygon","geometries","closed","coordinate","geoStream"],"mappings":"AAAA,SAASA,EAAeC,GAAUC,GAAQ;AACxC,EAAID,KAAYE,EAAmB,eAAeF,EAAS,IAAI,KAC7DE,EAAmBF,EAAS,IAAI,EAAEA,GAAUC,CAAM;AAEtD;AAEA,IAAIE,IAAmB;AAAA,EACrB,SAAS,SAASC,GAAQH,GAAQ;AAChC,IAAAF,EAAeK,EAAO,UAAUH,CAAM;AAAA,EACxC;AAAA,EACA,mBAAmB,SAASG,GAAQH,GAAQ;AAE1C,aADII,IAAWD,EAAO,UAAUE,IAAI,IAAIC,IAAIF,EAAS,QAC9C,EAAEC,IAAIC,IAAG,CAAAR,EAAeM,EAASC,CAAC,EAAE,UAAUL,CAAM;AAAA,EAC7D;AACF,GAEIC,IAAqB;AAAA,EACvB,QAAQ,SAASE,GAAQH,GAAQ;AAC/B,IAAAA,EAAO,OAAA;AAAA,EACT;AAAA,EACA,OAAO,SAASG,GAAQH,GAAQ;AAC9B,IAAAG,IAASA,EAAO,aAChBH,EAAO,MAAMG,EAAO,CAAC,GAAGA,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC;AAAA,EAC9C;AAAA,EACA,YAAY,SAASA,GAAQH,GAAQ;AAEnC,aADIO,IAAcJ,EAAO,aAAaE,IAAI,IAAIC,IAAIC,EAAY,QACvD,EAAEF,IAAIC,IAAG,CAAAH,IAASI,EAAYF,CAAC,GAAGL,EAAO,MAAMG,EAAO,CAAC,GAAGA,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC;AAAA,EACvF;AAAA,EACA,YAAY,SAASA,GAAQH,GAAQ;AACnC,IAAAQ,EAAWL,EAAO,aAAaH,GAAQ,CAAC;AAAA,EAC1C;AAAA,EACA,iBAAiB,SAASG,GAAQH,GAAQ;AAExC,aADIO,IAAcJ,EAAO,aAAaE,IAAI,IAAIC,IAAIC,EAAY,QACvD,EAAEF,IAAIC,IAAG,CAAAE,EAAWD,EAAYF,CAAC,GAAGL,GAAQ,CAAC;AAAA,EACtD;AAAA,EACA,SAAS,SAASG,GAAQH,GAAQ;AAChC,IAAAS,EAAcN,EAAO,aAAaH,CAAM;AAAA,EAC1C;AAAA,EACA,cAAc,SAASG,GAAQH,GAAQ;AAErC,aADIO,IAAcJ,EAAO,aAAaE,IAAI,IAAIC,IAAIC,EAAY,QACvD,EAAEF,IAAIC,OAAiBC,EAAYF,CAAC,GAAGL,CAAM;AAAA,EACtD;AAAA,EACA,oBAAoB,SAASG,GAAQH,GAAQ;AAE3C,aADIU,IAAaP,EAAO,YAAYE,IAAI,IAAIC,IAAII,EAAW,QACpD,EAAEL,IAAIC,OAAkBI,EAAWL,CAAC,GAAGL,CAAM;AAAA,EACtD;AACF;AAEA,SAASQ,EAAWD,GAAaP,GAAQW,GAAQ;AAC/C,MAAIN,IAAI,IAAIC,IAAIC,EAAY,SAASI,GAAQC;AAE7C,OADAZ,EAAO,UAAA,GACA,EAAEK,IAAIC,IAAG,CAAAM,IAAaL,EAAYF,CAAC,GAAGL,EAAO,MAAMY,EAAW,CAAC,GAAGA,EAAW,CAAC,GAAGA,EAAW,CAAC,CAAC;AACrG,EAAAZ,EAAO,QAAA;AACT;AAEA,SAASS,EAAcF,GAAaP,GAAQ;AAC1C,MAAIK,IAAI,IAAIC,IAAIC,EAAY;AAE5B,OADAP,EAAO,aAAA,GACA,EAAEK,IAAIC,IAAG,CAAAE,EAAWD,EAAYF,CAAC,GAAGL,GAAQ,CAAC;AACpD,EAAAA,EAAO,WAAA;AACT;AAEA,SAAAa,EAAwBV,GAAQH,GAAQ;AACtC,EAAIG,KAAUD,EAAiB,eAAeC,EAAO,IAAI,IACvDD,EAAiBC,EAAO,IAAI,EAAEA,GAAQH,CAAM,IAE5CF,EAAeK,GAAQH,CAAM;AAEjC;","x_google_ignoreList":[0]}

package/dist/index.es298.js

@@ -0,0 +1,418 @@
+import { createHomogeneousTransform as B, invertHomogeneousTransform as L, applyHomogeneousTransform as u } from "./index.es299.js";
+import { WarpedMapEvent as D, WarpedMapEventType as b } from "./index.es213.js";
+import { TriangulatedWarpedMap as z } from "./index.es300.js";
+import { createBuffer as a } from "./index.es301.js";
+import { getTilesAtOtherScaleFactors as I, tileKey as v } from "./index.es302.js";
+import { subSetArray as V } from "./index.es216.js";
+import { lineStringToLines as _, pointsAndPointsToLines as G } from "./index.es275.js";
+import { hexToFractionalOpaqueRgba as A } from "./index.es303.js";
+import { mergeOptions as S } from "./index.es217.js";
+import "./index.es219.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.es220.js";
+import j from "./index.es304.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.es298.js.map