@nasa-terra/components 0.0.189 → 0.0.192

package/cdn/chunks/chunk.BD3FY2DX.js

@@ -0,0 +1,945 @@
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/utilities/harmony.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@turf/turf/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@turf/helpers/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+var earthRadius = 63710088e-1;
+var factors = {
+  centimeters: earthRadius * 100,
+  centimetres: earthRadius * 100,
+  degrees: 360 / (2 * Math.PI),
+  feet: earthRadius * 3.28084,
+  inches: earthRadius * 39.37,
+  kilometers: earthRadius / 1e3,
+  kilometres: earthRadius / 1e3,
+  meters: earthRadius,
+  metres: earthRadius,
+  miles: earthRadius / 1609.344,
+  millimeters: earthRadius * 1e3,
+  millimetres: earthRadius * 1e3,
+  nauticalmiles: earthRadius / 1852,
+  radians: 1,
+  yards: earthRadius * 1.0936
+};
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function lineString(coordinates, properties, options = {}) {
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be an array of two or more positions");
+  }
+  const geom = {
+    type: "LineString",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function isObject(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input);
+}
+
+// node_modules/@turf/invariant/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function getCoord(coord) {
+  if (!coord) {
+    throw new Error("coord is required");
+  }
+  if (!Array.isArray(coord)) {
+    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+      return [...coord.geometry.coordinates];
+    }
+    if (coord.type === "Point") {
+      return [...coord.coordinates];
+    }
+  }
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
+  }
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function getCoords(coords) {
+  if (Array.isArray(coords)) {
+    return coords;
+  }
+  if (coords.type === "Feature") {
+    if (coords.geometry !== null) {
+      return coords.geometry.coordinates;
+    }
+  } else {
+    if (coords.coordinates) {
+      return coords.coordinates;
+    }
+  }
+  throw new Error(
+    "coords must be GeoJSON Feature, Geometry Object or an Array"
+  );
+}
+function getType(geojson, _name) {
+  if (geojson.type === "FeatureCollection") {
+    return "FeatureCollection";
+  }
+  if (geojson.type === "GeometryCollection") {
+    return "GeometryCollection";
+  }
+  if (geojson.type === "Feature" && geojson.geometry !== null) {
+    return geojson.geometry.type;
+  }
+  return geojson.type;
+}
+
+// node_modules/@turf/meta/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function coordEach(geojson, callback, excludeWrapCoord) {
+  if (geojson === null)
+    return;
+  var j, k, l, geometry, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? (
+      // @ts-expect-error: Known type conflict
+      geojson.features[featureIndex].geometry
+    ) : isFeature ? (
+      // @ts-expect-error: Known type conflict
+      geojson.geometry
+    ) : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry === null)
+        continue;
+      coords = geometry.coordinates;
+      var geomType = geometry.type;
+      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (
+            // @ts-expect-error: Known type conflict
+            callback(
+              coords,
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false
+          )
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j = 0; j < coords.length; j++) {
+            if (
+              // @ts-expect-error: Known type conflict
+              callback(
+                coords[j],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false
+            )
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint")
+              multiFeatureIndex++;
+          }
+          if (geomType === "LineString")
+            multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j = 0; j < coords.length; j++) {
+            for (k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (
+                // @ts-expect-error: Known type conflict
+                callback(
+                  coords[j][k],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false
+              )
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString")
+              multiFeatureIndex++;
+            if (geomType === "Polygon")
+              geometryIndex++;
+          }
+          if (geomType === "Polygon")
+            multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (k = 0; k < coords[j].length; k++) {
+              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (
+                  // @ts-expect-error: Known type conflict
+                  callback(
+                    coords[j][k][l],
+                    coordIndex,
+                    featureIndex,
+                    multiFeatureIndex,
+                    geometryIndex
+                  ) === false
+                )
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j = 0; j < geometry.geometries.length; j++)
+            if (
+              // @ts-expect-error: Known type conflict
+              coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false
+            )
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+  }
+}
+function coordAll(geojson) {
+  var coords = [];
+  coordEach(geojson, function(coord) {
+    coords.push(coord);
+  });
+  return coords;
+}
+function geomEach(geojson, callback) {
+  var i, j, g, geometry, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (i = 0; i < stop; i++) {
+    geometryMaybeCollection = isFeatureCollection ? (
+      // @ts-expect-error: Known type conflict
+      geojson.features[i].geometry
+    ) : isFeature ? (
+      // @ts-expect-error: Known type conflict
+      geojson.geometry
+    ) : geojson;
+    featureProperties = isFeatureCollection ? (
+      // @ts-expect-error: Known type conflict
+      geojson.features[i].properties
+    ) : isFeature ? (
+      // @ts-expect-error: Known type conflict
+      geojson.properties
+    ) : {};
+    featureBBox = isFeatureCollection ? (
+      // @ts-expect-error: Known type conflict
+      geojson.features[i].bbox
+    ) : isFeature ? (
+      // @ts-expect-error: Known type conflict
+      geojson.bbox
+    ) : void 0;
+    featureId = isFeatureCollection ? (
+      // @ts-expect-error: Known type conflict
+      geojson.features[i].id
+    ) : isFeature ? (
+      // @ts-expect-error: Known type conflict
+      geojson.id
+    ) : void 0;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (g = 0; g < stopG; g++) {
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[g] : geometryMaybeCollection;
+      if (geometry === null) {
+        if (
+          // @ts-expect-error: Known type conflict
+          callback(
+            // @ts-expect-error: Known type conflict
+            null,
+            featureIndex,
+            featureProperties,
+            featureBBox,
+            featureId
+          ) === false
+        )
+          return false;
+        continue;
+      }
+      switch (geometry.type) {
+        case "Point":
+        case "LineString":
+        case "MultiPoint":
+        case "Polygon":
+        case "MultiLineString":
+        case "MultiPolygon": {
+          if (
+            // @ts-expect-error: Known type conflict
+            callback(
+              geometry,
+              featureIndex,
+              featureProperties,
+              featureBBox,
+              featureId
+            ) === false
+          )
+            return false;
+          break;
+        }
+        case "GeometryCollection": {
+          for (j = 0; j < geometry.geometries.length; j++) {
+            if (
+              // @ts-expect-error: Known type conflict
+              callback(
+                geometry.geometries[j],
+                featureIndex,
+                featureProperties,
+                featureBBox,
+                featureId
+              ) === false
+            )
+              return false;
+          }
+          break;
+        }
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+    featureIndex++;
+  }
+}
+
+// node_modules/@turf/boolean-point-on-line/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function booleanPointOnLine(pt, line, options = {}) {
+  const ptCoords = getCoord(pt);
+  const lineCoords = getCoords(line);
+  for (let i = 0; i < lineCoords.length - 1; i++) {
+    let ignoreBoundary = false;
+    if (options.ignoreEndVertices) {
+      if (i === 0) {
+        ignoreBoundary = "start";
+      }
+      if (i === lineCoords.length - 2) {
+        ignoreBoundary = "end";
+      }
+      if (i === 0 && i + 1 === lineCoords.length - 1) {
+        ignoreBoundary = "both";
+      }
+    }
+    if (isPointOnLineSegment(
+      lineCoords[i],
+      lineCoords[i + 1],
+      ptCoords,
+      ignoreBoundary,
+      typeof options.epsilon === "undefined" ? null : options.epsilon
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPointOnLineSegment(lineSegmentStart, lineSegmentEnd, pt, excludeBoundary, epsilon) {
+  const x = pt[0];
+  const y = pt[1];
+  const x1 = lineSegmentStart[0];
+  const y1 = lineSegmentStart[1];
+  const x2 = lineSegmentEnd[0];
+  const y2 = lineSegmentEnd[1];
+  const dxc = pt[0] - x1;
+  const dyc = pt[1] - y1;
+  const dxl = x2 - x1;
+  const dyl = y2 - y1;
+  const cross = dxc * dyl - dyc * dxl;
+  if (epsilon !== null) {
+    if (Math.abs(cross) > epsilon) {
+      return false;
+    }
+  } else if (cross !== 0) {
+    return false;
+  }
+  if (Math.abs(dxl) === Math.abs(dyl) && Math.abs(dxl) === 0) {
+    if (excludeBoundary) {
+      return false;
+    }
+    if (pt[0] === lineSegmentStart[0] && pt[1] === lineSegmentStart[1]) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  if (!excludeBoundary) {
+    if (Math.abs(dxl) >= Math.abs(dyl)) {
+      return dxl > 0 ? x1 <= x && x <= x2 : x2 <= x && x <= x1;
+    }
+    return dyl > 0 ? y1 <= y && y <= y2 : y2 <= y && y <= y1;
+  } else if (excludeBoundary === "start") {
+    if (Math.abs(dxl) >= Math.abs(dyl)) {
+      return dxl > 0 ? x1 < x && x <= x2 : x2 <= x && x < x1;
+    }
+    return dyl > 0 ? y1 < y && y <= y2 : y2 <= y && y < y1;
+  } else if (excludeBoundary === "end") {
+    if (Math.abs(dxl) >= Math.abs(dyl)) {
+      return dxl > 0 ? x1 <= x && x < x2 : x2 < x && x <= x1;
+    }
+    return dyl > 0 ? y1 <= y && y < y2 : y2 < y && y <= y1;
+  } else if (excludeBoundary === "both") {
+    if (Math.abs(dxl) >= Math.abs(dyl)) {
+      return dxl > 0 ? x1 < x && x < x2 : x2 < x && x < x1;
+    }
+    return dyl > 0 ? y1 < y && y < y2 : y2 < y && y < y1;
+  }
+  return false;
+}
+
+// node_modules/@turf/clean-coords/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function cleanCoords(geojson, options = {}) {
+  var mutate = typeof options === "object" ? options.mutate : options;
+  if (!geojson)
+    throw new Error("geojson is required");
+  var type = getType(geojson);
+  var newCoords = [];
+  switch (type) {
+    case "LineString":
+      newCoords = cleanLine(geojson, type);
+      break;
+    case "MultiLineString":
+    case "Polygon":
+      getCoords(geojson).forEach(function(line) {
+        newCoords.push(cleanLine(line, type));
+      });
+      break;
+    case "MultiPolygon":
+      getCoords(geojson).forEach(function(polygons) {
+        var polyPoints = [];
+        polygons.forEach(function(ring) {
+          polyPoints.push(cleanLine(ring, type));
+        });
+        newCoords.push(polyPoints);
+      });
+      break;
+    case "Point":
+      return geojson;
+    case "MultiPoint":
+      var existing = {};
+      getCoords(geojson).forEach(function(coord) {
+        var key = coord.join("-");
+        if (!Object.prototype.hasOwnProperty.call(existing, key)) {
+          newCoords.push(coord);
+          existing[key] = true;
+        }
+      });
+      break;
+    default:
+      throw new Error(type + " geometry not supported");
+  }
+  if (geojson.coordinates) {
+    if (mutate === true) {
+      geojson.coordinates = newCoords;
+      return geojson;
+    }
+    return { type, coordinates: newCoords };
+  } else {
+    if (mutate === true) {
+      geojson.geometry.coordinates = newCoords;
+      return geojson;
+    }
+    return feature({ type, coordinates: newCoords }, geojson.properties, {
+      bbox: geojson.bbox,
+      id: geojson.id
+    });
+  }
+}
+function cleanLine(line, type) {
+  const points = getCoords(line);
+  if (points.length === 2 && !equals(points[0], points[1]))
+    return points;
+  const newPoints = [];
+  let a = 0, b2 = 1, c = 2;
+  newPoints.push(points[a]);
+  while (c < points.length) {
+    if (booleanPointOnLine(points[b2], lineString([points[a], points[c]]))) {
+      b2 = c;
+    } else {
+      newPoints.push(points[b2]);
+      a = b2;
+      b2++;
+      c = b2;
+    }
+    c++;
+  }
+  newPoints.push(points[b2]);
+  if (type === "Polygon" || type === "MultiPolygon") {
+    if (booleanPointOnLine(
+      newPoints[0],
+      lineString([newPoints[1], newPoints[newPoints.length - 2]])
+    )) {
+      newPoints.shift();
+      newPoints.pop();
+      newPoints.push(newPoints[0]);
+    }
+    if (newPoints.length < 4) {
+      throw new Error("invalid polygon, fewer than 4 points");
+    }
+    if (!equals(newPoints[0], newPoints[newPoints.length - 1])) {
+      throw new Error("invalid polygon, first and last points not equal");
+    }
+  }
+  return newPoints;
+}
+function equals(pt1, pt2) {
+  return pt1[0] === pt2[0] && pt1[1] === pt2[1];
+}
+
+// node_modules/@turf/clone/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function clone(geojson) {
+  if (!geojson) {
+    throw new Error("geojson is required");
+  }
+  switch (geojson.type) {
+    case "Feature":
+      return cloneFeature(geojson);
+    case "FeatureCollection":
+      return cloneFeatureCollection(geojson);
+    case "Point":
+    case "LineString":
+    case "Polygon":
+    case "MultiPoint":
+    case "MultiLineString":
+    case "MultiPolygon":
+    case "GeometryCollection":
+      return cloneGeometry(geojson);
+    default:
+      throw new Error("unknown GeoJSON type");
+  }
+}
+function cloneFeature(geojson) {
+  const cloned = { type: "Feature" };
+  Object.keys(geojson).forEach((key) => {
+    switch (key) {
+      case "type":
+      case "properties":
+      case "geometry":
+        return;
+      default:
+        cloned[key] = geojson[key];
+    }
+  });
+  cloned.properties = cloneProperties(geojson.properties);
+  if (geojson.geometry == null) {
+    cloned.geometry = null;
+  } else {
+    cloned.geometry = cloneGeometry(geojson.geometry);
+  }
+  return cloned;
+}
+function cloneProperties(properties) {
+  const cloned = {};
+  if (!properties) {
+    return cloned;
+  }
+  Object.keys(properties).forEach((key) => {
+    const value = properties[key];
+    if (typeof value === "object") {
+      if (value === null) {
+        cloned[key] = null;
+      } else if (Array.isArray(value)) {
+        cloned[key] = value.map((item) => {
+          return item;
+        });
+      } else {
+        cloned[key] = cloneProperties(value);
+      }
+    } else {
+      cloned[key] = value;
+    }
+  });
+  return cloned;
+}
+function cloneFeatureCollection(geojson) {
+  const cloned = { type: "FeatureCollection" };
+  Object.keys(geojson).forEach((key) => {
+    switch (key) {
+      case "type":
+      case "features":
+        return;
+      default:
+        cloned[key] = geojson[key];
+    }
+  });
+  cloned.features = geojson.features.map((feature2) => {
+    return cloneFeature(feature2);
+  });
+  return cloned;
+}
+function cloneGeometry(geometry) {
+  const geom = { type: geometry.type };
+  if (geometry.bbox) {
+    geom.bbox = geometry.bbox;
+  }
+  if (geometry.type === "GeometryCollection") {
+    geom.geometries = geometry.geometries.map((g) => {
+      return cloneGeometry(g);
+    });
+    return geom;
+  }
+  geom.coordinates = deepSlice(geometry.coordinates);
+  return geom;
+}
+function deepSlice(coords) {
+  const cloned = coords;
+  if (typeof cloned[0] !== "object") {
+    return cloned.slice();
+  }
+  return cloned.map((coord) => {
+    return deepSlice(coord);
+  });
+}
+
+// node_modules/@turf/simplify/dist/esm/index.js
+init_dirname();
+init_buffer();
+init_process();
+function getSqDist(p1, p2) {
+  var dx = p1[0] - p2[0], dy = p1[1] - p2[1];
+  return dx * dx + dy * dy;
+}
+function getSqSegDist(p, p1, p2) {
+  var x = p1[0], y = p1[1], dx = p2[0] - x, dy = p2[1] - y;
+  if (dx !== 0 || dy !== 0) {
+    var t = ((p[0] - x) * dx + (p[1] - y) * dy) / (dx * dx + dy * dy);
+    if (t > 1) {
+      x = p2[0];
+      y = p2[1];
+    } else if (t > 0) {
+      x += dx * t;
+      y += dy * t;
+    }
+  }
+  dx = p[0] - x;
+  dy = p[1] - y;
+  return dx * dx + dy * dy;
+}
+function simplifyRadialDist(points, sqTolerance) {
+  var prevPoint = points[0], newPoints = [prevPoint], point;
+  for (var i = 1, len = points.length; i < len; i++) {
+    point = points[i];
+    if (getSqDist(point, prevPoint) > sqTolerance) {
+      newPoints.push(point);
+      prevPoint = point;
+    }
+  }
+  if (prevPoint !== point)
+    newPoints.push(point);
+  return newPoints;
+}
+function simplifyDPStep(points, first, last, sqTolerance, simplified) {
+  var maxSqDist = sqTolerance, index;
+  for (var i = first + 1; i < last; i++) {
+    var sqDist = getSqSegDist(points[i], points[first], points[last]);
+    if (sqDist > maxSqDist) {
+      index = i;
+      maxSqDist = sqDist;
+    }
+  }
+  if (maxSqDist > sqTolerance) {
+    if (index - first > 1)
+      simplifyDPStep(points, first, index, sqTolerance, simplified);
+    simplified.push(points[index]);
+    if (last - index > 1)
+      simplifyDPStep(points, index, last, sqTolerance, simplified);
+  }
+}
+function simplifyDouglasPeucker(points, sqTolerance) {
+  var last = points.length - 1;
+  var simplified = [points[0]];
+  simplifyDPStep(points, 0, last, sqTolerance, simplified);
+  simplified.push(points[last]);
+  return simplified;
+}
+function simplify(points, tolerance, highestQuality) {
+  if (points.length <= 2)
+    return points;
+  var sqTolerance = tolerance !== void 0 ? tolerance * tolerance : 1;
+  points = highestQuality ? points : simplifyRadialDist(points, sqTolerance);
+  points = simplifyDouglasPeucker(points, sqTolerance);
+  return points;
+}
+function simplify2(geojson, options = {}) {
+  var _a, _b, _c;
+  options = options != null ? options : {};
+  if (!isObject(options))
+    throw new Error("options is invalid");
+  const tolerance = (_a = options.tolerance) != null ? _a : 1;
+  const highQuality = (_b = options.highQuality) != null ? _b : false;
+  const mutate = (_c = options.mutate) != null ? _c : false;
+  if (!geojson)
+    throw new Error("geojson is required");
+  if (tolerance && tolerance < 0)
+    throw new Error("invalid tolerance");
+  if (mutate !== true)
+    geojson = clone(geojson);
+  geomEach(geojson, function(geom) {
+    simplifyGeom(geom, tolerance, highQuality);
+  });
+  return geojson;
+}
+function simplifyGeom(geometry, tolerance, highQuality) {
+  const type = geometry.type;
+  if (type === "Point" || type === "MultiPoint")
+    return geometry;
+  cleanCoords(geometry, { mutate: true });
+  if (type !== "GeometryCollection") {
+    switch (type) {
+      case "LineString":
+        geometry.coordinates = simplify(
+          geometry.coordinates,
+          tolerance,
+          highQuality
+        );
+        break;
+      case "MultiLineString":
+        geometry.coordinates = geometry.coordinates.map(
+          (lines) => simplify(lines, tolerance, highQuality)
+        );
+        break;
+      case "Polygon":
+        geometry.coordinates = simplifyPolygon(
+          geometry.coordinates,
+          tolerance,
+          highQuality
+        );
+        break;
+      case "MultiPolygon":
+        geometry.coordinates = geometry.coordinates.map(
+          (rings) => simplifyPolygon(rings, tolerance, highQuality)
+        );
+    }
+  }
+  return geometry;
+}
+function simplifyPolygon(coordinates, tolerance, highQuality) {
+  return coordinates.map(function(ring) {
+    if (ring.length < 4) {
+      throw new Error("invalid polygon");
+    }
+    let ringTolerance = tolerance;
+    let simpleRing = simplify(ring, ringTolerance, highQuality);
+    while (!checkValidity(simpleRing) && ringTolerance >= Number.EPSILON) {
+      ringTolerance -= ringTolerance * 0.01;
+      simpleRing = simplify(ring, ringTolerance, highQuality);
+    }
+    if (!checkValidity(simpleRing)) {
+      return ring;
+    }
+    if (simpleRing[simpleRing.length - 1][0] !== simpleRing[0][0] || simpleRing[simpleRing.length - 1][1] !== simpleRing[0][1]) {
+      simpleRing.push(simpleRing[0]);
+    }
+    return simpleRing;
+  });
+}
+function checkValidity(ring) {
+  if (ring.length < 3)
+    return false;
+  return !(ring.length === 3 && ring[2][0] === ring[0][0] && ring[2][1] === ring[0][1]);
+}
+
+// src/utilities/harmony.ts
+function isCancellationError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error.name === "AbortError") {
+    return true;
+  }
+  const errorMessage = error.message.toLowerCase();
+  if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorMessage.includes("aborted")) {
+    return true;
+  }
+  const { cause } = error;
+  if (cause) {
+    let causeMessage;
+    if (cause instanceof Error) {
+      causeMessage = cause.message.toLowerCase();
+      if (cause.name === "AbortError") {
+        return true;
+      }
+    } else {
+      causeMessage = String(cause).toLowerCase();
+    }
+    if (causeMessage.includes("cancelled") || causeMessage.includes("canceled") || causeMessage.includes("aborted")) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractHarmonyError(error, jobErrors) {
+  let errorCode = "400";
+  let errorMessage = "An error occurred";
+  let errorContext;
+  if (error instanceof Error) {
+    errorMessage = error.message;
+    const { cause } = error;
+    let underlyingMessage;
+    if (cause) {
+      if (cause instanceof Error) {
+        underlyingMessage = cause.message;
+      } else {
+        underlyingMessage = String(cause);
+      }
+    }
+    if (underlyingMessage) {
+      const underlyingMessageLower = underlyingMessage.toLowerCase();
+      if (underlyingMessageLower.includes("cancelled") || underlyingMessageLower.includes("canceled") || underlyingMessageLower.includes("aborted")) {
+        errorMessage = underlyingMessage;
+      }
+    }
+    const errorMatch = errorMessage.match(
+      /Failed to (?:create|fetch|cancel) subset job:\s*(.+)/i
+    );
+    if (errorMatch) {
+      errorContext = errorMatch[1];
+      errorMessage = errorMatch[1];
+    } else {
+      errorContext = errorMessage;
+    }
+    const statusMatch = errorMessage.match(/status[:\s]+(\d+)/i);
+    if (statusMatch) {
+      errorCode = statusMatch[1];
+    }
+  } else {
+    errorMessage = String(error);
+    errorContext = errorMessage;
+  }
+  if (jobErrors && jobErrors.length > 0) {
+    errorContext = jobErrors[0].message || errorContext;
+    errorMessage = jobErrors[0].message || errorMessage;
+  }
+  const isCancellation = isCancellationError(error);
+  return {
+    status: parseInt(errorCode, 10) || 500,
+    code: errorCode,
+    message: errorMessage,
+    context: errorContext,
+    isCancellation
+  };
+}
+function formatHarmonyErrorMessage(error) {
+  const errorCode = error.code;
+  if (errorCode === "429") {
+    return b`
+            You have reached your quota for the month. Please reach out using the
+            "Help" menu above for help
+        `;
+  }
+  if (errorCode === "400") {
+    const errorText2 = error.context || error.message || "Bad or missing input";
+    return b`${errorText2}`;
+  }
+  const errorText = error.context || error.message;
+  if (errorText && errorText !== "An error occurred") {
+    return b`${errorText}`;
+  }
+  return b`
+        There was a problem making this request. For help, please
+        <a
+            href="https://forum.earthdata.nasa.gov/viewforum.php?f=7&DAAC=3"
+            target="_blank"
+            rel="noopener noreferrer"
+            >contact us using the Earthdata Forum</a
+        >
+    `;
+}
+function simplifyToPointLimit(geoJson, maxPoints) {
+  const asAllGeoJson = geoJson;
+  if (coordAll(asAllGeoJson).length <= maxPoints) {
+    return geoJson;
+  }
+  let high = 1e-3;
+  while (coordAll(
+    simplify2(asAllGeoJson, {
+      tolerance: high,
+      highQuality: false,
+      mutate: false
+    })
+  ).length > maxPoints) {
+    high *= 2;
+    if (high >= 1)
+      break;
+  }
+  let low = 0;
+  let best = simplify2(asAllGeoJson, {
+    tolerance: high,
+    highQuality: false,
+    mutate: false
+  });
+  for (let i = 0; i < 24; i++) {
+    const mid = (low + high) / 2;
+    const candidate = simplify2(asAllGeoJson, {
+      tolerance: mid,
+      highQuality: false,
+      mutate: false
+    });
+    if (coordAll(candidate).length <= maxPoints) {
+      best = candidate;
+      high = mid;
+    } else {
+      low = mid;
+    }
+  }
+  console.log(
+    `Simplified GeoJSON from ${coordAll(asAllGeoJson).length} to ${coordAll(best).length} vertices`
+  );
+  return best;
+}
+
+export {
+  isCancellationError,
+  extractHarmonyError,
+  formatHarmonyErrorMessage,
+  simplifyToPointLimit
+};