@loaders.gl/tiles 5.0.0-alpha.5 → 5.0.0-alpha.7

package/src/spatial/format-spatial-reference.ts

@@ -4,6 +4,10 @@
 
 import type {ReadonlyCRSDefinition} from '@math.gl/crs';
 import {getI3SLinearUnitScale, getI3SVerticalUnitScale} from './i3s-elevation';
+import {
+  getKnownCrsIdentifierCoordinateFrame,
+  getSpatialCoordinateFrame
+} from './get-spatial-coordinate-frame';
 import {createTilesetSpatialReference} from './spatial-types';
 import type {TilesetElevationMode, TilesetSpatialReference} from './spatial-types';
 
@@ -40,6 +44,7 @@ type Tiles3DLike = {
   schemaUri?: string;
   metadata?: {class?: string; properties?: Record<string, unknown>};
   root?: {boundingVolume?: {region?: unknown}};
+  extensions?: Record<string, unknown>;
 };
 
 /**
@@ -68,8 +73,10 @@ export function getI3SSpatialReference(layer: I3SLayerLike): TilesetSpatialRefer
   const sourceIdentifier = getCrsIdentifier(spatialReference);
   const coordinateFrame =
     sourceIdentifier === undefined
-      ? getWktCoordinateFrame(spatialReference?.wkt)
-      : getIdentifierCoordinateFrame(sourceIdentifier);
+      ? sourceCrs
+        ? getSpatialCoordinateFrame(sourceCrs)
+        : 'unknown'
+      : getSpatialCoordinateFrame(`EPSG:${sourceIdentifier}`);
   const units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
   const warnings: string[] = [];
   const elevationMode = getI3SElevationMode(layer.elevationInfo?.mode);
@@ -159,6 +166,10 @@ function getI3SElevationMode(mode: string | undefined): TilesetElevationMode | u
  * @returns Normalized source spatial metadata.
  */
 export function get3DTilesSpatialReference(tileset: Tiles3DLike): TilesetSpatialReference {
+  const draftSpatialReference = getDraft3DTilesSpatialReference(tileset);
+  if (draftSpatialReference) {
+    return draftSpatialReference;
+  }
   const geocentricCrs = getTilesetSemanticValue(tileset, 'TILESET_CRS_GEOCENTRIC');
   const coordinateEpoch = getTilesetSemanticValue(tileset, 'TILESET_CRS_COORDINATE_EPOCH');
   const warnings: string[] = [];
@@ -202,6 +213,120 @@ export function get3DTilesSpatialReference(tileset: Tiles3DLike): TilesetSpatial
   });
 }
 
