@performant-software/geospatial 3.1.25-beta.1 → 3.1.25

package/dist/index.es287.js

@@ -0,0 +1,89 @@
+import D from "./index.es465.js";
+import K from "./index.es199.js";
+import { polygonIsBboxRectangle as O, computeBbox as U } from "./index.es196.js";
+import { conformPolygon as $, midPoint as j, triangleAngles as z, closePolygon as H } from "./index.es275.js";
+import { mergeOptions as J } from "./index.es198.js";
+import { buildKDBushPointIndex as Q, splitPolygonLines as b, preprocessPolygonForInsideCheck as F, coordsInPolygonForInsidenessCheck as C, interpolatePolygon as B, bboxToGridPoints as V, coordsInPolygonsForInsidenessCheck as W } from "./index.es466.js";
+import { interpolateRing as ae } from "./index.es466.js";
+const X = 1e-4, Y = {
+  steinerPoints: [],
+  steinerPolygons: [],
+  minimumTriangleAngle: X,
+  computeInsideSteinerPolygons: !1
+};
+function se(o, u, E) {
+  const s = J(Y, E);
+  o = $(o);
+  const R = O(o);
+  let g = s.steinerPolygons.map((e) => $(e));
+  const T = Q(s.steinerPoints);
+  o = b(o, s.steinerPoints, T), g = g.map((e) => b(e, s.steinerPoints, T));
+  const c = F(o), G = s.steinerPoints.filter((e) => C(e[0], e[1], c));
+  let P = [], m = [], d = [], f = [], I = [], y = [];
+  u ? (P = B(o, u), d = g.map((e) => B(e, u)), I = V(U(o), u), y = I.filter((e) => C(e[0], e[1], c))) : (P = o, d = g), m = P.flat(), f = d.flat(2);
+  const L = [
+    ...m,
+    ...y,
+    ...f,
+    ...G
+  ], l = [], h = /* @__PURE__ */ new Map();
+  for (const e of L) {
+    const n = `${e[0]},${e[1]}`;
+    h.has(n) || (h.set(n, l.length), l.push(e));
+  }
+  const A = ([e, n]) => {
+    const i = h.get(`${e},${n}`);
+    if (i === void 0)
+      throw new Error(`Point not found in uniquePoints: [${e}, ${n}]`);
+    return i;
+  }, x = P.map((e) => e.map(A)), S = new Set(x.flat()), k = d.map((e) => e.map((n) => n.map(A))), w = [
+    ...x,
+    ...k.flat()
+  ].flatMap((e) => e.map((n, i) => [
+    n,
+    e[(i + 1) % e.length]
+  ])), N = new D(l.flat()), t = new K(N);
+  t.delaunify(!0), t.constrainAll(w);
+  let p = [], r = [];
+  const M = [];
+  for (let e = 0; e < t.del.triangles.length; e += 3)
+    p.push([
+      t.del.triangles[e],
+      t.del.triangles[e + 1],
+      t.del.triangles[e + 2]
+    ]), r.push([
+      l[t.del.triangles[e]],
+      l[t.del.triangles[e + 1]],
+      l[t.del.triangles[e + 2]]
+    ]), M.push(S.has(t.del.triangles[e]) || S.has(t.del.triangles[e + 1]) || S.has(t.del.triangles[e + 2]));
+  let a = r.map((e) => j(...e));
+  const q = r.map((e, n) => M[n] ? (R ? !0 : C(a[n][0], a[n][1], c)) && z(e).every((i) => i >= s.minimumTriangleAngle) : !0);
+  p = p.filter((e, n) => q[n]), r = r.filter((e, n) => q[n]), a = a.filter((e, n) => q[n]);
+  let _ = [];
+  const v = g.map((e) => H(e));
+  if (s.computeInsideSteinerPolygons) {
+    const e = v.map((n) => F(n));
+    _ = r.map((n, i) => W(a[i][0], a[i][1], e) === !0);
+  }
+  return {
+    interpolatedPolygon: P,
+    interpolatedPolygonPoints: m,
+    gridPoints: I,
+    gridPointsInPolygon: y,
+    interpolatedSteinerPolygons: d,
+    interpolatedSteinerPolygonsPoints: f,
+    uniquePoints: l,
+    triangles: r,
+    uniquePointIndexTriangles: p,
+    uniquePointIndexInterpolatedPolygon: x,
+    uniquePointIndexEdges: w,
+    uniquePointIndexInterpolatedSteinerPolygons: k,
+    insideSteinerPolygonsTriangles: _
+  };
+}
+export {
+  B as interpolatePolygon,
+  ae as interpolateRing,
+  se as triangulateToUnique
+};
+//# sourceMappingURL=index.es287.js.map

