@performant-software/geospatial 3.1.28 → 3.1.29

package/dist/index.es195.js

@@ -1,151 +1,480 @@
-function b(e, o, r) {
-  if (e !== null)
-    for (var t, l, a, u, c, i, s, y = 0, f = 0, h, p = e.type, C = p === "FeatureCollection", v = p === "Feature", w = C ? e.features.length : 1, M = 0; M < w; M++) {
-      s = C ? e.features[M].geometry : v ? e.geometry : e, h = s ? s.type === "GeometryCollection" : !1, c = h ? s.geometries.length : 1;
-      for (var G = 0; G < c; G++) {
-        var n = 0, g = 0;
-        if (u = h ? s.geometries[G] : s, u !== null) {
-          i = u.coordinates;
-          var P = u.type;
-          switch (y = r && (P === "Polygon" || P === "MultiPolygon") ? 1 : 0, P) {
-            case null:
-              break;
-            case "Point":
-              if (o(
-                i,
-                f,
-                M,
-                n,
-                g
-              ) === !1)
-                return !1;
-              f++, n++;
-              break;
-            case "LineString":
-            case "MultiPoint":
-              for (t = 0; t < i.length; t++) {
-                if (o(
-                  i[t],
-                  f,
-                  M,
-                  n,
-                  g
-                ) === !1)
-                  return !1;
-                f++, P === "MultiPoint" && n++;
-              }
-              P === "LineString" && n++;
-              break;
-            case "Polygon":
-            case "MultiLineString":
-              for (t = 0; t < i.length; t++) {
-                for (l = 0; l < i[t].length - y; l++) {
-                  if (o(
-                    i[t][l],
-                    f,
-                    M,
-                    n,
-                    g
-                  ) === !1)
-                    return !1;
-                  f++;
-                }
-                P === "MultiLineString" && n++, P === "Polygon" && g++;
-              }
-              P === "Polygon" && n++;
-              break;
-            case "MultiPolygon":
-              for (t = 0; t < i.length; t++) {
-                for (g = 0, l = 0; l < i[t].length; l++) {
-                  for (a = 0; a < i[t][l].length - y; a++) {
-                    if (o(
-                      i[t][l][a],
-                      f,
-                      M,
-                      n,
-                      g
-                    ) === !1)
-                      return !1;
-                    f++;
-                  }
-                  g++;
-                }
-                n++;
-              }
-              break;
-            case "GeometryCollection":
-              for (t = 0; t < u.geometries.length; t++)
-                if (b(u.geometries[t], o, r) === !1)
-                  return !1;
-              break;
-            default:
-              throw new Error("Unknown Geometry Type");
-          }
-        }
-      }
-    }
-}
-function S(e, o) {
-  if (e.type === "Feature")
-    o(e, 0);
-  else if (e.type === "FeatureCollection")
-    for (var r = 0; r < e.features.length && o(e.features[r], r) !== !1; r++)
-      ;
+import { applyHomogeneousTransform as g } from "./index.es281.js";
+import { WarpedMapEvent as T, WarpedMapEventType as P } from "./index.es194.js";
+import { fetchImageInfo as v } from "./index.es302.js";
+import { rectanglesToScale as u, computeBbox as r, bboxToRectangle as i, sizeToRectangle as y } from "./index.es196.js";
+import { getPropertyFromDoubleCacheOrComputation as b, getPropertyFromCacheOrComputation as G } from "./index.es303.js";
+import { mixNumbers as d, mixLineStrings as F } from "./index.es270.js";
+import { omit as M, objectDifference as R } from "./index.es197.js";
+import { mergeOptionsUnlessUndefined as p, mergeOptions as n, mergePartialOptions as O } from "./index.es198.js";
+import { ProjectedGcpTransformer as f } from "./index.es300.js";
+import { webMercatorProjection as a } from "./index.es206.js";
+import "./index.es210.js";
+import "./index.es211.js";
+import { Image as w } from "./index.es304.js";
+import "./index.es213.js";
+import c from "./index.es305.js";
+var h = {
+  gcps: [],
+  resourceMask: [],
+  transformationType: "polynomial",
+  internalProjection: a,
+  projection: a,
+  visible: !0,
+  anticipateVisibility: !1,
+  overviewTilesMaxResolution: void 0,
+  overviewTilesSelection: "lowest",
+  applyMask: !0,
+  distortionMeasure: void 0
+}, A = {
+  minOffsetRatio: 0.01,
+  maxDepth: 5,
+  differentHandedness: !0
+}, l = {
+  ...h,
+  ...A
+};
+function z() {
+  return (m, e, t, o) => new V(m, e, t, o);
 }
-function k(e, o) {
-  var r, t, l, a, u, c, i, s, y, f, h = 0, p = e.type === "FeatureCollection", C = e.type === "Feature", v = p ? e.features.length : 1;
-  for (r = 0; r < v; r++) {
-    for (c = p ? e.features[r].geometry : C ? e.geometry : e, s = p ? e.features[r].properties : C ? e.properties : {}, y = p ? e.features[r].bbox : C ? e.bbox : void 0, f = p ? e.features[r].id : C ? e.id : void 0, i = c ? c.type === "GeometryCollection" : !1, u = i ? c.geometries.length : 1, l = 0; l < u; l++) {
-      if (a = i ? c.geometries[l] : c, a === null) {
-        if (o(
-          null,
-          h,
-          s,
-          y,
-          f
-        ) === !1)
-          return !1;
-        continue;
-      }
-      switch (a.type) {
-        case "Point":
-        case "LineString":
-        case "MultiPoint":
-        case "Polygon":
-        case "MultiLineString":
-        case "MultiPolygon": {
-          if (o(
-            a,
-            h,
-            s,
-            y,
-            f
-          ) === !1)
-            return !1;
-          break;
-        }
-        case "GeometryCollection": {
-          for (t = 0; t < a.geometries.length; t++)
-            if (o(
-              a.geometries[t],
-              h,
-              s,
-              y,
-              f
-            ) === !1)
-              return !1;
-          break;
-        }
-        default:
-          throw new Error("Unknown Geometry Type");
+var V = class k extends EventTarget {
+  mapId;
+  georeferencedMap;
+  defaultOptions;
+  georeferencedMapOptions;
+  listOptions;
+  mapOptions;
+  options;
+  fetchingImageInfo;
+  image;
+  tileSize;
+  abortController;
+  mixed = !1;
+  visible;
+  previousVisible;
+  visibilityOpacity;
+  previousVisibilityOpacity;
+  applyMask;
+  previousApplyMask;
+  applyMaskOpacity;
+  previousApplyMaskOpacity;
+  gcps;
+  projectedGcps;
+  resourcePoints;
+  geoPoints;
+  projectedGeoPoints;
+  projectedGeoTransformedResourcePoints;
+  projectedGeoPreviousTransformedResourcePoints;
+  resourceFullMask;
+  resourceFullMaskBbox;
+  resourceFullMaskRectangle;
+  resourceMask;
+  resourceMaskBbox;
+  resourceMaskRectangle;
+  resourceAppliedMask;
+  resourceAppliedMaskBbox;
+  resourceAppliedMaskRectangle;
+  transformationType;
+  previousTransformationType;
+  internalProjection;
+  previousInternalProjection;
+  projection;
+  projectedTransformer;
+  projectedPreviousTransformer;
+  projectedTransformerCache;
+  projectedTransformerDoubleCache;
+  geoFullMask;
+  geoFullMaskBbox;
+  geoFullMaskRectangle;
+  geoMask;
+  geoMaskBbox;
+  geoMaskRectangle;
+  geoAppliedMask;
+  geoAppliedMaskBbox;
+  geoAppliedMaskRectangle;
+  projectedGeoFullMask;
+  projectedGeoFullMaskBbox;
+  projectedGeoFullMaskRectangle;
+  projectedGeoMask;
+  projectedGeoMaskBbox;
+  projectedGeoMaskRectangle;
+  projectedGeoAppliedMask;
+  projectedGeoAppliedMaskBbox;
+  projectedGeoAppliedMaskRectangle;
+  resourceToProjectedGeoScale;
+  distortionMeasure;
+  previousDistortionMeasure;
+  tileZoomLevelForViewport;
+  overviewTileZoomLevelForViewport;
+  projectedGeoBufferedViewportRectangleForViewport;
+  projectedGeoBufferedViewportRectangleBboxForViewport;
+  resourceBufferedViewportRingForViewport;
+  resourceBufferedViewportRingBboxForViewport;
+  resourceBufferedViewportRingBboxAndResourceMaskBboxIntersectionForViewport;
+  fetchableTilesForViewport = [];
+  overviewFetchableTilesForViewport = [];
+  /**
+  * Creates an instance of WarpedMap.
+  *
+  * @param mapId - ID of the map
+  * @param georeferencedMap - Georeferenced map used to construct the WarpedMap
+  * @param options - options
+  */
+  constructor(e, t, o = {}, s = {}) {
+    super(), this.mapId = e, this.georeferencedMap = t, this.projectedTransformerCache = /* @__PURE__ */ new Map(), this.projectedTransformerDoubleCache = /* @__PURE__ */ new Map(), this.fetchingImageInfo = !1, this.mapOptions = s, this.listOptions = o, this.georeferencedMapOptions = {
+      transformationType: t.transformation?.type,
+      internalProjection: t.resourceCrs,
+      gcps: t.gcps,
+      resourceMask: t.resourceMask
+    }, this.setDefaultOptions(), this.applyOptions({ stage: "init" });
+  }
+  /**
+  * Get default options
+  */
+  static getDefaultOptions() {
+    return h;
+  }
+  /**
+  * Get default options without the options overwritten by the georeferenced map
+  */
+  static getDefaultWithoutGeoreferencedMapOptions() {
+    return M(h, [
+      "transformationType",
+      "internalProjection",
+      "resourceMask",
+      "gcps"
+    ]);
+  }
+  /**
+  * Get the resource applied mask, mask or full mask, based on an input option.
+  */
+  getResourceAppliedMask(e) {
+    return e === void 0 ? this.resourceAppliedMask : e ? this.resourceMask : this.resourceFullMask;
+  }
+  /**
+  * Get the geo applied mask, mask or full mask, based on an input option.
+  */
+  getGeoAppliedMask(e) {
+    return e === void 0 ? this.geoAppliedMask : e ? this.geoMask : this.geoFullMask;
+  }
+  /**
+  * Get the projected geo applied mask, mask or full mask, based on an input option.
+  */
+  getProjectedGeoAppliedMask(e) {
+    return e === void 0 ? this.projectedGeoAppliedMask : e ? this.projectedGeoMask : this.projectedGeoFullMask;
+  }
+  /**
+  * Get default and georeferenced map options
+  */
+  getDefaultAndGeoreferencedMapOptions() {
+    return p(this.defaultOptions, this.georeferencedMapOptions);
+  }
+  /**
+  * Get scale of the warped map, in resource pixels per viewport pixels.
+  *
+  * @param viewport - the current viewport
+  * @returns
+  */
+  getResourceToViewportScale(e) {
+    return u(this.resourceMaskRectangle, this.projectedGeoMaskRectangle.map((t) => g(e.projectedGeoToViewportHomogeneousTransform, t)));
+  }
+  /**
+  * Get scale of the warped map, in resource pixels per canvas pixels.
+  *
+  * @param viewport - the current viewport
+  * @returns
+  */
+  getResourceToCanvasScale(e) {
+    return this.getResourceToViewportScale(e) / e.devicePixelRatio;
+  }
+  /**
+  * Get the reference scaling from the forward transformation of the projected Helmert transformer
+  *
+  * @returns
+  */
+  getReferenceScale() {
+    return this.getProjectedTransformer("helmert").getToGeoTransformation().getMeasures().scale;
+  }
+  /**
+  * Get a projected transformer of the given transformation type.
+  *
+  * Uses cashed projected transformers by transformation type,
+  * and only computes a new projected transformer if none found.
+  *
+  * Returns a projected transformer in the current projection,
+  * even if the cached transformer was computed in a different projection.
+  *
+  * Default settings apply for the options.
+  *
+  * @params transformationType - the transformation type
+  * @params partialProjectedGcpTransformerOptions - options
+  * @returns A projected transformer
+  */
+  getProjectedTransformer(e, t) {
+    const o = p(l, {
+      projection: this.projection,
+      internalProjection: this.internalProjection
+    }, t);
+    return e = e ?? this.transformationType, b(this.projectedTransformerDoubleCache, e, this.projection.definition, () => {
+      const s = G(this.projectedTransformerCache, e, () => new f(this.gcps, e, M(o, ["projection"])));
+      return f.setProjection(c(s), o.projection);
+    });
+  }
+  /**
+  * Set the defaultOptions
+  */
+  setDefaultOptions() {
+    this.defaultOptions = k.getDefaultOptions();
+  }
+  /**
+  * Set the list options
+  *
+  * @param listOptions - list options
+  * @param animationOptions - Animation options
+  */
+  setListOptions(e, t) {
+    return this.setMapAndListOptions(void 0, e, t);
+  }
+  /**
+  * Set the map-specific options
+  *
+  * @param mapOptions - Map-specific options
+  * @param animationOptions - Animation options
+  */
+  setMapOptions(e, t) {
+    return this.setMapAndListOptions(e, void 0, t);
+  }
+  /**
+  * Set the map-specific options, and the list options
+  *
+  * @param mapOptions - Map-specific options
+  * @param listOptions - list options
+  * @param animationOptions - Animation options
+  */
+  setMapAndListOptions(e, t, o) {
+    const s = [];
+    return e !== void 0 && Object.keys(e).length > 0 && (this.mapOptions = n(this.mapOptions, e), s.push(...Object.keys(e))), t !== void 0 && Object.keys(t).length > 0 && (this.listOptions = n(this.listOptions, t), s.push(...Object.keys(t))), this.applyOptions(O(o, { optionKeysPossiblyChanged: s }));
+  }
+  applyOptions(e) {
+    const t = p(this.defaultOptions, this.georeferencedMapOptions, this.listOptions, this.mapOptions), o = e?.optionKeysPossiblyChanged?.filter((j) => e.optionKeysToOmit ? !e.optionKeysToOmit.includes(j) : !0), s = R(t, this.options, o);
+    return this.options = n(this.options, s), e?.stage == "init" ? (this.visible = this.options.visible, this.previousVisible = this.visible, this.visibilityOpacity = this.visible ? 1 : 0, this.previousVisibilityOpacity = this.visibilityOpacity, this.applyMask = this.options.applyMask, this.previousApplyMask = this.applyMask, this.applyMaskOpacity = this.applyMask ? 0 : 1, this.previousApplyMaskOpacity = this.applyMaskOpacity, this.gcps = this.options.gcps, this.resourceFullMask = this.getResourceFullMask(), this.resourceMask = this.georeferencedMap.resourceMask, this.resourceAppliedMask = this.applyMask ? this.resourceMask : this.resourceFullMask, this.updateResourceMaskProperties(), this.transformationType = this.options.transformationType, this.previousTransformationType = this.transformationType, this.internalProjection = this.options.internalProjection, this.previousInternalProjection = this.internalProjection, this.projection = this.options.projection, this.updateProjectedTransformerProperties()) : ("visible" in s && (this.visible = this.options.visible, this.visibilityOpacity = this.visible ? 1 : 0), "gcps" in s && this.setGcps(this.options.gcps), ("resourceMask" in s || "applyMask" in s) && (this.applyMask = this.options.applyMask, this.applyMaskOpacity = this.applyMask ? 0 : 1, this.setResourceMask()), "transformationType" in s && this.setTransformationType(this.options.transformationType), "internalProjection" in s && this.setInternalProjection(this.options.internalProjection), "projection" in s && this.setProjection(this.options.projection), ("distortionMeasure" in s || "distortionMeasures" in s) && this.setDistortionMeasure(this.options.distortionMeasure)), s;
+  }
+  shouldRenderMap(e) {
+    return this.options.visible !== !1 || this.previousVisible !== !1;
+  }
+  shouldRenderLines() {
+    return this.options.visible !== !1 || this.previousVisible !== !1;
+  }
+  shouldRenderPoints() {
+    return this.options.visible !== !1 || this.previousVisible !== !1;
+  }
+  /**
+  * Update the ground control points loaded from a georeferenced map to new ground control points.
+  *
+  * @param gcps
+  */
+  setGcps(e) {
+    this.gcps = e, this.clearProjectedTransformerCaches(), this.updateProjectedTransformerProperties();
+  }
+  /**
+  * Update the resource mask loaded from a georeferenced map to a new mask.
+  *
+  * @param resourceMask
+  */
+  setResourceMask() {
+    this.resourceFullMask = this.getResourceFullMask(), this.resourceMask = this.options.resourceMask, this.resourceAppliedMask = this.applyMask ? this.resourceMask : this.resourceFullMask, this.updateResourceMaskProperties(), this.updateGeoMaskProperties(), this.updateProjectedGeoMaskProperties();
+  }
+  /**
+  * Set the transformationType
+  *
+  * @param transformationType
+  */
+  setTransformationType(e) {
+    this.transformationType = e, this.previousTransformationType || (this.previousTransformationType = this.transformationType), this.updateProjectedTransformerProperties();
+  }
+  /**
+  * Set the distortionMeasure
+  *
+  * @param distortionMeasure - the disortion measure
+  */
+  setDistortionMeasure(e) {
+    this.distortionMeasure = e;
+  }
+  /**
+  * Set the internal projection
+  *
+  * @param projection - the internal projection
+  */
+  setInternalProjection(e) {
+    this.internalProjection = e || l.internalProjection || a, this.previousInternalProjection || (this.previousInternalProjection = this.internalProjection), this.clearProjectedTransformerCaches(), this.updateProjectedTransformerProperties();
+  }
+  /**
+  * Set the projection
+  *
+  * @param projection - the projection
+  */
+  setProjection(e) {
+    this.projection = e || l.projection || a, this.updateProjectedTransformerProperties();
+  }
+  /**
+  * Set the tile zoom level for the current viewport
+  *
+  * @param tileZoomLevel - tile zoom level for the current viewport
+  */
+  setTileZoomLevelForViewport(e) {
+    this.tileZoomLevelForViewport = e;
+  }
+  /**
+  * Set the overview tile zoom level for the current viewport
+  *
+  * @param tileZoomLevel - tile zoom level for the current viewport
+  */
+  setOverviewTileZoomLevelForViewport(e) {
+    this.overviewTileZoomLevelForViewport = e;
+  }
+  /**
+  * Set projectedGeoBufferedViewportRectangle for the current viewport
+  *
+  * @param projectedGeoBufferedViewportRectangle
+  */
+  setProjectedGeoBufferedViewportRectangleForViewport(e) {
+    this.projectedGeoBufferedViewportRectangleForViewport = e, this.projectedGeoBufferedViewportRectangleBboxForViewport = e ? r(e) : void 0;
+  }
+  /**
+  * Set resourceBufferedViewportRing for the current viewport
+  *
+  * @param resourceBufferedViewportRing
+  */
+  setResourceBufferedViewportRingForViewport(e) {
+    this.resourceBufferedViewportRingForViewport = e, this.resourceBufferedViewportRingBboxForViewport = e ? r(e) : void 0;
+  }
+  /**
+  * Set resourceBufferedViewportRingBboxAndResourceAppliedMaskBboxIntersection for the current viewport
+  *
+  * @param resourceBufferedViewportRingBboxAndResourceAppliedMaskBboxIntersection
+  */
+  setResourceBufferedViewportRingBboxAndResourceAppliedMaskBboxIntersectionForViewport(e) {
+    this.resourceBufferedViewportRingBboxAndResourceMaskBboxIntersectionForViewport = e;
+  }
+  /**
+  * Set tiles for the current viewport
+  *
+  * @param fetchableTiles
+  */
+  setFetchableTilesForViewport(e) {
+    this.fetchableTilesForViewport = e;
+  }
+  /**
+  * Set overview tiles for the current viewport
+  *
+  * @param overviewFetchableTiles
+  */
+  setOverviewFetchableTilesForViewport(e) {
+    this.overviewFetchableTilesForViewport = e;
+  }
+  /**
+  * Reset the properties for the current values
+  */
+  resetForViewport() {
+    this.setTileZoomLevelForViewport(), this.setOverviewTileZoomLevelForViewport(), this.setProjectedGeoBufferedViewportRectangleForViewport(), this.setResourceBufferedViewportRingForViewport(), this.setFetchableTilesForViewport([]), this.setOverviewFetchableTilesForViewport([]);
+  }
+  /**
+  * Reset previous transform properties to new ones (when completing an animation).
+  */
+  resetPrevious() {
+    this.mixed = !1, this.previousVisible = this.visible, this.previousVisibilityOpacity = this.visibilityOpacity, this.previousApplyMask = this.applyMask, this.previousApplyMaskOpacity = this.applyMaskOpacity, this.previousTransformationType = this.transformationType, this.previousDistortionMeasure = this.distortionMeasure, this.previousInternalProjection = this.internalProjection, this.projectedPreviousTransformer = c(this.projectedTransformer), this.projectedGeoPreviousTransformedResourcePoints = this.projectedGeoTransformedResourcePoints;
+  }
+  /**
+  * Mix previous transform properties with new ones (when changing an ongoing animation).
+  *
+  * @param t - animation progress
+  */
+  mixPreviousAndNew(e) {
+    this.mixed = !0, this.previousVisible = this.visible, this.previousVisibilityOpacity = d(this.visibilityOpacity, this.previousVisibilityOpacity, e), this.previousApplyMask = this.applyMask, this.previousApplyMaskOpacity = d(this.applyMaskOpacity, this.previousApplyMaskOpacity, e), this.previousTransformationType = this.transformationType, this.previousDistortionMeasure = this.distortionMeasure, this.previousInternalProjection = this.internalProjection, this.projectedPreviousTransformer = c(this.projectedTransformer), this.projectedGeoPreviousTransformedResourcePoints = F(this.projectedGeoTransformedResourcePoints, this.projectedGeoPreviousTransformedResourcePoints, e);
+  }
+  /**
+  * Check if this instance has parsed image
+  *
+  * @returns
+  */
+  hasImage() {
+    return this.image !== void 0;
+  }
+  /**
+  * Load the parsed image from cache, or fetch and parse the image info to create it
+  *
+  * @returns
+  */
+  async loadImage(e) {
+    try {
+      const t = this.georeferencedMap.resource.id;
+      if (e && e.has(t)) this.image = e.get(t);
+      else {
+        this.fetchingImageInfo = !0, this.abortController = new AbortController();
+        const o = this.abortController.signal, s = await v(t, { signal: o }, this.options.fetchFn);
+        this.abortController = void 0, this.image = w.parse(s), e && e.set(t, this.image);
       }
+      this.tileSize = [Math.max(...this.image.tileZoomLevels.map((o) => o.width)), Math.max(...this.image.tileZoomLevels.map((o) => o.height))], this.dispatchEvent(new T(P.IMAGELOADED));
+    } catch (t) {
+      throw this.fetchingImageInfo = !1, t;
+    } finally {
+      this.fetchingImageInfo = !1;
     }
-    h++;
   }
-}
+  updateResourceMaskProperties() {
+    this.resourceFullMaskBbox = r(this.resourceFullMask), this.resourceFullMaskRectangle = i(this.resourceFullMaskBbox), this.resourceMaskBbox = r(this.resourceMask), this.resourceMaskRectangle = i(this.resourceMaskBbox), this.resourceAppliedMaskBbox = r(this.resourceAppliedMask), this.resourceAppliedMaskRectangle = i(this.resourceAppliedMaskBbox);
+  }
+  getResourceFullMask() {
+    const e = this.georeferencedMap.resource.width, t = this.georeferencedMap.resource.height;
+    return e && t ? y([e, t]) : i(r(this.georeferencedMap.resourceMask));
+  }
+  updateGeoMaskProperties() {
+    this.updateFullGeoMask(), this.updateGeoMask(), this.updateAppliedGeoMask();
+  }
+  updateProjectedGeoMaskProperties() {
+    this.updateProjectedFullGeoMask(), this.updateProjectedGeoMask(), this.updateProjectedAppliedGeoMask(), this.updateResourceToProjectedGeoScale();
+  }
+  updateProjectedTransformerProperties() {
+    this.updateProjectedTransformer(), this.updateGeoMaskProperties(), this.updateProjectedGeoMaskProperties(), this.updateGcpsProperties();
+  }
+  updateProjectedTransformer() {
+    this.projectedTransformer = this.getProjectedTransformer(this.transformationType), this.projectedPreviousTransformer || (this.projectedPreviousTransformer = this.projectedTransformer);
+  }
+  updateFullGeoMask() {
+    this.geoFullMask = this.projectedTransformer.transformToGeo([this.resourceFullMask])[0], this.geoFullMaskBbox = r(this.geoFullMask), this.geoFullMaskRectangle = this.projectedTransformer.transformToGeo([this.resourceFullMaskRectangle], { maxDepth: 0 })[0];
+  }
+  updateGeoMask() {
+    this.geoMask = this.projectedTransformer.transformToGeo([this.resourceMask])[0], this.geoMaskBbox = r(this.geoMask), this.geoMaskRectangle = this.projectedTransformer.transformToGeo([this.resourceMaskRectangle], { maxDepth: 0 })[0];
+  }
+  updateAppliedGeoMask() {
+    this.geoAppliedMask = this.applyMask ? this.geoMask : this.geoFullMask, this.geoAppliedMaskBbox = this.applyMask ? this.geoMaskBbox : this.geoFullMaskBbox, this.geoAppliedMaskRectangle = this.applyMask ? this.geoMaskRectangle : this.geoFullMaskRectangle;
+  }
+  updateProjectedFullGeoMask() {
+    this.projectedGeoFullMask = this.projectedTransformer.transformToProjectedGeo([this.resourceFullMask])[0], this.projectedGeoFullMaskBbox = r(this.projectedGeoFullMask), this.projectedGeoFullMaskRectangle = this.projectedTransformer.transformToProjectedGeo([this.resourceFullMaskRectangle], { maxDepth: 0 })[0];
+  }
+  updateProjectedGeoMask() {
+    this.projectedGeoMask = this.projectedTransformer.transformToProjectedGeo([this.resourceMask])[0], this.projectedGeoMaskBbox = r(this.projectedGeoMask), this.projectedGeoMaskRectangle = this.projectedTransformer.transformToProjectedGeo([this.resourceMaskRectangle], { maxDepth: 0 })[0];
+  }
+  updateProjectedAppliedGeoMask() {
+    this.projectedGeoAppliedMask = this.applyMask ? this.projectedGeoMask : this.projectedGeoFullMask, this.projectedGeoAppliedMaskBbox = this.applyMask ? this.projectedGeoMaskBbox : this.projectedGeoFullMaskBbox, this.projectedGeoAppliedMaskRectangle = this.applyMask ? this.projectedGeoMaskRectangle : this.projectedGeoFullMaskRectangle;
+  }
+  updateResourceToProjectedGeoScale() {
+    this.resourceToProjectedGeoScale = u(this.resourceMaskRectangle, this.projectedGeoMaskRectangle);
+  }
+  updateGcpsProperties() {
+    this.projectedGcps = this.gcps.map(({ resource: e, geo: t }) => ({
+      resource: e,
+      geo: this.projectedTransformer.lonLatToProjection(t)
+    })), this.resourcePoints = this.gcps.map((e) => e.resource), this.geoPoints = this.gcps.map((e) => e.geo), this.projectedGeoPoints = this.projectedGcps.map((e) => e.geo), this.projectedGeoTransformedResourcePoints = this.gcps.map((e) => this.projectedTransformer.transformToProjectedGeo(e.resource)), this.projectedGeoPreviousTransformedResourcePoints || (this.projectedGeoPreviousTransformedResourcePoints = this.projectedGeoTransformedResourcePoints);
+  }
+  clearProjectedTransformerCaches() {
+    this.projectedTransformerCache = /* @__PURE__ */ new Map(), this.projectedTransformerDoubleCache = /* @__PURE__ */ new Map();
+  }
+  destroy() {
+    this.abortController && this.abortController.abort();
+  }
+};
 export {
-  b as coordEach,
-  S as featureEach,
-  k as geomEach
+  V as WarpedMap,
+  z as createWarpedMapFactory
 };
 //# sourceMappingURL=index.es195.js.map