+/** Resolves the draft glTF EXT_geospatial_crs WKID or WKT2 declaration. */
+function getDraft3DTilesSpatialReference(
+  tileset: Tiles3DLike
+): TilesetSpatialReference | undefined {
+  const extension = tileset.extensions?.EXT_geospatial_crs as
+    | {format?: unknown; extensions?: Record<string, unknown>}
+    | undefined;
+  if (!extension) {
+    return undefined;
+  }
+  const warnings: string[] = [];
+  let sourceCrs: ReadonlyCRSDefinition | undefined;
+  let verticalCrs: ReadonlyCRSDefinition | undefined;
+  let epoch: number | undefined;
+  let representation: 'identifier' | 'wkt' | undefined;
+  if (extension.format === 'wkid') {
+    const wkidExtension = extension.extensions?.EXT_geospatial_crs_wkid as
+      | {authority?: unknown; wkid?: unknown; vcsWkid?: unknown; epoch?: unknown}
+      | undefined;
+    if (typeof wkidExtension?.authority === 'string' && Number.isInteger(wkidExtension.wkid)) {
+      sourceCrs = `${wkidExtension.authority}:${wkidExtension.wkid}`;
+      representation = 'identifier';
+      if (Number.isInteger(wkidExtension.vcsWkid)) {
+        verticalCrs = `${wkidExtension.authority}:${wkidExtension.vcsWkid}`;
+      }
+      epoch = parseCoordinateEpoch(wkidExtension.epoch);
+      if (wkidExtension.epoch !== undefined && epoch === undefined) {
+        warnings.push('EXT_geospatial_crs_wkid epoch is not a finite decimal year');
+      }
+    } else {
+      warnings.push('EXT_geospatial_crs_wkid requires string authority and integer wkid');
+    }
+  } else if (extension.format === 'wkt2') {
+    const wktExtension = extension.extensions?.EXT_geospatial_crs_wkt2 as
+      | {wkt2?: unknown}
+      | undefined;
+    if (typeof wktExtension?.wkt2 === 'string' && wktExtension.wkt2.trim()) {
+      sourceCrs = wktExtension.wkt2;
+      representation = 'wkt';
+    } else {
+      warnings.push('EXT_geospatial_crs_wkt2 requires a nonempty wkt2 string');
+    }
+  } else {
+    warnings.push(`Unsupported EXT_geospatial_crs format ${String(extension.format)}`);
+  }
+  const coordinateFrame =
+    representation === 'wkt'
+      ? getSpatialCoordinateFrame(sourceCrs as string)
+      : getKnownCrsIdentifierCoordinateFrame(sourceCrs) || 'unknown';
+  const verticalSemantics = getDraftVerticalCrsSemantics(verticalCrs);
+  if (verticalCrs && !verticalSemantics) {
+    warnings.push(
+      `Unsupported vertical CRS ${String(verticalCrs)}; vertical unit and height reference are unknown`
+    );
+  }
+  const verticalUnit = verticalCrs ? verticalSemantics?.unit : 'meter';
+  return createTilesetSpatialReference({
+    sourceCrs,
+    sourceCrsState: sourceCrs ? 'explicit' : 'unknown',
+    sourceCrsRepresentation: representation,
+    verticalCrs,
+    coordinateEpoch: epoch,
+    units:
+      coordinateFrame === 'geocentric'
+        ? ['meter', 'meter', 'meter']
+        : coordinateFrame === 'geographic' && verticalUnit
+          ? ['degree', 'degree', verticalUnit]
+          : undefined,
+    verticalUnitScale: verticalCrs ? (verticalSemantics?.verticalUnitScale ?? Number.NaN) : 1,
+    heightReference: verticalCrs
+      ? (verticalSemantics?.heightReference ?? 'unknown')
+      : sourceCrs
+        ? 'ellipsoidal'
+        : 'unknown',
+    coordinateFrame,
+    axisOrder: sourceCrs ? 'xyz' : 'unknown',
+    provenance: 'metadata',
+    warnings
+  });
+}
+
+/** Known vertical CRS semantics needed to interpret draft 3D Tiles height values. */
+type DraftVerticalCrsSemantics = {
+  unit: string;
+  verticalUnitScale: number;
+  heightReference: 'orthometric';
+};
+
+/** Resolves vertical units and height interpretation for known EPSG vertical CRSs. */
+function getDraftVerticalCrsSemantics(
+  verticalCrs: ReadonlyCRSDefinition | undefined
+): DraftVerticalCrsSemantics | undefined {
+  if (typeof verticalCrs !== 'string') {
+    return undefined;
+  }
+  const epsgMatch = /^EPSG:(\d+)$/i.exec(verticalCrs);
+  if (!epsgMatch) {
+    return undefined;
+  }
+  switch (Number(epsgMatch[1])) {
+    case 5702: // NGVD29 height (ftUS)
+    case 6360: // NAVD88 height (ftUS)
+      return {
+        unit: 'us-foot',
+        verticalUnitScale: 1200 / 3937,
+        heightReference: 'orthometric'
+      };
+    case 5703: // NAVD88 height
+      return {unit: 'meter', verticalUnitScale: 1, heightReference: 'orthometric'};
+    default:
+      return undefined;
+  }
+}
+
 /** Parse the 3D Tiles decimal-year string while tolerating legacy numeric producer output. */
 function parseCoordinateEpoch(value: unknown): number | undefined {
   if (typeof value !== 'string' && typeof value !== 'number') {
@@ -238,57 +363,6 @@ function getCrsIdentifier(spatialReference?: I3SSpatialReferenceLike): number |
   return spatialReference?.latestWkid ?? spatialReference?.wkid;
 }
 
-/** Classify common EPSG identifiers used by I3S into their coordinate frames. */
-function getIdentifierCoordinateFrame(
-  identifier: number
-): TilesetSpatialReference['coordinateFrame'] {
-  if (identifier === 4978) {
-    return 'geocentric';
-  }
-  if (identifier === 4326 || identifier === 4490 || identifier === 4979) {
-    return 'geographic';
-  }
-  return 'projected';
-}
-
-/**
- * Classify a WKT root coordinate system without guessing when the declaration is ambiguous.
- *
- * WKT2 uses `GEODCRS` for both geographic and geocentric systems, so its `CS` declaration is
- * inspected before assigning a frame.
- */
-function getWktCoordinateFrame(wkt?: string): TilesetSpatialReference['coordinateFrame'] {
-  if (!wkt) {
-    return 'unknown';
-  }
-
-  const normalizedWkt = wkt.trim().toUpperCase();
-  const rootKeyword = normalizedWkt.match(/^([A-Z][A-Z0-9_]*)\s*[\[(]/)?.[1];
-  if (rootKeyword === 'GEOCCS') {
-    return 'geocentric';
-  }
-  if (
-    rootKeyword === 'GEOGCS' ||
-    rootKeyword === 'GEOGRAPHICCRS' ||
-    rootKeyword === 'GEOGRAPHIC2DCRS' ||
-    rootKeyword === 'GEOGRAPHIC3DCRS'
-  ) {
-    return 'geographic';
-  }
-  if (rootKeyword === 'PROJCS' || rootKeyword === 'PROJCRS' || rootKeyword === 'PROJECTEDCRS') {
-    return 'projected';
-  }
-  if (rootKeyword === 'GEODCRS' || rootKeyword === 'GEODETICCRS') {
-    if (/\bCS\s*[\[(]\s*CARTESIAN\s*,\s*3\b/.test(normalizedWkt)) {
-      return 'geocentric';
-    }
-    if (/\bCS\s*[\[(]\s*ELLIPSOIDAL\s*,\s*[23]\b/.test(normalizedWkt)) {
-      return 'geographic';
-    }
-  }
-  return 'unknown';
-}
-
 /** Resolve a tileset-wide structured metadata property by its standard semantic. */
 function getTilesetSemanticValue(tileset: Tiles3DLike, semantic: string): unknown {
   const classIdentifier = tileset.metadata?.class;

package/src/spatial/get-spatial-coordinate-frame.ts

@@ -2,19 +2,19 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ReadonlyCRSDefinition, SpatialReferenceCoordinateFrame} from '@math.gl/crs';
-
-const GEOGRAPHIC_CRS = 'EPSG:4326';
-const GEOCENTRIC_CRS = 'EPSG:4978';
-
-/** Normalize common OGC URL and URN CRS spellings to authority identifiers. */
-function normalizeCrsIdentifier(identifier: string): string {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(
-    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
-  );
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
-}
+import {
+  inferCRSRepresentation,
+  parsePROJString,
+  parseWKTCRS,
+  type ReadonlyCRSDefinition,
+  type SpatialReferenceCoordinateFrame,
+  type WKTCRSNode
+} from '@math.gl/crs';
+import {
+  normalizeCrsIdentifier,
+  WGS84_GEOCENTRIC_CRS,
+  WGS84_GEOGRAPHIC_CRS
+} from './normalize-crs-identifier';
 
 /**
  * Classify a CRS definition into the broad coordinate frame used by 3D format adapters.
@@ -26,25 +26,14 @@ export function getSpatialCoordinateFrame(
   definition: ReadonlyCRSDefinition
 ): SpatialReferenceCoordinateFrame {
   if (typeof definition === 'string') {
-    const normalized = normalizeCrsIdentifier(definition);
-    if (normalized === GEOCENTRIC_CRS || /^GEOCCS\s*[\[(]/.test(normalized)) {
-      return 'geocentric';
+    const representation = inferCRSRepresentation(definition);
+    if (representation === 'wkt') {
+      return getWktCoordinateFrame(definition);
     }
-    if (
-      normalized === GEOGRAPHIC_CRS ||
-      normalized === 'EPSG:4490' ||
-      normalized === 'EPSG:4979' ||
-      normalized === 'OGC:CRS84' ||
-      normalized.includes('+PROJ=LONGLAT') ||
-      normalized.includes('+PROJ=LATLONG') ||
-      /^(?:GEOGCS|GEOGCRS|GEOGRAPHICCRS|GEOGRAPHIC2DCRS|GEOGRAPHIC3DCRS)\s*[\[(]/.test(normalized)
-    ) {
-      return 'geographic';
+    if (representation === 'proj-string') {
+      return getProjStringCoordinateFrame(definition);
     }
-    if (/^(?:GEODCRS|GEODETICCRS)\s*[\[(]/.test(normalized)) {
-      return /CS\s*[\[(]\s*CARTESIAN/.test(normalized) ? 'geocentric' : 'geographic';
-    }
-    return 'projected';
+    return getKnownCrsIdentifierCoordinateFrame(definition) || 'projected';
   }
 
   const projJsonDefinition = definition as {
@@ -70,5 +59,111 @@ export function getSpatialCoordinateFrame(
       ? 'geocentric'
       : 'geographic';
   }
-  return 'projected';
+  return 'unknown';
+}
+
+/**
+ * Classifies authority identifiers for which the tiles runtime has explicit frame knowledge.
+ *
+ * Unlike {@link getSpatialCoordinateFrame}, this function does not assume that an unrecognized
+ * authority identifier is projected. Draft formats use this strict result to avoid inventing
+ * semantics for unknown authorities or registry codes.
+ *
+ * @param definition - Serialized CRS identifier.
+ * @returns A known frame, or `undefined` when registry semantics are unavailable.
+ */
+export function getKnownCrsIdentifierCoordinateFrame(
+  definition: ReadonlyCRSDefinition | undefined
+): SpatialReferenceCoordinateFrame | undefined {
+  if (typeof definition !== 'string') {
+    return undefined;
+  }
+  const normalized = normalizeCrsIdentifier(definition);
+  if (normalized === WGS84_GEOCENTRIC_CRS) {
+    return 'geocentric';
+  }
+  if (normalized === WGS84_GEOGRAPHIC_CRS || normalized === 'OGC:CRS84') {
+    return 'geographic';
+  }
+  const epsgMatch = /^EPSG:(\d+)$/.exec(normalized);
+  if (!epsgMatch) {
+    return undefined;
+  }
+  const identifier = Number(epsgMatch[1]);
+  if (identifier === 7789) {
+    return 'geocentric';
+  }
+  if (identifier === 4490 || identifier === 4979) {
+    return 'geographic';
+  }
+  if (
+    identifier === 3857 ||
+    (identifier >= 32601 && identifier <= 32660) ||
+    (identifier >= 32701 && identifier <= 32760)
+  ) {
+    return 'projected';
+  }
+  return undefined;
+}
+
+/** Classifies a WKT definition using the syntax tree parsed by `@math.gl/crs`. */
+function getWktCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
+  let root: WKTCRSNode;
+  try {
+    root = parseWKTCRS(definition).root;
+  } catch {
+    return 'unknown';
+  }
+  switch (root.keyword.toUpperCase()) {
+    case 'GEOCCS':
+      return 'geocentric';
+    case 'GEOGCS':
+    case 'GEOGCRS':
+    case 'GEOGRAPHICCRS':
+    case 'GEOGRAPHIC2DCRS':
+    case 'GEOGRAPHIC3DCRS':
+      return 'geographic';
+    case 'PROJCS':
+    case 'PROJCRS':
+    case 'PROJECTEDCRS':
+      return 'projected';
+    case 'GEODCRS':
+    case 'GEODETICCRS': {
+      const coordinateSystem = root.values.find(
+        (value): value is WKTCRSNode =>
+          value.type === 'node' && value.keyword.toUpperCase() === 'CS'
+      );
+      const subtype = coordinateSystem?.values[0];
+      if (subtype?.type !== 'enumeration' && subtype?.type !== 'string') {
+        return 'unknown';
+      }
+      return subtype.value.toUpperCase() === 'CARTESIAN'
+        ? 'geocentric'
+        : subtype.value.toUpperCase() === 'ELLIPSOIDAL'
+          ? 'geographic'
+          : 'unknown';
+    }
+    default:
+      return 'unknown';
+  }
+}
+
+/** Classifies a PROJ string using the syntax tree parsed by `@math.gl/crs`. */
+function getProjStringCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
+  try {
+    const projection = parsePROJString(definition).parameters.find(
+      parameter => parameter.name.toLowerCase() === 'proj'
+    )?.value;
+    switch (projection?.toLowerCase()) {
+      case 'longlat':
+      case 'latlong':
+        return 'geographic';
+      case 'geocent':
+        return 'geocentric';
+      default:
+        return projection ? 'projected' : 'unknown';
+    }
+  } catch {
+    return 'unknown';
+  }
 }

package/src/spatial/normalize-crs-identifier.ts

@@ -0,0 +1,26 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Compact identifier for conventional WGS84 longitude/latitude coordinates. */
+export const WGS84_GEOGRAPHIC_CRS = 'EPSG:4326';
+
+/** Compact identifier for WGS84 Earth-centered, Earth-fixed coordinates. */
+export const WGS84_GEOCENTRIC_CRS = 'EPSG:4978';
+
+/**
+ * Normalizes common OGC URL and URN CRS spellings to compact authority identifiers.
+ *
+ * This intentionally performs syntax normalization only. Authority lookup and semantic
+ * equivalence remain outside the scope of `@math.gl/crs` and the tiles runtime.
+ *
+ * @param identifier - Serialized CRS identifier.
+ * @returns Uppercase compact identifier when an OGC spelling is recognized.
+ */
+export function normalizeCrsIdentifier(identifier: string): string {
+  const normalizedIdentifier = identifier.trim().toUpperCase();
+  const ogcMatch = normalizedIdentifier.match(
+    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
+  );
+  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
+}

package/src/spatial/spatial-coordinate-transformer.ts

@@ -8,6 +8,11 @@ import {Ellipsoid} from '@math.gl/geospatial';
 import type {ReadonlyCRSDefinition} from '@math.gl/crs';
 import {Proj4Projection, toProj4CRSDefinition, type Proj4CRSDefinition} from '@math.gl/proj4';
 import {getGeoidModel} from './spatial-resource-registry';
+import {
+  normalizeCrsIdentifier,
+  WGS84_GEOCENTRIC_CRS,
+  WGS84_GEOGRAPHIC_CRS
+} from './normalize-crs-identifier';
 import type {
   TilesetHeightReference,
   TilesetSpatialOptions,
@@ -16,9 +21,6 @@ import type {
 } from './spatial-types';
 export {getSpatialCoordinateFrame} from './get-spatial-coordinate-frame';
 
-const GEOGRAPHIC_CRS = 'EPSG:4326';
-const GEOCENTRIC_CRS = 'EPSG:4978';
-
 /**
  * Deterministic coordinate transformer used by 3D tile format adapters.
  *
@@ -90,13 +92,13 @@ export class SpatialCoordinateTransformer {
       if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
         this.geographicProjection = new Proj4Projection({
           from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-          to: GEOGRAPHIC_CRS,
+          to: WGS84_GEOGRAPHIC_CRS,
           enforceAxis: false
         });
       }
       if (!this.outputIsGeographic && !this.outputIsGeocentric) {
         this.heightOutputProjection = new Proj4Projection({
-          from: GEOGRAPHIC_CRS,
+          from: WGS84_GEOGRAPHIC_CRS,
           to: getHorizontalProj4Definition(outputCrs),
           enforceAxis: false
         });
@@ -157,6 +159,59 @@ export class SpatialCoordinateTransformer {
     return result;
   }
 
+  /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+  transformPositions(positions: ArrayLike<number>): Float64Array {
+    if (positions.length % 3 !== 0) {
+      throw new Error('Packed spatial positions must contain a multiple of three components');
+    }
+    const transformedPositions = new Float64Array(positions.length);
+    for (let index = 0; index < positions.length; index += 3) {
+      const transformed = this.transformPosition([
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ]);
+      transformedPositions[index] = transformed[0];
+      transformedPositions[index + 1] = transformed[1];
+      transformedPositions[index + 2] = transformed[2];
+    }
+    return transformedPositions;
+  }
+
+  /** Transform packed xyz normals using a local finite-difference tangent approximation. */
+  transformNormals(normals: ArrayLike<number>, positions: ArrayLike<number>): Float32Array {
+    if (normals.length !== positions.length || normals.length % 3 !== 0) {
+      throw new Error('Spatial normals and positions must have matching xyz component counts');
+    }
+    const transformedNormals = new Float32Array(normals.length);
+    const epsilon = 1e-5;
+    for (let index = 0; index < normals.length; index += 3) {
+      const position = [
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ];
+      const normal = [
+        Number(normals[index]),
+        Number(normals[index + 1]),
+        Number(normals[index + 2])
+      ];
+      const jacobian = getFiniteDifferenceJacobian(this, position, epsilon);
+      const transformedNormal = inverseTransposeMultiply(jacobian, normal);
+      const length = Math.hypot(...transformedNormal);
+      if (length > 0 && Number.isFinite(length)) {
+        transformedNormals[index] = transformedNormal[0] / length;
+        transformedNormals[index + 1] = transformedNormal[1] / length;
+        transformedNormals[index + 2] = transformedNormal[2] / length;
+      } else {
+        transformedNormals[index] = normal[0];
+        transformedNormals[index + 1] = normal[1];
+        transformedNormals[index + 2] = normal[2];
+      }
+    }
+    return transformedNormals;
+  }
+
   /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
   private toGeographic(coordinate: number[]): number[] {
     if (this.sourceIsGeocentric) {
@@ -180,6 +235,47 @@ export class SpatialCoordinateTransformer {
   }
 }
 
+function getFiniteDifferenceJacobian(
+  transformer: SpatialCoordinateTransformer,
+  position: number[],
+  epsilon: number
+): number[][] {
+  const columns: number[][] = [];
+  for (let axis = 0; axis < 3; axis++) {
+    const plus = position.slice();
+    const minus = position.slice();
+    plus[axis] += epsilon;
+    minus[axis] -= epsilon;
+    const plusPosition = transformer.transformPosition(plus);
+    const minusPosition = transformer.transformPosition(minus);
+    columns.push([
+      (plusPosition[0] - minusPosition[0]) / (2 * epsilon),
+      (plusPosition[1] - minusPosition[1]) / (2 * epsilon),
+      (plusPosition[2] - minusPosition[2]) / (2 * epsilon)
+    ]);
+  }
+  return columns;
+}
+
+function inverseTransposeMultiply(jacobianColumns: number[][], vector: number[]): number[] {
+  const [a, b, c] = jacobianColumns;
+  const determinant =
+    a[0] * (b[1] * c[2] - b[2] * c[1]) -
+    b[0] * (a[1] * c[2] - a[2] * c[1]) +
+    c[0] * (a[1] * b[2] - a[2] * b[1]);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-15) {
+    return vector;
+  }
+  const inverseTranspose = [
+    [b[1] * c[2] - b[2] * c[1], a[2] * c[1] - a[1] * c[2], a[1] * b[2] - a[2] * b[1]],
+    [b[2] * c[0] - b[0] * c[2], a[0] * c[2] - a[2] * c[0], a[2] * b[0] - a[0] * b[2]],
+    [b[0] * c[1] - b[1] * c[0], a[1] * c[0] - a[0] * c[1], a[0] * b[1] - a[1] * b[0]]
+  ];
+  return inverseTranspose.map(
+    row => (row[0] * vector[0] + row[1] * vector[1] + row[2] * vector[2]) / determinant
+  );
+}
+
 /** Select the horizontal component that the proj4js runtime can execute. */
 function getHorizontalProj4Definition(
   definition: ReadonlyCRSDefinition | undefined
@@ -224,7 +320,9 @@ function validateTransformRequest(spatialReference: TilesetSpatialReference): vo
 
 /** Return whether a CRS definition identifies the WGS84 geocentric frame. */
 function isWgs84Geocentric(definition: unknown): boolean {
-  return typeof definition === 'string' && normalizeCrsIdentifier(definition) === GEOCENTRIC_CRS;
+  return (
+    typeof definition === 'string' && normalizeCrsIdentifier(definition) === WGS84_GEOCENTRIC_CRS
+  );
 }
 
 /** Return whether a CRS definition uses conventional WGS84 longitude/latitude coordinates. */
@@ -233,16 +331,9 @@ function isWgs84Geographic(definition: unknown): boolean {
     return false;
   }
   const identifier = normalizeCrsIdentifier(definition);
-  return identifier === GEOGRAPHIC_CRS || identifier === 'EPSG:4979' || identifier === 'OGC:CRS84';
-}
-
-/** Normalize common OGC URL and URN CRS spellings to authority identifiers. */
-function normalizeCrsIdentifier(identifier: string): string {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(
-    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
+  return (
+    identifier === WGS84_GEOGRAPHIC_CRS || identifier === 'EPSG:4979' || identifier === 'OGC:CRS84'
   );
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
 }
 
 /** Return whether source and target height interpretations differ. */