package/dist/index.es287.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es287.js","sources":["../../../node_modules/@allmaps/triangulate/dist/triangulate.js"],"sourcesContent":["import Delaunator from 'delaunator';\nimport Constrainautor from '@kninnug/constrainautor';\nimport { closePolygon, computeBbox, conformPolygon, mergeOptions, midPoint, polygonIsBboxRectangle, triangleAngles } from '@allmaps/stdlib';\nimport { bboxToGridPoints, interpolateRing, interpolatePolygon, coordsInPolygonForInsidenessCheck, preprocessPolygonForInsideCheck, coordsInPolygonsForInsidenessCheck, buildKDBushPointIndex, splitPolygonLines } from './shared.js';\nconst MINIMUM_TRIANGLE_ANGLE = 0.0001;\nconst defaultTriangulationOptions = {\n    steinerPoints: [],\n    steinerPolygons: [],\n    minimumTriangleAngle: MINIMUM_TRIANGLE_ANGLE,\n    computeInsideSteinerPolygons: false\n};\nexport { interpolateRing, interpolatePolygon };\n/**\n * Triangulate a polygon to triangles smaller then a distance\n *\n * Grid points are placed inside the polygon to obtain small, well conditioned triangles.\n *\n * @param polygon - Polygon\n * @param distance - Distance that conditions the triangles\n * @param triangulationOptions - Triangulation Options.\n * @returns Array of triangles partitioning the polygon\n */\nexport function triangulate(polygon, distance, triangulationOptions) {\n    {\n        const { triangles } = triangulateToUnique(polygon, distance, triangulationOptions);\n        return triangles;\n    }\n}\n/**\n * Triangulate a polygon to triangles smaller then a distance, and return them via unique points.\n *\n * Grid points are placed inside the polygon to obtain small, well conditioned triangles.\n *\n * This function returns the triangulation as an array of unique points, and triangles of indices refering to those unique points.\n *\n * @param polygon - Polygon\n * @param distance - Distance that conditions the triangles\n * @param partialOptions - Triangulation Options.\n * @returns Triangulation Object with uniquePointIndexTriangles and uniquePoints\n */\nexport function triangulateToUnique(polygon, distance, partialOptions) {\n    const options = mergeOptions(defaultTriangulationOptions, partialOptions);\n    // Conform polygon and Steiner polygons (this also checks if there are at least 3 points)\n    polygon = conformPolygon(polygon);\n    const polygonIsRectangle = polygonIsBboxRectangle(polygon);\n    let steinerPolygons = options.steinerPolygons.map((steinerPolygon) => conformPolygon(steinerPolygon));\n    // Split polygon and Steiner polygons using Steiner points\n    const steinerPointIndex = buildKDBushPointIndex(options.steinerPoints);\n    polygon = splitPolygonLines(polygon, options.steinerPoints, steinerPointIndex);\n    steinerPolygons = steinerPolygons.map((steinerPolygon) => splitPolygonLines(steinerPolygon, options.steinerPoints, steinerPointIndex));\n    // Preprocess polygon\n    const polygonForInsidenessCheck = preprocessPolygonForInsideCheck(polygon);\n    // Gather Steinerpoints\n    const steinerPointsInPolygon = options.steinerPoints.filter((point) => coordsInPolygonForInsidenessCheck(point[0], point[1], polygonForInsidenessCheck));\n    // Interpolate polygons and create grid based on distance\n    let interpolatedPolygon = [];\n    let interpolatedPolygonPoints = [];\n    let interpolatedSteinerPolygons = [];\n    let interpolatedSteinerPolygonsPoints = [];\n    let gridPoints = [];\n    let gridPointsInPolygon = [];\n    if (distance) {\n        // Interpolate polygon\n        interpolatedPolygon = interpolatePolygon(polygon, distance);\n        // Interpolate Steiner Polygons\n        interpolatedSteinerPolygons = steinerPolygons.map((steinerPolygon) => interpolatePolygon(steinerPolygon, distance));\n        // Add grid points inside the polygon\n        gridPoints = bboxToGridPoints(computeBbox(polygon), distance);\n        gridPointsInPolygon = gridPoints.filter((point) => coordsInPolygonForInsidenessCheck(point[0], point[1], polygonForInsidenessCheck));\n    }\n    else {\n        interpolatedPolygon = polygon;\n        interpolatedSteinerPolygons = steinerPolygons;\n    }\n    interpolatedPolygonPoints = interpolatedPolygon.flat();\n    interpolatedSteinerPolygonsPoints = interpolatedSteinerPolygons.flat(2);\n    // Gather all points and deduplicate to keep only unique points\n    // with map from points to their index in uniquePoints, and index getter\n    const allPoints = [\n        ...interpolatedPolygonPoints,\n        ...gridPointsInPolygon,\n        ...interpolatedSteinerPolygonsPoints,\n        ...steinerPointsInPolygon\n    ];\n    const uniquePoints = [];\n    const uniquePointIndexByPointString = new Map();\n    for (const point of allPoints) {\n        const key = `${point[0]},${point[1]}`;\n        if (!uniquePointIndexByPointString.has(key)) {\n            uniquePointIndexByPointString.set(key, uniquePoints.length);\n            uniquePoints.push(point);\n        }\n    }\n    const getPointIndex = ([x, y]) => {\n        const index = uniquePointIndexByPointString.get(`${x},${y}`);\n        if (index === undefined)\n            throw new Error(`Point not found in uniquePoints: [${x}, ${y}]`);\n        return index;\n    };\n    // Lookup point indices for the edges of the interpolated polygon\n    const uniquePointIndexInterpolatedPolygon = interpolatedPolygon.map((ring) => ring.map(getPointIndex));\n    const uniquePointIndexSetInterpolatedPolygon = new Set(uniquePointIndexInterpolatedPolygon.flat());\n    // Lookup point indices for the edges of the interpolated steiner polygons\n    const uniquePointIndexInterpolatedSteinerPolygons = interpolatedSteinerPolygons.map((polygon) => polygon.map((ring) => ring.map(getPointIndex)));\n    // Gather all constrained edges\n    // TODO: consider to make unique, but this could be very expensive and low chance of non-uniquess\n    const uniquePointIndexEdges = [\n        ...uniquePointIndexInterpolatedPolygon,\n        ...uniquePointIndexInterpolatedSteinerPolygons.flat()\n    ].flatMap((ring) => ring.map((uniquePointIndex, i) => [\n        uniquePointIndex,\n        ring[(i + 1) % ring.length]\n    ]));\n    // Initialize Delaunay triangulation\n    const delautator = new Delaunator(uniquePoints.flat());\n    // Constrain triangulation\n    // Note: instead of\n    // const constrainautor = new Constrainautor(delautator, uniquePointIndexEdges)\n    // which gives an error \"Constraining edge intersects point\" for small distances, e.g. maxDepth 7 on https://gist.githubusercontent.com/sammeltassen/fa3dbfaf4dfa800e00824478c4bd1928/raw/f182beac911e38b0a1d1eb420fbd54b4e6d2f2eb/nl-railway-map.json\n    // we perform a delaunify check first as proposed by\n    // https://github.com/kninnug/Constrainautor/issues/11#issuecomment-2571296247\n    // Keep an eye on proposed solutions, sinche the delaunify check is expensive\n    const constrainautor = new Constrainautor(delautator);\n    constrainautor.delaunify(true);\n    constrainautor.constrainAll(uniquePointIndexEdges);\n    let uniquePointIndexTriangles = [];\n    let triangles = [];\n    const triangleIsAlongInterpolatedPolygon = [];\n    for (let i = 0; i < constrainautor.del.triangles.length; i += 3) {\n        uniquePointIndexTriangles.push([\n            constrainautor.del.triangles[i],\n            constrainautor.del.triangles[i + 1],\n            constrainautor.del.triangles[i + 2]\n        ]);\n        triangles.push([\n            uniquePoints[constrainautor.del.triangles[i]],\n            uniquePoints[constrainautor.del.triangles[i + 1]],\n            uniquePoints[constrainautor.del.triangles[i + 2]]\n        ]);\n        // Only classify triangles if they are along the border\n        triangleIsAlongInterpolatedPolygon.push(uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i]) ||\n            uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i + 1]) ||\n            uniquePointIndexSetInterpolatedPolygon.has(constrainautor.del.triangles[i + 2]));\n    }\n    // Triangle midPoints\n    let triangleMidPoints = triangles.map((triangle) => midPoint(...triangle));\n    // Only keep triangles inside polygon\n    const triangleShouldKeep = triangles.map((triangle, index) => {\n        // Only keep if inside (and can't be outside if polygon is bbox)\n        // This check for every triangle is expensive!\n        if (triangleIsAlongInterpolatedPolygon[index]) {\n            return ((polygonIsRectangle\n                ? true\n                : coordsInPolygonForInsidenessCheck(triangleMidPoints[index][0], triangleMidPoints[index][1], polygonForInsidenessCheck)) &&\n                triangleAngles(triangle).every((angle) => angle >= options.minimumTriangleAngle));\n        }\n        else {\n            return true;\n        }\n    });\n    uniquePointIndexTriangles = uniquePointIndexTriangles.filter((_triangle, index) => triangleShouldKeep[index]);\n    triangles = triangles.filter((_triangle, index) => triangleShouldKeep[index]);\n    triangleMidPoints = triangleMidPoints.filter((_triangle, index) => triangleShouldKeep[index]);\n    // If requested, compute if triangles are inside steiner polygons\n    // This check for every triangle is expensive!\n    let insideSteinerPolygonsTriangles = [];\n    const steinerClosedPolygons = steinerPolygons.map((steinerPolygon) => closePolygon(steinerPolygon));\n    if (options.computeInsideSteinerPolygons) {\n        const steinerClosedPolygonsForInsidenessCheck = steinerClosedPolygons.map((steinerPolygon) => preprocessPolygonForInsideCheck(steinerPolygon));\n        insideSteinerPolygonsTriangles = triangles.map((_triangle, index) => coordsInPolygonsForInsidenessCheck(triangleMidPoints[index][0], triangleMidPoints[index][1], steinerClosedPolygonsForInsidenessCheck) === true);\n    }\n    return {\n        interpolatedPolygon,\n        interpolatedPolygonPoints,\n        gridPoints,\n        gridPointsInPolygon,\n        interpolatedSteinerPolygons,\n        interpolatedSteinerPolygonsPoints,\n        uniquePoints,\n        triangles,\n        uniquePointIndexTriangles,\n        uniquePointIndexInterpolatedPolygon,\n        uniquePointIndexEdges,\n        uniquePointIndexInterpolatedSteinerPolygons,\n        insideSteinerPolygonsTriangles\n    };\n}\n"],"names":["MINIMUM_TRIANGLE_ANGLE","defaultTriangulationOptions","triangulateToUnique","polygon","distance","partialOptions","options","mergeOptions","conformPolygon","polygonIsRectangle","polygonIsBboxRectangle","steinerPolygons","steinerPolygon","steinerPointIndex","buildKDBushPointIndex","splitPolygonLines","polygonForInsidenessCheck","preprocessPolygonForInsideCheck","steinerPointsInPolygon","point","coordsInPolygonForInsidenessCheck","interpolatedPolygon","interpolatedPolygonPoints","interpolatedSteinerPolygons","interpolatedSteinerPolygonsPoints","gridPoints","gridPointsInPolygon","interpolatePolygon","bboxToGridPoints","computeBbox","allPoints","uniquePoints","uniquePointIndexByPointString","key","getPointIndex","x","y","index","uniquePointIndexInterpolatedPolygon","ring","uniquePointIndexSetInterpolatedPolygon","uniquePointIndexInterpolatedSteinerPolygons","uniquePointIndexEdges","uniquePointIndex","delautator","Delaunator","constrainautor","Constrainautor","uniquePointIndexTriangles","triangles","triangleIsAlongInterpolatedPolygon","i","triangleMidPoints","triangle","midPoint","triangleShouldKeep","triangleAngles","angle","_triangle","insideSteinerPolygonsTriangles","steinerClosedPolygons","closePolygon","steinerClosedPolygonsForInsidenessCheck","coordsInPolygonsForInsidenessCheck"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es288.js

@@ -0,0 +1,565 @@
+import { RTree as l } from "./index.es289.js";
+import { WarpedMapEvent as n, WarpedMapEventType as a } from "./index.es194.js";
+import { createWarpedMapFactory as w } from "./index.es195.js";
+import { WebGL2WarpedMap as f } from "./index.es290.js";
+import E from "./index.es204.js";
+import { bboxToCenter as A, computeBbox as y, convexHull as b, doBboxesIntersect as j, pointInBbox as F, bboxToLine as P } from "./index.es196.js";
+import { closePolygon as B } from "./index.es275.js";
+import { mergeOptions as c, optionKeysToUndefinedOptions as h, mergePartialOptions as v } from "./index.es198.js";
+import "./index.es205.js";
+import { webMercatorProjection as D, lonLatProjection as R, isEqualProjection as G } from "./index.es206.js";
+import x from "./index.es278.js";
+import { generateChecksum as L } from "./index.es291.js";
+import { parseAnnotation as O } from "./index.es292.js";
+import "./index.es208.js";
+import { validateGeoreferencedMap as I } from "./index.es293.js";
+import "./index.es207.js";
+import "./index.es209.js";
+import "./index.es210.js";
+import "./index.es211.js";
+import { Image as N } from "./index.es284.js";
+import "./index.es213.js";
+var W = { applyMask: !0 }, z = {
+  animate: !0,
+  duration: 300
+}, C = { stage: "pre" };
+function k(u) {
+  return u instanceof Error ? u : new Error(String(u));
+}
+var pe = class m extends EventTarget {
+  /**
+  * Maps in this list, indexed by their ID
+  */
+  DEFAULT_WARPED_MAP_LIST_OPTIONS;
+  warpedMapsById;
+  zIndices;
+  imagesById;
+  geoMaskRTree;
+  geoFullMaskRTree;
+  projectedGeoMaskRTree;
+  projectedGeoFullMaskRTree;
+  options;
+  #s;
+  /**
+  * Creates an instance of a WarpedMapList
+  *
+  * @constructor
+  * @param warpedMapFactory - Factory function for creating WarpedMap objects
+  * @param options - Options of this list, which will be set on newly added maps as their list options
+  */
+  constructor(e) {
+    super(), this.DEFAULT_WARPED_MAP_LIST_OPTIONS = {
+      createRTree: !0,
+      rtreeUpdatedOptions: [
+        "gcps",
+        "resourceMask",
+        "transformationType",
+        "internalProjection",
+        "projection"
+      ],
+      animatedOptions: [
+        "visible",
+        "applyMask",
+        "transformationType",
+        "internalProjection",
+        "distortionMeasure"
+      ],
+      projection: D,
+      warpedMapFactory: w()
+    }, this.warpedMapsById = /* @__PURE__ */ new Map(), this.zIndices = /* @__PURE__ */ new Map(), this.imagesById = /* @__PURE__ */ new Map(), this.#s = /* @__PURE__ */ new Map(), this.options = c(this.DEFAULT_WARPED_MAP_LIST_OPTIONS, e), this.options.createRTree && (this.geoMaskRTree = new l(), this.geoFullMaskRTree = new l(), this.projectedGeoMaskRTree = new l(), this.projectedGeoFullMaskRTree = new l());
+  }
+  /**
+  * Adds a georeferenced map to this list
+  *
+  * @param georeferencedMap - Georeferenced Map
+  * @param mapOptions - Map options
+  * @returns Map ID of the map that was added
+  */
+  addGeoreferencedMap(e, t) {
+    const s = I(e);
+    if (Array.isArray(s)) throw new Error("Expected a single georeferenced map, but got an array of georeferenced maps. Please use addGeoreferencedMaps to add multiple maps at once.");
+    const o = s, i = this.#a(o, t);
+    return this.dispatchEvent(new n(a.CHANGED)), i;
+  }
+  addGeoreferencedMaps(e, t) {
+    const s = I(e), o = Array.isArray(s) ? s : [s], i = this.#n(o, t);
+    return this.dispatchEvent(new n(a.CHANGED)), i;
+  }
+  /**
+  * Removes a georeferenced map from this list
+  *
+  * @param georeferencedMap
+  * @returns Map ID of the removed map, or an error
+  */
+  removeGeoreferencedMap(e) {
+    const t = I(e);
+    if (Array.isArray(t)) throw new Error("Expected a single georeferenced map, but got an array of georeferenced maps. Please use addGeoreferencedMaps to add multiple maps at once.");
+    const s = t, o = this.#p(s);
+    return this.dispatchEvent(new n(a.CHANGED)), o;
+  }
+  removeGeoreferencedMaps(e) {
+    const t = I(e), s = Array.isArray(t) ? t : [t], o = this.#c(s);
+    return this.dispatchEvent(new n(a.CHANGED)), o;
+  }
+  /**
+  * Removes a georeferenced map from the list by its ID
+  *
+  * @param mapId - Map ID
+  * @returns Map ID of the removed map, or an error
+  */
+  removeGeoreferencedMapById(e) {
+    const t = this.#d(e);
+    return this.dispatchEvent(new n(a.CHANGED)), t;
+  }
+  /**
+  * Parses an annotation and adds its georeferenced map to this list
+  *
+  * @param annotation - Annotation
+  * @param mapOptions - Map options
+  * @returns Map IDs of the maps that were added, or an error per map
+  */
+  addGeoreferenceAnnotation(e, t) {
+    const s = O(e), o = this.#n(s, t);
+    return this.dispatchEvent(new n(a.CHANGED)), o;
+  }
+  /**
+  * Parses an annotation and removes its georeferenced map from this list
+  *
+  * @param annotation
+  * @returns Map IDs of the maps that were removed, or an error per map
+  */
+  removeGeoreferenceAnnotation(e) {
+    const t = O(e), s = this.#c(t);
+    return this.dispatchEvent(new n(a.CHANGED)), s;
+  }
+  /**
+  * Update the maps in the list using the warpedMapFactory
+  *
+  * This function is used when creating a WarpedMapList from scratch
+  * and later including it in a specific renderer (e.g. a WebGL2Renderer)
+  * which has a specific warpedMapFactory (e.g. including the WebGL context)
+  * which could not be applied in the initial WarpedMapList.
+  * This function recreates the WarpedMaps using the factory.
+  *
+  * It is import to do this after the event listeners on the warpedmaplist
+  * are added to the renderer, so the WARPEDMAPADDED event is passed.
+  */
+  updateWarpedMapsUsingFactory() {
+    for (const e of this.warpedMapsById.values()) {
+      const t = this.options.warpedMapFactory(e.mapId, e.georeferencedMap, this.options, e.mapOptions);
+      this.warpedMapsById.set(e.mapId, t), this.#f(t), this.dispatchEvent(new n(a.WARPEDMAPADDED, { mapIds: [e.mapId] }));
+    }
+    return this;
+  }
+  /**
+  * Adds image informations, parses them to images and adds them to the image cache
+  *
+  * @param imageInfos - Image informations
+  * @returns Image IDs of the image informations that were added
+  */
+  addImageInfos(e) {
+    const t = [];
+    for (const s of e) {
+      const o = N.parse(s);
+      this.imagesById.set(o.uri, o), t.push(o.uri);
+    }
+    return this.dispatchEvent(new n(a.IMAGEINFOSADDED)), t;
+  }
+  /**
+  * Get mapIds for selected maps
+  *
+  * The options allow a.o. to:
+  * - filter for visible maps
+  * - filter for specific mapIds
+  * - filter for maps that overlap with a given point. Use geoPoint or projectedGeoPoint. Optionally specify projection for projectedGeoPoint. Optionally specify whether mask should be applied when computing overlap using applyMask.
+  * - filter for maps whose bbox overlap with the specified bbox. Use geoBbox or projectedGeoBbox. Optionally specify projection for projectedGeoBbox. Optionally specify whether mask should be applied when computing overlap using applyMask.
+  *
+  * @param partialOptions - Selection, mask and projection options, defaults to all visible maps, applied mask and current projection
+  * @returns mapIds
+  */
+  getMapIds(e) {
+    return this.getWarpedMaps(e).map((t) => t.mapId);
+  }
+  /**
+  * Get the WarpedMap instances for selected maps
+  *
+  * The options allow a.o. to:
+  * - filter for visible maps
+  * - filter for specific mapIds
+  * - filter for maps that overlap with a given point. Use geoPoint or projectedGeoPoint. Optionally specify projection for projectedGeoPoint. Optionally specify whether mask should be applied when computing overlap using applyMask.
+  * - filter for maps whose bbox overlap with the specified bbox. Use geoBbox or projectedGeoBbox. Optionally specify projection for projectedGeoBbox. Optionally specify whether mask should be applied when computing overlap using applyMask.
+  *
+  * @param partialOptions - Selection, mask and projection options, defaults to all visible maps, applied mask and current projection
+  * @returns WarpedMap instances
+  */
+  getWarpedMaps(e) {
+    const t = c(c(W, { projection: this.options.projection }), e);
+    let s;
+    if (t.mapIds === void 0) if (t.geoPoint) t.applyMask ? s = this.geoMaskRTree?.searchFromPoint(t.geoPoint) ?? this.#i(t.geoPoint, (i) => i.geoMaskBbox, (i) => i.geoMask) : s = this.geoFullMaskRTree?.searchFromPoint(t.geoPoint) ?? this.#i(t.geoPoint, (i) => i.geoFullMaskBbox, (i) => i.geoFullMask);
+    else if (t.geoBbox) t.applyMask ? s = this.geoMaskRTree?.searchFromBbox(t.geoBbox) ?? this.#o(t.geoBbox, (i) => i.geoMaskBbox) : s = this.geoFullMaskRTree?.searchFromBbox(t.geoBbox) ?? this.#o(t.geoBbox, (i) => i.geoFullMaskBbox);
+    else if (t.projectedGeoPoint) {
+      const i = m.projectPointIfNeeded(this.options.projection, t.projection, t.projectedGeoPoint);
+      t.applyMask ? s = this.projectedGeoMaskRTree?.searchFromPoint(i) ?? this.#i(i, (r) => r.projectedGeoMaskBbox, (r) => r.projectedGeoMask) : s = this.projectedGeoFullMaskRTree?.searchFromPoint(i) ?? this.#i(i, (r) => r.projectedGeoFullMaskBbox, (r) => r.projectedGeoFullMask);
+    } else if (t.projectedGeoBbox) {
+      const i = m.projectBboxIfNeeded(this.options.projection, t.projection, t.projectedGeoBbox);
+      t.applyMask ? s = this.projectedGeoMaskRTree?.searchFromBbox(i) ?? this.#o(i, (r) => r.projectedGeoMaskBbox) : s = this.projectedGeoFullMaskRTree?.searchFromBbox(i) ?? this.#o(i, (r) => r.projectedGeoFullMaskBbox);
+    } else s = Array.from(this.warpedMapsById.keys());
+    else s = t.mapIds;
+    const o = [];
+    if (s === void 0) return o;
+    for (const i of s) {
+      const r = this.warpedMapsById.get(i);
+      r && (!t.onlyVisible || r.options.visible) && o.push(r);
+    }
+    return o.sort((i, r) => this.orderMapIdsByZIndex(i.mapId, r.mapId)), o;
+  }
+  /**
+  * Get the WarpedMap instance for a map
+  *
+  * @param mapId - Map ID of the requested WarpedMap instance
+  * @returns WarpedMap instance, or undefined
+  */
+  getWarpedMap(e) {
+    return this.warpedMapsById.get(e);
+  }
+  /**
+  * Get the center of the bounding box of the maps in this list
+  *
+  * The result is returned in lon-lat `EPSG:4326` by default.
+  *
+  * @param options - Selection, mask and projection options, defaults to all visible maps, applied mask and current projection
+  * @returns The center of the bbox of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.
+  */
+  getMapsCenter(e) {
+    const t = this.getMapsBbox(e);
+    if (t) return A(t);
+  }
+  /**
+  * Get the bounding box of the maps in this list
+  *
+  * The result is returned in lon-lat `EPSG:4326` by default.
+  *
+  * @param options - Selection, mask and projection options, defaults to all visible maps, applied mask and current projection
+  * @returns The bbox of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.
+  */
+  getMapsBbox(e) {
+    const t = this.#M(e);
+    if (t.length !== 0)
+      return y(t);
+  }
+  /**
+  * Get the convex hull of the maps in this list
+  *
+  * The result is returned in lon-lat `EPSG:4326` by default.
+  *
+  * @param options - Selection, mask and projection options, defaults to all visible maps, applied mask and current projection
+  * @returns The convex hull of all selected maps, in the chosen projection, or undefined if there were no maps matching the selection.
+  */
+  getMapsConvexHull(e) {
+    return b(this.#M(e));
+  }
+  /**
+  * Get the z-index of a map
+  *
+  * @param mapId - Map ID for which to get the z-index
+  */
+  getMapZIndex(e) {
+    return this.zIndices.get(e);
+  }
+  /**
+  * Get the default options of the list
+  */
+  getDefaultOptions() {
+    return c(this.DEFAULT_WARPED_MAP_LIST_OPTIONS, f.getDefaultOptions());
+  }
+  /**
+  * Get the default options of a map
+  *
+  * These come from the default option settings for WebGL2WarpedMaps and the map's georeferenced map proporties
+  *
+  * @param mapId - Map ID for which the options apply
+  */
+  getMapDefaultOptions(e) {
+    return this.getWarpedMap(e)?.getDefaultAndGeoreferencedMapOptions();
+  }
+  /**
+  * Get the options of this list
+  */
+  getOptions() {
+    return this.getListOptions();
+  }
+  /**
+  * Get the options of this list
+  */
+  getListOptions() {
+    return this.options;
+  }
+  /**
+  * Get the map-specific options of a map
+  *
+  * @param mapId - Map ID for which the options apply
+  */
+  getMapMapOptions(e) {
+    return this.getWarpedMaps({ mapIds: [e] })[0]?.mapOptions;
+  }
+  /**
+  * Get the options of a map
+  *
+  * These options are the result of merging the default, georeferenced map,
+  * layer and map-specific options of that map.
+  *
+  * @param mapId - Map ID for which the options apply
+  */
+  getMapOptions(e) {
+    return this.getWarpedMaps({ mapIds: [e] })[0]?.options;
+  }
+  /**
+  * Set the options
+  *
+  * Note: Map-specific options set here will be passed to newly added maps.
+  *
+  * @param listOptions - List Options
+  */
+  setOptions(e) {
+    if (this.options = c(this.options, e), e && "projection" in e) for (const t of this.getWarpedMaps()) this.#r(t);
+  }
+  /**
+  * Set the options of this list
+  *
+  * Note: Map-specific options set here will be passed to newly added maps.
+  *
+  * @param listOptions - List Options
+  * @param animationOptions - Animation options
+  */
+  setListOptions(e, t) {
+    this.#e(void 0, e, t);
+  }
+  setMapsOptions(e, t, s) {
+    if (Array.isArray(e)) this.#e((o) => e.includes(o) ? t : void 0, void 0, s);
+    else {
+      if (e === void 0) throw new Error("mapsOptionsCallbackFn is undefined");
+      this.#e(e, void 0, t);
+    }
+  }
+  setMapsAndListOptions(e, t, s, o) {
+    if (Array.isArray(e)) this.#e((i) => e.includes(i) ? t : void 0, s, o);
+    else {
+      if (e === void 0) throw new Error("mapsOptionsCallbackFn is undefined");
+      this.#e(e, t, s);
+    }
+  }
+  /**
+  * Reset the list options
+  *
+  * Undefined option keys reset all options
+  *
+  * @param listOptionKeys - Keys of the list options to reset
+  * @param animationOptions - Animation options
+  */
+  resetListOptions(e, t) {
+    e === void 0 && (e = Object.keys(f.getDefaultOptions())), this.setListOptions(h(e), t);
+  }
+  resetMapsOptions(e, t, s) {
+    const o = f.getDefaultOptions(), i = Object.keys(o);
+    if (Array.isArray(e))
+      t === void 0 && (t = i), this.setMapsOptions(e, h(t), s);
+    else {
+      if (e === void 0) throw new Error("mapsOptionKeysCallbackFn is undefined");
+      const r = e;
+      this.setMapsOptions((d) => {
+        let p = r(d);
+        return p === void 0 && (p = i), h(p);
+      }, t);
+    }
+  }
+  resetMapsAndListOptions(e, t, s, o) {
+    const i = f.getDefaultOptions(), r = Object.keys(i);
+    if (Array.isArray(e))
+      t === void 0 && (t = r), s === void 0 && (s = r), this.setMapsAndListOptions(e, h(t), h(s), o);
+    else {
+      if (e === void 0) throw new Error("mapsOptionKeysCallbackFn is undefined");
+      const d = e;
+      t === void 0 && (t = r), this.setMapsAndListOptions((p) => {
+        let M = d(p);
+        return M === void 0 && (M = r), h(M);
+      }, h(t), s);
+    }
+  }
+  /**
+  * Change the z-index of the specified maps to bring them to front
+  *
+  * @param mapIds - Map IDs
+  */
+  bringMapsToFront(e) {
+    let t = this.warpedMapsById.size;
+    for (const s of e) this.zIndices.has(s) && (this.zIndices.set(s, t), t++);
+    this.#t(), this.dispatchEvent(new n(a.CHANGED));
+  }
+  /**
+  * Change the z-index of the specified maps to send them to back
+  *
+  * @param mapIds - Map IDs
+  */
+  sendMapsToBack(e) {
+    let t = -Array.from(e).length;
+    for (const s of e) this.zIndices.has(s) && (this.zIndices.set(s, t), t++);
+    this.#t(), this.dispatchEvent(new n(a.CHANGED));
+  }
+  /**
+  * Change the z-index of the specified maps to bring them forward
+  *
+  * @param mapIds - Map IDs
+  */
+  bringMapsForward(e) {
+    for (const [t, s] of this.zIndices.entries()) this.zIndices.set(t, s * 2);
+    for (const t of e) {
+      const s = this.zIndices.get(t);
+      s !== void 0 && this.zIndices.set(t, s + 3);
+    }
+    this.#t(), this.dispatchEvent(new n(a.CHANGED));
+  }
+  /**
+  * Change the zIndex of the specified maps to send them backward
+  *
+  * @param mapIds - Map IDs
+  */
+  sendMapsBackward(e) {
+    for (const [t, s] of this.zIndices.entries()) this.zIndices.set(t, s * 2);
+    for (const t of e) {
+      const s = this.zIndices.get(t);
+      s !== void 0 && this.zIndices.set(t, s - 3);
+    }
+    this.#t(), this.dispatchEvent(new n(a.CHANGED));
+  }
+  /**
+  * Order mapIds
+  *
+  * Use this as anonymous sort function in Array.prototype.sort()
+  */
+  orderMapIdsByZIndex(e, t) {
+    const s = this.getMapZIndex(e), o = this.getMapZIndex(t);
+    return s !== void 0 && o !== void 0 ? s - o : 0;
+  }
+  clear() {
+    this.warpedMapsById = /* @__PURE__ */ new Map(), this.zIndices = /* @__PURE__ */ new Map(), this.geoMaskRTree?.clear(), this.geoFullMaskRTree?.clear(), this.projectedGeoMaskRTree?.clear(), this.projectedGeoFullMaskRTree?.clear(), this.dispatchEvent(new n(a.CLEARED));
+  }
+  destroy() {
+    for (const e of this.getWarpedMaps())
+      this.#m(e), e.destroy();
+    this.clear();
+  }
+  #a(e, t) {
+    const s = this.#h(e), o = this.options.warpedMapFactory(s, e, this.options, t);
+    return this.warpedMapsById.set(s, o), this.zIndices.set(s, this.warpedMapsById.size - 1), this.#r(o), this.#f(o), this.dispatchEvent(new n(a.WARPEDMAPADDED, { mapIds: [s] })), s;
+  }
+  #n(e, t) {
+    const s = [];
+    for (const o of e) try {
+      const i = this.#a(o, t);
+      s.push(i);
+    } catch (i) {
+      s.push(k(i));
+    }
+    return s;
+  }
+  #p(e) {
+    const t = this.#h(e);
+    return this.#d(t);
+  }
+  #d(e) {
+    const t = this.warpedMapsById.get(e);
+    if (t)
+      this.warpedMapsById.delete(e), this.zIndices.delete(e), this.#l(t), this.dispatchEvent(new n(a.WARPEDMAPREMOVED, { mapIds: [e] })), this.#t(), this.dispatchEvent(new n(a.CHANGED)), t.destroy();
+    else throw new Error(`No map found with ID ${e}`);
+    return e;
+  }
+  #c(e) {
+    const t = [];
+    for (const s of e) try {
+      const o = this.#p(s);
+      t.push(o);
+    } catch (o) {
+      t.push(k(o));
+    }
+    return t;
+  }
+  #h(e) {
+    return e.id || L(e);
+  }
+  #M(e) {
+    const t = this.getWarpedMaps(e), s = [];
+    for (const i of t) s.push(...i.getGeoAppliedMask(e?.applyMask));
+    const o = e?.projection;
+    return o ? m.projectPointsIfNeeded(R, o, s) : s;
+  }
+  /**
+  * Internal set map options
+  */
+  #e(e, t, s) {
+    if (this.setOptions(t), this.warpedMapsById.size === 0) return;
+    const o = c(c(z, C), s);
+    (o.animate && o.stage == "animate" || !o.animate) && this.dispatchEvent(new n(a.PREPARECHANGE, { mapIds: this.getMapIds() }));
+    let i = [];
+    const r = [];
+    for (const d of this.getWarpedMaps()) {
+      let p = {};
+      const M = e ? e(d.mapId) : void 0;
+      o.animate && o.stage == "pre" && (p = d.setMapAndListOptions(M, t, v(o, { optionKeysToOmit: o.animatedOptions ?? this.options.animatedOptions }))), (o.animate && o.stage == "animate" || !o.animate) && (p = d.setMapAndListOptions(M, t, o));
+      const g = Object.keys(p);
+      g.length > 0 && (i.push(...g), r.push(d.mapId)), this.options.rtreeUpdatedOptions.some((T) => T in p) && this.#r(d);
+    }
+    i = Array.from(new Set(i)), (o.animate && o.stage == "pre" || !o.animate) && (i.length > 0 && this.dispatchEvent(new n(a.IMMEDIATECHANGE, {
+      mapIds: r,
+      optionKeys: i
+    })), o.animate && o.stage == "pre" && this.#e(e, t, v(o, { stage: "animate" }))), o.animate && o.stage == "animate" && i.length > 0 && this.dispatchEvent(new n(a.ANIMATEDCHANGE, {
+      mapIds: r,
+      optionKeys: i,
+      animationOptions: o
+    }));
+  }
+  #r(e) {
+    this.#l(e), this.geoMaskRTree && this.geoMaskRTree.addItem(e.mapId, [e.geoMask]), this.geoFullMaskRTree && this.geoFullMaskRTree.addItem(e.mapId, [e.geoFullMask]), this.projectedGeoMaskRTree && this.projectedGeoMaskRTree.addItem(e.mapId, [e.projectedGeoMask]), this.projectedGeoFullMaskRTree && this.projectedGeoFullMaskRTree.addItem(e.mapId, [e.projectedGeoFullMask]);
+  }
+  #o(e, t) {
+    return Array.from(this.warpedMapsById.values()).filter((s) => j(e, t(s))).map((s) => s.mapId);
+  }
+  #i(e, t, s) {
+    return Array.from(this.warpedMapsById.values()).filter((o) => F(e, t(o)) && x(e, B([s(o)]))).map((o) => o.mapId);
+  }
+  #l(e) {
+    this.geoMaskRTree && this.geoMaskRTree.removeItem(e.mapId), this.geoFullMaskRTree && this.geoFullMaskRTree.removeItem(e.mapId), this.projectedGeoMaskRTree && this.projectedGeoMaskRTree.removeItem(e.mapId), this.projectedGeoFullMaskRTree && this.projectedGeoFullMaskRTree.removeItem(e.mapId);
+  }
+  #t() {
+    const e = [...this.zIndices.entries()].sort((s, o) => s[1] - o[1]);
+    let t = 0;
+    for (const s of e) {
+      const o = s[0];
+      this.zIndices.set(o, t), t++;
+    }
+  }
+  #I(e) {
+    this.dispatchEvent(new n(a.IMAGELOADED, { mapIds: [e] }));
+  }
+  #f(e) {
+    const t = this.#I.bind(this, e.mapId);
+    this.#s.set(e.mapId, t), e.addEventListener(a.IMAGELOADED, t);
+  }
+  #m(e) {
+    const t = this.#s.get(e.mapId);
+    t && (e.removeEventListener(a.IMAGELOADED, t), this.#s.delete(e.mapId));
+  }
+  static projectPointIfNeeded(e, t, s) {
+    return G(e, t) ? s : E(e?.definition, t?.definition, s);
+  }
+  static projectPointsIfNeeded(e, t, s) {
+    return G(e, t) ? s : s.map((o) => E(e?.definition, t?.definition, o));
+  }
+  static projectBboxIfNeeded(e, t, s) {
+    return y(this.projectPointsIfNeeded(e, t, P(s)));
+  }
+};
+export {
+  z as DEFAULT_ANIMATION_OPTIONS,
+  pe as WarpedMapList
+};
+//# sourceMappingURL=index.es288.js.map