@loaders.gl/potree 4.4.0-alpha.13 → 4.4.0-alpha.14

package/dist/dist.dev.js

@@ -19145,6 +19145,8 @@ var __exports__ = (() => {
     start2 += 48;
     o.maxs = [bounds[0], bounds[2], bounds[4]];
     o.mins = [bounds[1], bounds[3], bounds[5]];
+    const colorPointFormats = /* @__PURE__ */ new Set([2, 3]);
+    o.hasColor = colorPointFormats.has(o.pointsFormatId & 63);
     return o;
   }
   var LASLoader = class {
@@ -19282,11 +19284,10 @@ var __exports__ = (() => {
     }
     /**
      * @param count
-     * @param offset
      * @param skip
      * @returns Data
      */
-    readData(count, offset, skip) {
+    readData(count, skip) {
       if (!this.instance) {
         throw new Error("You need to open the file before trying to read stuff");
       }
@@ -19430,12 +19431,11 @@ var __exports__ = (() => {
     }
     /**
      * @param count
-     * @param start
      * @param skip
      * @returns Data
      */
-    readData(count, start2, skip) {
-      return this.loader.readData(count, start2, skip);
+    readData(count, skip) {
+      return this.loader.readData(count, skip);
     }
     /**
      * Closes the file
@@ -19808,6 +19808,328 @@ var __exports__ = (() => {
     return self2;
   }
 
+  // ../../node_modules/wkt-parser/PROJJSONBuilderBase.js
+  var PROJJSONBuilderBase = class {
+    static getId(node) {
+      const idNode = node.find((child) => Array.isArray(child) && child[0] === "ID");
+      if (idNode && idNode.length >= 3) {
+        return {
+          authority: idNode[1],
+          code: parseInt(idNode[2], 10)
+        };
+      }
+      return null;
+    }
+    static convertUnit(node, type = "unit") {
+      if (!node || node.length < 3) {
+        return { type, name: "unknown", conversion_factor: null };
+      }
+      const name = node[1];
+      const conversionFactor = parseFloat(node[2]) || null;
+      const idNode = node.find((child) => Array.isArray(child) && child[0] === "ID");
+      const id = idNode ? {
+        authority: idNode[1],
+        code: parseInt(idNode[2], 10)
+      } : null;
+      return {
+        type,
+        name,
+        conversion_factor: conversionFactor,
+        id
+      };
+    }
+    static convertAxis(node) {
+      const name = node[1] || "Unknown";
+      let direction;
+      const abbreviationMatch = name.match(/^\((.)\)$/);
+      if (abbreviationMatch) {
+        const abbreviation = abbreviationMatch[1].toUpperCase();
+        if (abbreviation === "E")
+          direction = "east";
+        else if (abbreviation === "N")
+          direction = "north";
+        else if (abbreviation === "U")
+          direction = "up";
+        else
+          throw new Error(`Unknown axis abbreviation: ${abbreviation}`);
+      } else {
+        direction = node[2] ? node[2].toLowerCase() : "unknown";
+      }
+      const orderNode = node.find((child) => Array.isArray(child) && child[0] === "ORDER");
+      const order = orderNode ? parseInt(orderNode[1], 10) : null;
+      const unitNode = node.find(
+        (child) => Array.isArray(child) && (child[0] === "LENGTHUNIT" || child[0] === "ANGLEUNIT" || child[0] === "SCALEUNIT")
+      );
+      const unit = this.convertUnit(unitNode);
+      return {
+        name,
+        direction,
+        // Use the valid PROJJSON direction value
+        unit,
+        order
+      };
+    }
+    static extractAxes(node) {
+      return node.filter((child) => Array.isArray(child) && child[0] === "AXIS").map((axis) => this.convertAxis(axis)).sort((a, b) => (a.order || 0) - (b.order || 0));
+    }
+    static convert(node, result = {}) {
+      switch (node[0]) {
+        case "PROJCRS":
+          result.type = "ProjectedCRS";
+          result.name = node[1];
+          result.base_crs = node.find((child) => Array.isArray(child) && child[0] === "BASEGEOGCRS") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "BASEGEOGCRS")) : null;
+          result.conversion = node.find((child) => Array.isArray(child) && child[0] === "CONVERSION") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "CONVERSION")) : null;
+          const csNode = node.find((child) => Array.isArray(child) && child[0] === "CS");
+          if (csNode) {
+            result.coordinate_system = {
+              type: csNode[1],
+              axis: this.extractAxes(node)
+            };
+          }
+          const lengthUnitNode = node.find((child) => Array.isArray(child) && child[0] === "LENGTHUNIT");
+          if (lengthUnitNode) {
+            const unit2 = this.convertUnit(lengthUnitNode);
+            result.coordinate_system.unit = unit2;
+          }
+          result.id = this.getId(node);
+          break;
+        case "BASEGEOGCRS":
+        case "GEOGCRS":
+          result.type = "GeographicCRS";
+          result.name = node[1];
+          const datumOrEnsembleNode = node.find(
+            (child) => Array.isArray(child) && (child[0] === "DATUM" || child[0] === "ENSEMBLE")
+          );
+          if (datumOrEnsembleNode) {
+            const datumOrEnsemble = this.convert(datumOrEnsembleNode);
+            if (datumOrEnsembleNode[0] === "ENSEMBLE") {
+              result.datum_ensemble = datumOrEnsemble;
+            } else {
+              result.datum = datumOrEnsemble;
+            }
+            const primem = node.find((child) => Array.isArray(child) && child[0] === "PRIMEM");
+            if (primem && primem[1] !== "Greenwich") {
+              datumOrEnsemble.prime_meridian = {
+                name: primem[1],
+                longitude: parseFloat(primem[2])
+              };
+            }
+          }
+          result.coordinate_system = {
+            type: "ellipsoidal",
+            axis: this.extractAxes(node)
+          };
+          result.id = this.getId(node);
+          break;
+        case "DATUM":
+          result.type = "GeodeticReferenceFrame";
+          result.name = node[1];
+          result.ellipsoid = node.find((child) => Array.isArray(child) && child[0] === "ELLIPSOID") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "ELLIPSOID")) : null;
+          break;
+        case "ENSEMBLE":
+          result.type = "DatumEnsemble";
+          result.name = node[1];
+          result.members = node.filter((child) => Array.isArray(child) && child[0] === "MEMBER").map((member) => ({
+            type: "DatumEnsembleMember",
+            name: member[1],
+            id: this.getId(member)
+            // Extract ID as { authority, code }
+          }));
+          const accuracyNode = node.find((child) => Array.isArray(child) && child[0] === "ENSEMBLEACCURACY");
+          if (accuracyNode) {
+            result.accuracy = parseFloat(accuracyNode[1]);
+          }
+          const ellipsoidNode = node.find((child) => Array.isArray(child) && child[0] === "ELLIPSOID");
+          if (ellipsoidNode) {
+            result.ellipsoid = this.convert(ellipsoidNode);
+          }
+          result.id = this.getId(node);
+          break;
+        case "ELLIPSOID":
+          result.type = "Ellipsoid";
+          result.name = node[1];
+          result.semi_major_axis = parseFloat(node[2]);
+          result.inverse_flattening = parseFloat(node[3]);
+          const units = node.find((child) => Array.isArray(child) && child[0] === "LENGTHUNIT") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "LENGTHUNIT"), result) : null;
+          break;
+        case "CONVERSION":
+          result.type = "Conversion";
+          result.name = node[1];
+          result.method = node.find((child) => Array.isArray(child) && child[0] === "METHOD") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "METHOD")) : null;
+          result.parameters = node.filter((child) => Array.isArray(child) && child[0] === "PARAMETER").map((param) => this.convert(param));
+          break;
+        case "METHOD":
+          result.type = "Method";
+          result.name = node[1];
+          result.id = this.getId(node);
+          break;
+        case "PARAMETER":
+          result.type = "Parameter";
+          result.name = node[1];
+          result.value = parseFloat(node[2]);
+          result.unit = this.convertUnit(
+            node.find(
+              (child) => Array.isArray(child) && (child[0] === "LENGTHUNIT" || child[0] === "ANGLEUNIT" || child[0] === "SCALEUNIT")
+            )
+          );
+          result.id = this.getId(node);
+          break;
+        case "BOUNDCRS":
+          result.type = "BoundCRS";
+          const sourceCrsNode = node.find((child) => Array.isArray(child) && child[0] === "SOURCECRS");
+          if (sourceCrsNode) {
+            const sourceCrsContent = sourceCrsNode.find((child) => Array.isArray(child));
+            result.source_crs = sourceCrsContent ? this.convert(sourceCrsContent) : null;
+          }
+          const targetCrsNode = node.find((child) => Array.isArray(child) && child[0] === "TARGETCRS");
+          if (targetCrsNode) {
+            const targetCrsContent = targetCrsNode.find((child) => Array.isArray(child));
+            result.target_crs = targetCrsContent ? this.convert(targetCrsContent) : null;
+          }
+          const transformationNode = node.find((child) => Array.isArray(child) && child[0] === "ABRIDGEDTRANSFORMATION");
+          if (transformationNode) {
+            result.transformation = this.convert(transformationNode);
+          } else {
+            result.transformation = null;
+          }
+          break;
+        case "ABRIDGEDTRANSFORMATION":
+          result.type = "Transformation";
+          result.name = node[1];
+          result.method = node.find((child) => Array.isArray(child) && child[0] === "METHOD") ? this.convert(node.find((child) => Array.isArray(child) && child[0] === "METHOD")) : null;
+          result.parameters = node.filter((child) => Array.isArray(child) && (child[0] === "PARAMETER" || child[0] === "PARAMETERFILE")).map((param) => {
+            if (param[0] === "PARAMETER") {
+              return this.convert(param);
+            } else if (param[0] === "PARAMETERFILE") {
+              return {
+                name: param[1],
+                value: param[2],
+                id: {
+                  "authority": "EPSG",
+                  "code": 8656
+                }
+              };
+            }
+          });
+          if (result.parameters.length === 7) {
+            const scaleDifference = result.parameters[6];
+            if (scaleDifference.name === "Scale difference") {
+              scaleDifference.value = Math.round((scaleDifference.value - 1) * 1e12) / 1e6;
+            }
+          }
+          result.id = this.getId(node);
+          break;
+        case "AXIS":
+          if (!result.coordinate_system) {
+            result.coordinate_system = { type: "unspecified", axis: [] };
+          }
+          result.coordinate_system.axis.push(this.convertAxis(node));
+          break;
+        case "LENGTHUNIT":
+          const unit = this.convertUnit(node, "LinearUnit");
+          if (result.coordinate_system && result.coordinate_system.axis) {
+            result.coordinate_system.axis.forEach((axis) => {
+              if (!axis.unit) {
+                axis.unit = unit;
+              }
+            });
+          }
+          if (unit.conversion_factor && unit.conversion_factor !== 1) {
+            if (result.semi_major_axis) {
+              result.semi_major_axis = {
+                value: result.semi_major_axis,
+                unit
+              };
+            }
+          }
+          break;
+        default:
+          result.keyword = node[0];
+          break;
+      }
+      return result;
+    }
+  };
+  var PROJJSONBuilderBase_default = PROJJSONBuilderBase;
+
+  // ../../node_modules/wkt-parser/PROJJSONBuilder2015.js
+  var PROJJSONBuilder2015 = class extends PROJJSONBuilderBase_default {
+    static convert(node, result = {}) {
+      super.convert(node, result);
+      if (result.coordinate_system && result.coordinate_system.subtype === "Cartesian") {
+        delete result.coordinate_system;
+      }
+      if (result.usage) {
+        delete result.usage;
+      }
+      return result;
+    }
+  };
+  var PROJJSONBuilder2015_default = PROJJSONBuilder2015;
+
+  // ../../node_modules/wkt-parser/PROJJSONBuilder2019.js
+  var PROJJSONBuilder2019 = class extends PROJJSONBuilderBase_default {
+    static convert(node, result = {}) {
+      super.convert(node, result);
+      const csNode = node.find((child) => Array.isArray(child) && child[0] === "CS");
+      if (csNode) {
+        result.coordinate_system = {
+          subtype: csNode[1],
+          axis: this.extractAxes(node)
+        };
+      }
+      const usageNode = node.find((child) => Array.isArray(child) && child[0] === "USAGE");
+      if (usageNode) {
+        const scope = usageNode.find((child) => Array.isArray(child) && child[0] === "SCOPE");
+        const area = usageNode.find((child) => Array.isArray(child) && child[0] === "AREA");
+        const bbox = usageNode.find((child) => Array.isArray(child) && child[0] === "BBOX");
+        result.usage = {};
+        if (scope) {
+          result.usage.scope = scope[1];
+        }
+        if (area) {
+          result.usage.area = area[1];
+        }
+        if (bbox) {
+          result.usage.bbox = bbox.slice(1);
+        }
+      }
+      return result;
+    }
+  };
+  var PROJJSONBuilder2019_default = PROJJSONBuilder2019;
+
+  // ../../node_modules/wkt-parser/buildPROJJSON.js
+  function detectWKT2Version(root) {
+    if (root.find((child) => Array.isArray(child) && child[0] === "USAGE")) {
+      return "2019";
+    }
+    if (root.find((child) => Array.isArray(child) && child[0] === "CS")) {
+      return "2015";
+    }
+    if (root[0] === "BOUNDCRS" || root[0] === "PROJCRS" || root[0] === "GEOGCRS") {
+      return "2015";
+    }
+    return "2015";
+  }
+  function buildPROJJSON(root) {
+    const version = detectWKT2Version(root);
+    const builder = version === "2019" ? PROJJSONBuilder2019_default : PROJJSONBuilder2015_default;
+    return builder.convert(root);
+  }
+
+  // ../../node_modules/wkt-parser/detectWKTVersion.js
+  function detectWKTVersion(wkt) {
+    const normalizedWKT = wkt.toUpperCase();
+    if (normalizedWKT.includes("PROJCRS") || normalizedWKT.includes("GEOGCRS") || normalizedWKT.includes("BOUNDCRS") || normalizedWKT.includes("VERTCRS") || normalizedWKT.includes("LENGTHUNIT") || normalizedWKT.includes("ANGLEUNIT") || normalizedWKT.includes("SCALEUNIT")) {
+      return "WKT2";
+    }
+    if (normalizedWKT.includes("PROJCS") || normalizedWKT.includes("GEOGCS") || normalizedWKT.includes("LOCAL_CS") || normalizedWKT.includes("VERT_CS") || normalizedWKT.includes("UNIT")) {
+      return "WKT1";
+    }
+    return "WKT1";
+  }
+
   // ../../node_modules/wkt-parser/parser.js
   var parser_default = parseString;
   var NEUTRAL = 1;
@@ -20050,6 +20372,19 @@ var __exports__ = (() => {
           sExpr(v[3], obj[key]);
         }
         return;
+      case "EDATUM":
+      case "ENGINEERINGDATUM":
+      case "LOCAL_DATUM":
+      case "DATUM":
+      case "VERT_CS":
+      case "VERTCRS":
+      case "VERTICALCRS":
+        v[0] = ["name", v[0]];
+        mapit(obj, key, v);
+        return;
+      case "COMPD_CS":
+      case "COMPOUNDCRS":
+      case "FITTED_CS":
       case "PROJECTEDCRS":
       case "PROJCRS":
       case "GEOGCS":
@@ -20059,20 +20394,11 @@ var __exports__ = (() => {
       case "GEODCRS":
       case "GEODETICCRS":
       case "GEODETICDATUM":
-      case "EDATUM":
-      case "ENGINEERINGDATUM":
-      case "VERT_CS":
-      case "VERTCRS":
-      case "VERTICALCRS":
-      case "COMPD_CS":
-      case "COMPOUNDCRS":
-      case "ENGINEERINGCRS":
       case "ENGCRS":
-      case "FITTED_CS":
-      case "LOCAL_DATUM":
-      case "DATUM":
+      case "ENGINEERINGCRS":
         v[0] = ["name", v[0]];
         mapit(obj, key, v);
+        obj[key].type = key;
         return;
       default:
         i = -1;
@@ -20085,8 +20411,276 @@ var __exports__ = (() => {
     }
   }
 
-  // ../../node_modules/wkt-parser/index.js
+  // ../../node_modules/wkt-parser/util.js
   var D2R2 = 0.017453292519943295;
+  function d2r(input) {
+    return input * D2R2;
+  }
+  function applyProjectionDefaults(wkt) {
+    const normalizedProjName = (wkt.projName || "").toLowerCase().replace(/_/g, " ");
+    if (!wkt.long0 && wkt.longc && (normalizedProjName === "albers conic equal area" || normalizedProjName === "lambert azimuthal equal area")) {
+      wkt.long0 = wkt.longc;
+    }
+    if (!wkt.lat_ts && wkt.lat1 && (normalizedProjName === "stereographic south pole" || normalizedProjName === "polar stereographic (variant b)")) {
+      wkt.lat0 = d2r(wkt.lat1 > 0 ? 90 : -90);
+      wkt.lat_ts = wkt.lat1;
+      delete wkt.lat1;
+    } else if (!wkt.lat_ts && wkt.lat0 && (normalizedProjName === "polar stereographic" || normalizedProjName === "polar stereographic (variant a)")) {
+      wkt.lat_ts = wkt.lat0;
+      wkt.lat0 = d2r(wkt.lat0 > 0 ? 90 : -90);
+      delete wkt.lat1;
+    }
+  }
+
+  // ../../node_modules/wkt-parser/transformPROJJSON.js
+  function processUnit(unit) {
+    let result = { units: null, to_meter: void 0 };
+    if (typeof unit === "string") {
+      result.units = unit.toLowerCase();
+      if (result.units === "metre") {
+        result.units = "meter";
+      }
+      if (result.units === "meter") {
+        result.to_meter = 1;
+      }
+    } else if (unit && unit.name) {
+      result.units = unit.name.toLowerCase();
+      if (result.units === "metre") {
+        result.units = "meter";
+      }
+      result.to_meter = unit.conversion_factor;
+    }
+    return result;
+  }
+  function toValue(valueOrObject) {
+    if (typeof valueOrObject === "object") {
+      return valueOrObject.value * valueOrObject.unit.conversion_factor;
+    }
+    return valueOrObject;
+  }
+  function calculateEllipsoid(value, result) {
+    if (value.ellipsoid.radius) {
+      result.a = value.ellipsoid.radius;
+      result.rf = 0;
+    } else {
+      result.a = toValue(value.ellipsoid.semi_major_axis);
+      if (value.ellipsoid.inverse_flattening !== void 0) {
+        result.rf = value.ellipsoid.inverse_flattening;
+      } else if (value.ellipsoid.semi_major_axis !== void 0 && value.ellipsoid.semi_minor_axis !== void 0) {
+        result.rf = result.a / (result.a - toValue(value.ellipsoid.semi_minor_axis));
+      }
+    }
+  }
+  function transformPROJJSON(projjson, result = {}) {
+    if (!projjson || typeof projjson !== "object") {
+      return projjson;
+    }
+    if (projjson.type === "BoundCRS") {
+      transformPROJJSON(projjson.source_crs, result);
+      if (projjson.transformation) {
+        if (projjson.transformation.method && projjson.transformation.method.name === "NTv2") {
+          result.nadgrids = projjson.transformation.parameters[0].value;
+        } else {
+          result.datum_params = projjson.transformation.parameters.map((param) => param.value);
+        }
+      }
+      return result;
+    }
+    Object.keys(projjson).forEach((key) => {
+      const value = projjson[key];
+      if (value === null) {
+        return;
+      }
+      switch (key) {
+        case "name":
+          if (result.srsCode) {
+            break;
+          }
+          result.name = value;
+          result.srsCode = value;
+          break;
+        case "type":
+          if (value === "GeographicCRS") {
+            result.projName = "longlat";
+          } else if (value === "ProjectedCRS" && projjson.conversion && projjson.conversion.method) {
+            result.projName = projjson.conversion.method.name;
+          }
+          break;
+        case "datum":
+        case "datum_ensemble":
+          if (value.ellipsoid) {
+            result.ellps = value.ellipsoid.name;
+            calculateEllipsoid(value, result);
+          }
+          if (value.prime_meridian) {
+            result.from_greenwich = value.prime_meridian.longitude * Math.PI / 180;
+          }
+          break;
+        case "ellipsoid":
+          result.ellps = value.name;
+          calculateEllipsoid(value, result);
+          break;
+        case "prime_meridian":
+          result.long0 = (value.longitude || 0) * Math.PI / 180;
+          break;
+        case "coordinate_system":
+          if (value.axis) {
+            result.axis = value.axis.map((axis) => {
+              const direction = axis.direction;
+              if (direction === "east")
+                return "e";
+              if (direction === "north")
+                return "n";
+              if (direction === "west")
+                return "w";
+              if (direction === "south")
+                return "s";
+              throw new Error(`Unknown axis direction: ${direction}`);
+            }).join("") + "u";
+            if (value.unit) {
+              const { units, to_meter } = processUnit(value.unit);
+              result.units = units;
+              result.to_meter = to_meter;
+            } else if (value.axis[0] && value.axis[0].unit) {
+              const { units, to_meter } = processUnit(value.axis[0].unit);
+              result.units = units;
+              result.to_meter = to_meter;
+            }
+          }
+          break;
+        case "id":
+          if (value.authority && value.code) {
+            result.title = value.authority + ":" + value.code;
+          }
+          break;
+        case "conversion":
+          if (value.method && value.method.name) {
+            result.projName = value.method.name;
+          }
+          if (value.parameters) {
+            value.parameters.forEach((param) => {
+              const paramName = param.name.toLowerCase().replace(/\s+/g, "_");
+              const paramValue = param.value;
+              if (param.unit && param.unit.conversion_factor) {
+                result[paramName] = paramValue * param.unit.conversion_factor;
+              } else if (param.unit === "degree") {
+                result[paramName] = paramValue * Math.PI / 180;
+              } else {
+                result[paramName] = paramValue;
+              }
+            });
+          }
+          break;
+        case "unit":
+          if (value.name) {
+            result.units = value.name.toLowerCase();
+            if (result.units === "metre") {
+              result.units = "meter";
+            }
+          }
+          if (value.conversion_factor) {
+            result.to_meter = value.conversion_factor;
+          }
+          break;
+        case "base_crs":
+          transformPROJJSON(value, result);
+          result.datumCode = value.id ? value.id.authority + "_" + value.id.code : value.name;
+          break;
+        default:
+          break;
+      }
+    });
+    if (result.latitude_of_false_origin !== void 0) {
+      result.lat0 = result.latitude_of_false_origin;
+    }
+    if (result.longitude_of_false_origin !== void 0) {
+      result.long0 = result.longitude_of_false_origin;
+    }
+    if (result.latitude_of_standard_parallel !== void 0) {
+      result.lat0 = result.latitude_of_standard_parallel;
+      result.lat1 = result.latitude_of_standard_parallel;
+    }
+    if (result.latitude_of_1st_standard_parallel !== void 0) {
+      result.lat1 = result.latitude_of_1st_standard_parallel;
+    }
+    if (result.latitude_of_2nd_standard_parallel !== void 0) {
+      result.lat2 = result.latitude_of_2nd_standard_parallel;
+    }
+    if (result.latitude_of_projection_centre !== void 0) {
+      result.lat0 = result.latitude_of_projection_centre;
+    }
+    if (result.longitude_of_projection_centre !== void 0) {
+      result.longc = result.longitude_of_projection_centre;
+    }
+    if (result.easting_at_false_origin !== void 0) {
+      result.x0 = result.easting_at_false_origin;
+    }
+    if (result.northing_at_false_origin !== void 0) {
+      result.y0 = result.northing_at_false_origin;
+    }
+    if (result.latitude_of_natural_origin !== void 0) {
+      result.lat0 = result.latitude_of_natural_origin;
+    }
+    if (result.longitude_of_natural_origin !== void 0) {
+      result.long0 = result.longitude_of_natural_origin;
+    }
+    if (result.longitude_of_origin !== void 0) {
+      result.long0 = result.longitude_of_origin;
+    }
+    if (result.false_easting !== void 0) {
+      result.x0 = result.false_easting;
+    }
+    if (result.easting_at_projection_centre) {
+      result.x0 = result.easting_at_projection_centre;
+    }
+    if (result.false_northing !== void 0) {
+      result.y0 = result.false_northing;
+    }
+    if (result.northing_at_projection_centre) {
+      result.y0 = result.northing_at_projection_centre;
+    }
+    if (result.standard_parallel_1 !== void 0) {
+      result.lat1 = result.standard_parallel_1;
+    }
+    if (result.standard_parallel_2 !== void 0) {
+      result.lat2 = result.standard_parallel_2;
+    }
+    if (result.scale_factor_at_natural_origin !== void 0) {
+      result.k0 = result.scale_factor_at_natural_origin;
+    }
+    if (result.scale_factor_at_projection_centre !== void 0) {
+      result.k0 = result.scale_factor_at_projection_centre;
+    }
+    if (result.scale_factor_on_pseudo_standard_parallel !== void 0) {
+      result.k0 = result.scale_factor_on_pseudo_standard_parallel;
+    }
+    if (result.azimuth !== void 0) {
+      result.alpha = result.azimuth;
+    }
+    if (result.azimuth_at_projection_centre !== void 0) {
+      result.alpha = result.azimuth_at_projection_centre;
+    }
+    if (result.angle_from_rectified_to_skew_grid) {
+      result.rectified_grid_angle = result.angle_from_rectified_to_skew_grid;
+    }
+    applyProjectionDefaults(result);
+    return result;
+  }
+
+  // ../../node_modules/wkt-parser/index.js
+  var knownTypes = [
+    "PROJECTEDCRS",
+    "PROJCRS",
+    "GEOGCS",
+    "GEOCCS",
+    "PROJCS",
+    "LOCAL_CS",
+    "GEODCRS",
+    "GEODETICCRS",
+    "GEODETICDATUM",
+    "ENGCRS",
+    "ENGINEERINGCRS"
+  ];
   function rename(obj, params) {
     var outName = params[0];
     var inName = params[1];
@@ -20097,10 +20691,25 @@ var __exports__ = (() => {
       }
     }
   }
-  function d2r(input) {
-    return input * D2R2;
-  }
   function cleanWKT(wkt) {
+    var keys = Object.keys(wkt);
+    for (var i = 0, ii = keys.length; i < ii; ++i) {
+      var key = keys[i];
+      if (knownTypes.indexOf(key) !== -1) {
+        setPropertiesFromWkt(wkt[key]);
+      }
+      if (typeof wkt[key] === "object") {
+        cleanWKT(wkt[key]);
+      }
+    }
+  }
+  function setPropertiesFromWkt(wkt) {
+    if (wkt.AUTHORITY) {
+      var authority = Object.keys(wkt.AUTHORITY)[0];
+      if (authority && authority in wkt.AUTHORITY) {
+        wkt.title = authority + ":" + wkt.AUTHORITY[authority];
+      }
+    }
     if (wkt.type === "GEOGCS") {
       wkt.projName = "longlat";
     } else if (wkt.type === "LOCAL_CS") {
@@ -20162,7 +20771,7 @@ var __exports__ = (() => {
       if (wkt.datumCode.slice(0, 2) === "d_") {
         wkt.datumCode = wkt.datumCode.slice(2);
       }
-      if (wkt.datumCode === "new_zealand_geodetic_datum_1949" || wkt.datumCode === "new_zealand_1949") {
+      if (wkt.datumCode === "new_zealand_1949") {
         wkt.datumCode = "nzgd49";
       }
       if (wkt.datumCode === "wgs_1984" || wkt.datumCode === "world_geodetic_system_1984") {
@@ -20171,13 +20780,7 @@ var __exports__ = (() => {
         }
         wkt.datumCode = "wgs84";
       }
-      if (wkt.datumCode.slice(-6) === "_ferro") {
-        wkt.datumCode = wkt.datumCode.slice(0, -6);
-      }
-      if (wkt.datumCode.slice(-8) === "_jakarta") {
-        wkt.datumCode = wkt.datumCode.slice(0, -8);
-      }
-      if (~wkt.datumCode.indexOf("belge")) {
+      if (wkt.datumCode === "belge_1972") {
         wkt.datumCode = "rnb72";
       }
       if (geogcs.DATUM && geogcs.DATUM.SPHEROID) {
@@ -20210,6 +20813,9 @@ var __exports__ = (() => {
     if (wkt.b && !isFinite(wkt.b)) {
       wkt.b = wkt.a;
     }
+    if (wkt.rectified_grid_angle) {
+      wkt.rectified_grid_angle = d2r(wkt.rectified_grid_angle);
+    }
     function toMeter(input) {
       var ratio = wkt.to_meter || 1;
       return input * ratio;
@@ -20255,27 +20861,23 @@ var __exports__ = (() => {
       ["srsCode", "name"]
     ];
     list.forEach(renamer);
-    if (!wkt.long0 && wkt.longc && (wkt.projName === "Albers_Conic_Equal_Area" || wkt.projName === "Lambert_Azimuthal_Equal_Area")) {
-      wkt.long0 = wkt.longc;
-    }
-    if (!wkt.lat_ts && wkt.lat1 && (wkt.projName === "Stereographic_South_Pole" || wkt.projName === "Polar Stereographic (variant B)")) {
-      wkt.lat0 = d2r(wkt.lat1 > 0 ? 90 : -90);
-      wkt.lat_ts = wkt.lat1;
-    } else if (!wkt.lat_ts && wkt.lat0 && wkt.projName === "Polar_Stereographic") {
-      wkt.lat_ts = wkt.lat0;
-      wkt.lat0 = d2r(wkt.lat0 > 0 ? 90 : -90);
-    }
+    applyProjectionDefaults(wkt);
   }
   function wkt_parser_default(wkt) {
+    if (typeof wkt === "object") {
+      return transformPROJJSON(wkt);
+    }
+    const version = detectWKTVersion(wkt);
     var lisp = parser_default(wkt);
-    var type = lisp.shift();
-    var name = lisp.shift();
-    lisp.unshift(["name", name]);
-    lisp.unshift(["type", type]);
+    if (version === "WKT2") {
+      const projjson = buildPROJJSON(lisp);
+      return transformPROJJSON(projjson);
+    }
+    var type = lisp[0];
     var obj = {};
     sExpr(lisp, obj);
     cleanWKT(obj);
-    return obj;
+    return obj[type];
   }
 
   // ../../node_modules/proj4/lib/defs.js