ol 10.2.2-dev.1730915520848 → 10.2.2-dev.1730916385053

package/geom/Geometry.js

@@ -330,11 +330,11 @@ class Geometry extends BaseObject {
               tmpTransform,
               outCoordinates,
             );
-            return getTransform(sourceProj, destination)(
-              transformed,
-              transformed,
-              stride,
-            );
+            const projTransform = getTransform(sourceProj, destination);
+            if (projTransform) {
+              return projTransform(transformed, transformed, stride);
+            }
+            return transformed;
           }
         : getTransform(sourceProj, destination);
     this.applyTransform(transformFn);

package/math.d.ts

@@ -101,4 +101,12 @@ export function floor(n: number, decimals: number): number;
  * @return {number} The next bigger integer.
  */
 export function ceil(n: number, decimals: number): number;
+/**
+ * Wraps a number between some minimum and maximum values.
+ * @param {number} n The number to wrap.
+ * @param {number} min The minimum of the range (inclusive).
+ * @param {number} max The maximum of the range (exclusive).
+ * @return {number} The wrapped number.
+ */
+export function wrap(n: number, min: number, max: number): number;
 //# sourceMappingURL=math.d.ts.map

package/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["math.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,6BANW,MAAM,OACN,MAAM,OACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;;;;;GAUG;AACH,0CARW,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAgBjB;AAED;;;;;;;GAOG;AACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAMjB;AAED;;;;;;GAMG;AACH,uCAJW,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAEnB,KAAK,CAAC,MAAM,CAAC,GAAC,IAAI,CAgD7B;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,0BAJW,MAAM,KACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;;GAOG;AACH,wBALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;GAKG;AACH,2BAJW,MAAM,YACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;GAMG;AACH,yBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,yBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,wBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB"}
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["math.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,6BANW,MAAM,OACN,MAAM,OACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;;;;;GAUG;AACH,0CARW,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAgBjB;AAED;;;;;;;GAOG;AACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAMjB;AAED;;;;;;GAMG;AACH,uCAJW,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAEnB,KAAK,CAAC,MAAM,CAAC,GAAC,IAAI,CAgD7B;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,0BAJW,MAAM,KACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;;GAOG;AACH,wBALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;GAKG;AACH,2BAJW,MAAM,YACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;GAMG;AACH,yBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,yBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,wBAJW,MAAM,YACN,MAAM,GACL,MAAM,CAIjB;AAED;;;;;;GAMG;AACH,wBALW,MAAM,OACN,MAAM,OACN,MAAM,GACL,MAAM,CAQjB"}

package/math.js

@@ -197,3 +197,18 @@ export function floor(n, decimals) {
 export function ceil(n, decimals) {
   return Math.ceil(toFixed(n, decimals));
 }
+
+/**
+ * Wraps a number between some minimum and maximum values.
+ * @param {number} n The number to wrap.
+ * @param {number} min The minimum of the range (inclusive).
+ * @param {number} max The maximum of the range (exclusive).
+ * @return {number} The wrapped number.
+ */
+export function wrap(n, min, max) {
+  if (n >= min && n < max) {
+    return n;
+  }
+  const range = max - min;
+  return ((((n - min) % range) + range) % range) + min;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.2.2-dev.1730915520848",
+  "version": "10.2.2-dev.1730916385053",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/proj/Projection.d.ts

@@ -58,28 +58,30 @@ export type Options = {
  */
 /**
  * @classdesc
- * Projection definition class. One of these is created for each projection
- * supported in the application and stored in the {@link module:ol/proj} namespace.
- * You can use these in applications, but this is not required, as API params
- * and options use {@link module:ol/proj~ProjectionLike} which means the simple string
- * code will suffice.
+ * In most cases, you should not need to create instances of this class.
+ * Instead, where projection information is required, you can use a string
+ * projection code or identifier (e.g. `EPSG:4326`) instead of a projection
+ * instance.
  *
- * You can use {@link module:ol/proj.get} to retrieve the object for a particular
- * projection.
+ * The library includes support for transforming coordinates between the following
+ * projections:
  *
- * The library includes definitions for `EPSG:4326` and `EPSG:3857`, together
- * with the following aliases:
- * * `EPSG:4326`: CRS:84, urn:ogc:def:crs:EPSG:6.6:4326,
- *     urn:ogc:def:crs:OGC:1.3:CRS84, urn:ogc:def:crs:OGC:2:84,
- *     http://www.opengis.net/gml/srs/epsg.xml#4326,
- *     urn:x-ogc:def:crs:EPSG:4326
- * * `EPSG:3857`: EPSG:102100, EPSG:102113, EPSG:900913,
- *     urn:ogc:def:crs:EPSG:6.18:3:3857,
- *     http://www.opengis.net/gml/srs/epsg.xml#3857
+ *  * WGS 84 / Geographic - Using codes `EPSG:4326`, `CRS:84`, `urn:ogc:def:crs:EPSG:6.6:4326`,
+ *    `urn:ogc:def:crs:OGC:1.3:CRS84`, `urn:ogc:def:crs:OGC:2:84`, `http://www.opengis.net/gml/srs/epsg.xml#4326`,
+ *    or `urn:x-ogc:def:crs:EPSG:4326`
+ *  * WGS 84 / Spherical Mercator - Using codes `EPSG:3857`, `EPSG:102100`, `EPSG:102113`, `EPSG:900913`,
+ *    `urn:ogc:def:crs:EPSG:6.18:3:3857`, or `http://www.opengis.net/gml/srs/epsg.xml#3857`
+ *  * WGS 84 / UTM zones - Using codes `EPSG:32601` through `EPSG:32660` for northern zones
+ *    and `EPSG:32701` through `EPSG:32760` for southern zones. Note that the built-in UTM transforms
+ *    are lower accuracy (with errors on the order of 0.1 m) than those that you might get in a
+ *    library like [proj4js](https://github.com/proj4js/proj4js).
  *
- * If you use [proj4js](https://github.com/proj4js/proj4js), aliases can
- * be added using `proj4.defs()`. After all required projection definitions are
- * added, call the {@link module:ol/proj/proj4.register} function.
+ * For additional projection support, or to use higher accuracy transforms than the built-in ones, you can use
+ * the [proj4js](https://github.com/proj4js/proj4js) library. With `proj4js`, after adding any new projection
+ * definitions, call the {@link module:ol/proj/proj4.register} function.
+ *
+ * You can use the {@link module:ol/proj.get} function to retrieve a projection instance
+ * for one of the registered projections.
  *
  * @api
  */

package/proj/Projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Projection.d.ts","sourceRoot":"","sources":["Projection.js"],"names":[],"mappings":";;;;;UAOc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUG,MAAM,QAAE,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM;;AAZ5E;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyEjB;IAtEC;;;OAGG;IACH,cAAyB;IAEzB;;;;;;OAMG;IACH,eAAuE;IAEvE;;;;;;OAMG;IACH,gBAAmE;IAEnE;;;;;;OAMG;IACH,qBACgE;IAEhE;;;OAGG;IACH,yBACyE;IAEzE;;;OAGG;IACH,gBAAoE;IAEpE;;;OAGG;IACH,kBAAiD;IAEjD;;;OAGG;IACH,gCAAyD;IAEzD;;;OAGG;IACH,yBAA4B;IAE5B;;;OAGG;IACH,uBAA2C;IAG7C;;OAEG;IACH,YAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,WAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,aAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;OAIG;IACH,YAHY,OAAO,YAAY,EAAE,KAAK,CAKrC;IAED;;;;;;OAMG;IACH,oBAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;;;;;;;OAUG;IACH,sBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,OAAO,CAKlB;IAED;;;;OAIG;IACH,kBAHW,OAAO,QAMjB;IAED;;OAEG;IACH,sBAFY,OAAO,yBAAyB,EAAE,OAAO,CAIpD;IAED;;OAEG;IACH,6BAFW,OAAO,yBAAyB,EAAE,OAAO,QAInD;IAED;;;;OAIG;IACH,kBAHW,OAAO,cAAc,EAAE,MAAM,QAMvC;IAED;;;;;OAKG;IACH,4BAJW,OAAO,cAAc,EAAE,MAAM,QAMvC;IAED;;;;;OAKG;IACH,4BAHW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAqC,EAArC,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM,QAKxE;IAED;;;;OAIG;IACH,0BAHY,CAAS,IAAM,EAAN,MAAM,EAAE,IAAqC,EAArC,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM,GAAC,SAAS,CAKnF;CACF"}
+{"version":3,"file":"Projection.d.ts","sourceRoot":"","sources":["Projection.js"],"names":[],"mappings":";;;;;UAOc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUG,MAAM,QAAE,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM;;AAZ5E;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyEjB;IAtEC;;;OAGG;IACH,cAAyB;IAEzB;;;;;;OAMG;IACH,eAAuE;IAEvE;;;;;;OAMG;IACH,gBAAmE;IAEnE;;;;;;OAMG;IACH,qBACgE;IAEhE;;;OAGG;IACH,yBACyE;IAEzE;;;OAGG;IACH,gBAAoE;IAEpE;;;OAGG;IACH,kBAAiD;IAEjD;;;OAGG;IACH,gCAAyD;IAEzD;;;OAGG;IACH,yBAA4B;IAE5B;;;OAGG;IACH,uBAA2C;IAG7C;;OAEG;IACH,YAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,WAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,aAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;OAIG;IACH,YAHY,OAAO,YAAY,EAAE,KAAK,CAKrC;IAED;;;;;;OAMG;IACH,oBAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;;;;;;;OAUG;IACH,sBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,OAAO,CAKlB;IAED;;;;OAIG;IACH,kBAHW,OAAO,QAMjB;IAED;;OAEG;IACH,sBAFY,OAAO,yBAAyB,EAAE,OAAO,CAIpD;IAED;;OAEG;IACH,6BAFW,OAAO,yBAAyB,EAAE,OAAO,QAInD;IAED;;;;OAIG;IACH,kBAHW,OAAO,cAAc,EAAE,MAAM,QAMvC;IAED;;;;;OAKG;IACH,4BAJW,OAAO,cAAc,EAAE,MAAM,QAMvC;IAED;;;;;OAKG;IACH,4BAHW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAqC,EAArC,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM,QAKxE;IAED;;;;OAIG;IACH,0BAHY,CAAS,IAAM,EAAN,MAAM,EAAE,IAAqC,EAArC,OAAO,kBAAkB,EAAE,UAAU,KAAE,MAAM,GAAC,SAAS,CAKnF;CACF"}

package/proj/Projection.js

@@ -24,28 +24,30 @@ import {METERS_PER_UNIT} from './Units.js';
 
 /**
  * @classdesc
- * Projection definition class. One of these is created for each projection
- * supported in the application and stored in the {@link module:ol/proj} namespace.
- * You can use these in applications, but this is not required, as API params
- * and options use {@link module:ol/proj~ProjectionLike} which means the simple string
- * code will suffice.
+ * In most cases, you should not need to create instances of this class.
+ * Instead, where projection information is required, you can use a string
+ * projection code or identifier (e.g. `EPSG:4326`) instead of a projection
+ * instance.
  *
- * You can use {@link module:ol/proj.get} to retrieve the object for a particular
- * projection.
+ * The library includes support for transforming coordinates between the following
+ * projections:
  *
- * The library includes definitions for `EPSG:4326` and `EPSG:3857`, together
- * with the following aliases:
- * * `EPSG:4326`: CRS:84, urn:ogc:def:crs:EPSG:6.6:4326,
- *     urn:ogc:def:crs:OGC:1.3:CRS84, urn:ogc:def:crs:OGC:2:84,
- *     http://www.opengis.net/gml/srs/epsg.xml#4326,
- *     urn:x-ogc:def:crs:EPSG:4326
- * * `EPSG:3857`: EPSG:102100, EPSG:102113, EPSG:900913,
- *     urn:ogc:def:crs:EPSG:6.18:3:3857,
- *     http://www.opengis.net/gml/srs/epsg.xml#3857
+ *  * WGS 84 / Geographic - Using codes `EPSG:4326`, `CRS:84`, `urn:ogc:def:crs:EPSG:6.6:4326`,
+ *    `urn:ogc:def:crs:OGC:1.3:CRS84`, `urn:ogc:def:crs:OGC:2:84`, `http://www.opengis.net/gml/srs/epsg.xml#4326`,
+ *    or `urn:x-ogc:def:crs:EPSG:4326`
+ *  * WGS 84 / Spherical Mercator - Using codes `EPSG:3857`, `EPSG:102100`, `EPSG:102113`, `EPSG:900913`,
+ *    `urn:ogc:def:crs:EPSG:6.18:3:3857`, or `http://www.opengis.net/gml/srs/epsg.xml#3857`
+ *  * WGS 84 / UTM zones - Using codes `EPSG:32601` through `EPSG:32660` for northern zones
+ *    and `EPSG:32701` through `EPSG:32760` for southern zones. Note that the built-in UTM transforms
+ *    are lower accuracy (with errors on the order of 0.1 m) than those that you might get in a
+ *    library like [proj4js](https://github.com/proj4js/proj4js).
  *
- * If you use [proj4js](https://github.com/proj4js/proj4js), aliases can
- * be added using `proj4.defs()`. After all required projection definitions are
- * added, call the {@link module:ol/proj/proj4.register} function.
+ * For additional projection support, or to use higher accuracy transforms than the built-in ones, you can use
+ * the [proj4js](https://github.com/proj4js/proj4js) library. With `proj4js`, after adding any new projection
+ * definitions, call the {@link module:ol/proj/proj4.register} function.
+ *
+ * You can use the {@link module:ol/proj.get} function to retrieve a projection instance
+ * for one of the registered projections.
  *
  * @api
  */

package/proj/proj4.js

@@ -7,8 +7,8 @@ import {
   addEquivalentProjections,
   addProjection,
   createSafeCoordinateTransform,
-  get,
 } from '../proj.js';
+import {get as getCachedProjection} from './projections.js';
 import {get as getTransform} from './transforms.js';
 
 /**
@@ -49,7 +49,7 @@ export function register(proj4) {
   let i, j;
   for (i = 0; i < len; ++i) {
     const code = projCodes[i];
-    if (!get(code)) {
+    if (!getCachedProjection(code)) {
       const def = proj4.defs(code);
       let units = /** @type {import("./Units.js").Units} */ (def.units);
       if (!units && def.projName === 'longlat') {
@@ -67,10 +67,10 @@ export function register(proj4) {
   }
   for (i = 0; i < len; ++i) {
     const code1 = projCodes[i];
-    const proj1 = get(code1);
+    const proj1 = getCachedProjection(code1);
     for (j = 0; j < len; ++j) {
       const code2 = projCodes[j];
-      const proj2 = get(code2);
+      const proj2 = getCachedProjection(code2);
       if (!getTransform(code1, code2)) {
         if (proj4.defs[code1] === proj4.defs[code2]) {
           addEquivalentProjections([proj1, proj2]);
@@ -148,13 +148,13 @@ export async function fromEPSGCode(code) {
 
   const epsgCode = 'EPSG:' + code;
   if (proj4.defs(epsgCode)) {
-    return get(epsgCode);
+    return getCachedProjection(epsgCode);
   }
 
   proj4.defs(epsgCode, await epsgLookup(code));
   register(proj4);
 
-  return get(epsgCode);
+  return getCachedProjection(epsgCode);
 }
 
 /**

package/proj/projections.d.ts

@@ -5,9 +5,9 @@ export function clear(): void;
 /**
  * Get a cached projection by code.
  * @param {string} code The code for the projection.
- * @return {import("./Projection.js").default} The projection (if cached).
+ * @return {import("./Projection.js").default|null} The projection (if cached).
  */
-export function get(code: string): import("./Projection.js").default;
+export function get(code: string): import("./Projection.js").default | null;
 /**
  * Add a projection to the cache.
  * @param {string} code The projection code.

package/proj/projections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projections.d.ts","sourceRoot":"","sources":["projections.js"],"names":[],"mappings":"AASA;;GAEG;AACH,8BAEC;AAED;;;;GAIG;AACH,0BAHW,MAAM,GACL,OAAO,iBAAiB,EAAE,OAAO,CAQ5C;AAED;;;;GAIG;AACH,0BAHW,MAAM,cACN,OAAO,iBAAiB,EAAE,OAAO,QAI3C"}
+{"version":3,"file":"projections.d.ts","sourceRoot":"","sources":["projections.js"],"names":[],"mappings":"AASA;;GAEG;AACH,8BAEC;AAED;;;;GAIG;AACH,0BAHW,MAAM,GACL,OAAO,iBAAiB,EAAE,OAAO,GAAC,IAAI,CAQjD;AAED;;;;GAIG;AACH,0BAHW,MAAM,cACN,OAAO,iBAAiB,EAAE,OAAO,QAI3C"}

package/proj/projections.js

@@ -17,7 +17,7 @@ export function clear() {
 /**
  * Get a cached projection by code.
  * @param {string} code The code for the projection.
- * @return {import("./Projection.js").default} The projection (if cached).
+ * @return {import("./Projection.js").default|null} The projection (if cached).
  */
 export function get(code) {
   return (

package/proj/transforms.d.ts

@@ -25,7 +25,7 @@ export function remove(source: import("./Projection.js").default, destination: i
  * Get a transform given a source code and a destination code.
  * @param {string} sourceCode The code for the source projection.
  * @param {string} destinationCode The code for the destination projection.
- * @return {import("../proj.js").TransformFunction|undefined} The transform function (if found).
+ * @return {import("../proj.js").TransformFunction|null} The transform function (if found).
  */
-export function get(sourceCode: string, destinationCode: string): import("../proj.js").TransformFunction | undefined;
+export function get(sourceCode: string, destinationCode: string): import("../proj.js").TransformFunction | null;
 //# sourceMappingURL=transforms.d.ts.map

package/proj/transforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.d.ts","sourceRoot":"","sources":["transforms.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,8BAEC;AAED;;;;;;;GAOG;AACH,4BAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,YAAY,EAAE,iBAAiB,QAShD;AAED;;;;;;;;GAQG;AACH,+BAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,iBAAiB,EAAE,OAAO,GAChC,OAAO,YAAY,EAAE,iBAAiB,CAWjD;AAED;;;;;GAKG;AACH,gCAJW,MAAM,mBACN,MAAM,GACL,OAAO,YAAY,EAAE,iBAAiB,GAAC,SAAS,CAQ3D"}
+{"version":3,"file":"transforms.d.ts","sourceRoot":"","sources":["transforms.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,8BAEC;AAED;;;;;;;GAOG;AACH,4BAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,YAAY,EAAE,iBAAiB,QAShD;AAED;;;;;;;;GAQG;AACH,+BAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,iBAAiB,EAAE,OAAO,GAChC,OAAO,YAAY,EAAE,iBAAiB,CAWjD;AAED;;;;;GAKG;AACH,gCAJW,MAAM,mBACN,MAAM,GACL,OAAO,YAAY,EAAE,iBAAiB,GAAC,IAAI,CAOtD"}

package/proj/transforms.js

@@ -57,12 +57,11 @@ export function remove(source, destination) {
  * Get a transform given a source code and a destination code.
  * @param {string} sourceCode The code for the source projection.
  * @param {string} destinationCode The code for the destination projection.
- * @return {import("../proj.js").TransformFunction|undefined} The transform function (if found).
+ * @return {import("../proj.js").TransformFunction|null} The transform function (if found).
  */
 export function get(sourceCode, destinationCode) {
-  let transform;
   if (sourceCode in transforms && destinationCode in transforms[sourceCode]) {
-    transform = transforms[sourceCode][destinationCode];
+    return transforms[sourceCode][destinationCode];
   }
-  return transform;
+  return null;
 }

package/proj/utm.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {string} code The projection code.
+ * @return {UTMZone|null} The UTM zone info (or null if not UTM).
+ */
+export function zoneFromCode(code: string): UTMZone | null;
+/**
+ * @param {string} code The projection code.
+ * @return {import('./Projection.js').default|null} A projection or null if unable to create one.
+ */
+export function makeProjection(code: string): import("./Projection.js").default | null;
+/**
+ * @param {import('./Projection.js').default} projection The projection.
+ * @return {import('../proj.js').Transforms|null} The transforms lookup or null if unable to handle projection.
+ */
+export function makeTransforms(projection: import("./Projection.js").default): import("../proj.js").Transforms | null;
+export type UTMZone = {
+    /**
+     * The zone number (1 - 60).
+     */
+    number: number;
+    /**
+     * The northern hemisphere.
+     */
+    north: boolean;
+};
+//# sourceMappingURL=utm.d.ts.map

package/proj/utm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utm.d.ts","sourceRoot":"","sources":["utm.js"],"names":[],"mappings":"AA6MA;;;GAGG;AACH,mCAHW,MAAM,GACL,OAAO,GAAC,IAAI,CA4BvB;AA8BD;;;GAGG;AACH,qCAHW,MAAM,GACL,OAAO,iBAAiB,EAAE,OAAO,GAAC,IAAI,CAQjD;AAED;;;GAGG;AACH,2CAHW,OAAO,iBAAiB,EAAE,OAAO,GAChC,OAAO,YAAY,EAAE,UAAU,GAAC,IAAI,CAY/C;;;;;YAhRa,MAAM;;;;WACN,OAAO"}

package/proj/utm.js

@@ -0,0 +1,292 @@
+/**
+ * @module ol/proj/utm
+ */
+
+/**
+ * Adapted from https://github.com/Turbo87/utm
+ * Copyright (c) 2012-2017 Tobias Bieniek
+ *
+ * The functions here provide approximate transforms to and from UTM.
+ * They are not appropriate for use beyond the validity extend of a UTM
+ * zone, and the accuracy of the transform decreases toward the zone
+ * edges.
+ */
+
+import Projection from './Projection.js';
+import {toDegrees, toRadians, wrap} from '../math.js';
+
+/**
+ * @typedef {Object} UTMZone
+ * @property {number} number The zone number (1 - 60).
+ * @property {boolean} north The northern hemisphere.
+ */
+
+const K0 = 0.9996;
+
+const E = 0.00669438;
+const E2 = E * E;
+const E3 = E2 * E;
+const E_P2 = E / (1 - E);
+
+const SQRT_E = Math.sqrt(1 - E);
+const _E = (1 - SQRT_E) / (1 + SQRT_E);
+const _E2 = _E * _E;
+const _E3 = _E2 * _E;
+const _E4 = _E3 * _E;
+const _E5 = _E4 * _E;
+
+const M1 = 1 - E / 4 - (3 * E2) / 64 - (5 * E3) / 256;
+const M2 = (3 * E) / 8 + (3 * E2) / 32 + (45 * E3) / 1024;
+const M3 = (15 * E2) / 256 + (45 * E3) / 1024;
+const M4 = (35 * E3) / 3072;
+
+const P2 = (3 / 2) * _E - (27 / 32) * _E3 + (269 / 512) * _E5;
+const P3 = (21 / 16) * _E2 - (55 / 32) * _E4;
+const P4 = (151 / 96) * _E3 - (417 / 128) * _E5;
+const P5 = (1097 / 512) * _E4;
+
+const R = 6378137;
+
+/**
+ * @param {number} easting Easting value of coordinate.
+ * @param {number} northing Northing value of coordinate.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import("../coordinate.js").Coordinate} The transformed coordinate.
+ */
+function toLonLat(easting, northing, zone) {
+  const x = easting - 500000;
+  const y = zone.north ? northing : northing - 10000000;
+
+  const m = y / K0;
+  const mu = m / (R * M1);
+
+  const pRad =
+    mu +
+    P2 * Math.sin(2 * mu) +
+    P3 * Math.sin(4 * mu) +
+    P4 * Math.sin(6 * mu) +
+    P5 * Math.sin(8 * mu);
+
+  const pSin = Math.sin(pRad);
+  const pSin2 = pSin * pSin;
+
+  const pCos = Math.cos(pRad);
+
+  const pTan = pSin / pCos;
+  const pTan2 = pTan * pTan;
+  const pTan4 = pTan2 * pTan2;
+
+  const epSin = 1 - E * pSin2;
+  const epSinSqrt = Math.sqrt(1 - E * pSin2);
+
+  const n = R / epSinSqrt;
+  const r = (1 - E) / epSin;
+
+  const c = E_P2 * pCos ** 2;
+  const c2 = c * c;
+
+  const d = x / (n * K0);
+  const d2 = d * d;
+  const d3 = d2 * d;
+  const d4 = d3 * d;
+  const d5 = d4 * d;
+  const d6 = d5 * d;
+
+  const latitude =
+    pRad -
+    (pTan / r) *
+      (d2 / 2 - (d4 / 24) * (5 + 3 * pTan2 + 10 * c - 4 * c2 - 9 * E_P2)) +
+    (d6 / 720) * (61 + 90 * pTan2 + 298 * c + 45 * pTan4 - 252 * E_P2 - 3 * c2);
+
+  let longitude =
+    (d -
+      (d3 / 6) * (1 + 2 * pTan2 + c) +
+      (d5 / 120) * (5 - 2 * c + 28 * pTan2 - 3 * c2 + 8 * E_P2 + 24 * pTan4)) /
+    pCos;
+
+  longitude = wrap(
+    longitude + toRadians(zoneToCentralLongitude(zone.number)),
+    -Math.PI,
+    Math.PI,
+  );
+
+  return [toDegrees(longitude), toDegrees(latitude)];
+}
+
+const MIN_LATITUDE = -80;
+const MAX_LATITUDE = 84;
+const MIN_LONGITUDE = -180;
+const MAX_LONGITUDE = 180;
+
+/**
+ * @param {number} longitude The longitude.
+ * @param {number} latitude The latitude.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import('../coordinate.js').Coordinate} The UTM coordinate.
+ */
+function fromLonLat(longitude, latitude, zone) {
+  longitude = wrap(longitude, MIN_LONGITUDE, MAX_LONGITUDE);
+
+  if (latitude < MIN_LATITUDE) {
+    latitude = MIN_LATITUDE;
+  } else if (latitude > MAX_LATITUDE) {
+    latitude = MAX_LATITUDE;
+  }
+
+  const latRad = toRadians(latitude);
+  const latSin = Math.sin(latRad);
+  const latCos = Math.cos(latRad);
+
+  const latTan = latSin / latCos;
+  const latTan2 = latTan * latTan;
+  const latTan4 = latTan2 * latTan2;
+
+  const lonRad = toRadians(longitude);
+  const centralLon = zoneToCentralLongitude(zone.number);
+  const centralLonRad = toRadians(centralLon);
+
+  const n = R / Math.sqrt(1 - E * latSin ** 2);
+  const c = E_P2 * latCos ** 2;
+
+  const a = latCos * wrap(lonRad - centralLonRad, -Math.PI, Math.PI);
+  const a2 = a * a;
+  const a3 = a2 * a;
+  const a4 = a3 * a;
+  const a5 = a4 * a;
+  const a6 = a5 * a;
+
+  const m =
+    R *
+    (M1 * latRad -
+      M2 * Math.sin(2 * latRad) +
+      M3 * Math.sin(4 * latRad) -
+      M4 * Math.sin(6 * latRad));
+
+  const easting =
+    K0 *
+      n *
+      (a +
+        (a3 / 6) * (1 - latTan2 + c) +
+        (a5 / 120) * (5 - 18 * latTan2 + latTan4 + 72 * c - 58 * E_P2)) +
+    500000;
+
+  let northing =
+    K0 *
+    (m +
+      n *
+        latTan *
+        (a2 / 2 +
+          (a4 / 24) * (5 - latTan2 + 9 * c + 4 * c ** 2) +
+          (a6 / 720) * (61 - 58 * latTan2 + latTan4 + 600 * c - 330 * E_P2)));
+
+  if (!zone.north) {
+    northing += 10000000;
+  }
+
+  return [easting, northing];
+}
+
+/**
+ * @param {number} zone The zone number.
+ * @return {number} The central longitude in degrees.
+ */
+function zoneToCentralLongitude(zone) {
+  return (zone - 1) * 6 - 180 + 3;
+}
+
+/**
+ * @type {Array<RegExp>}
+ */
+const epsgRegExes = [
+  /^EPSG:(\d+)$/,
+  /^urn:ogc:def:crs:EPSG::(\d+)$/,
+  /^http:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(\d+)$/,
+];
+
+/**
+ * @param {string} code The projection code.
+ * @return {UTMZone|null} The UTM zone info (or null if not UTM).
+ */
+export function zoneFromCode(code) {
+  let epsgId = 0;
+  for (const re of epsgRegExes) {
+    const match = code.match(re);
+    if (match) {
+      epsgId = parseInt(match[1]);
+      break;
+    }
+  }
+  if (!epsgId) {
+    return null;
+  }
+
+  let number = 0;
+  let north = false;
+  if (epsgId > 32700 && epsgId < 32761) {
+    number = epsgId - 32700;
+  } else if (epsgId > 32600 && epsgId < 32661) {
+    north = true;
+    number = epsgId - 32600;
+  }
+  if (!number) {
+    return null;
+  }
+
+  return {number, north};
+}
+
+/**
+ * @param {function(number, number, UTMZone): import('../coordinate.js').Coordinate} transformer The transformer.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import('../proj.js').TransformFunction} The transform function.
+ */
+function makeTransformFunction(transformer, zone) {
+  return function (input, output, dimension, stride) {
+    const length = input.length;
+    dimension = dimension > 1 ? dimension : 2;
+    stride = stride ?? dimension;
+    if (!output) {
+      if (dimension > 2) {
+        output = input.slice();
+      } else {
+        output = new Array(length);
+      }
+    }
+    for (let i = 0; i < length; i += stride) {
+      const x = input[i];
+      const y = input[i + 1];
+      const coord = transformer(x, y, zone);
+      output[i] = coord[0];
+      output[i + 1] = coord[1];
+    }
+    return output;
+  };
+}
+
+/**
+ * @param {string} code The projection code.
+ * @return {import('./Projection.js').default|null} A projection or null if unable to create one.
+ */
+export function makeProjection(code) {
+  const zone = zoneFromCode(code);
+  if (!zone) {
+    return null;
+  }
+  return new Projection({code, units: 'm'});
+}
+
+/**
+ * @param {import('./Projection.js').default} projection The projection.
+ * @return {import('../proj.js').Transforms|null} The transforms lookup or null if unable to handle projection.
+ */
+export function makeTransforms(projection) {
+  const zone = zoneFromCode(projection.getCode());
+  if (!zone) {
+    return null;
+  }
+
+  return {
+    forward: makeTransformFunction(fromLonLat, zone),
+    inverse: makeTransformFunction(toLonLat, zone),
+  };
+}

package/proj.d.ts

@@ -156,12 +156,12 @@ export function equivalent(projection1: Projection, projection2: Projection): bo
  * Searches in the list of transform functions for the function for converting
  * coordinates from the source projection to the destination projection.
  *
- * @param {Projection} sourceProjection Source Projection object.
- * @param {Projection} destinationProjection Destination Projection
+ * @param {Projection} source Source Projection object.
+ * @param {Projection} destination Destination Projection
  *     object.
- * @return {TransformFunction} Transform function.
+ * @return {TransformFunction|null} Transform function.
  */
-export function getTransformFromProjections(sourceProjection: Projection, destinationProjection: Projection): TransformFunction;
+export function getTransformFromProjections(source: Projection, destination: Projection): TransformFunction | null;
 /**
  * Given the projection-like objects, searches for a transformation
  * function to convert a coordinates array from the source projection to the
@@ -175,7 +175,9 @@ export function getTransformFromProjections(sourceProjection: Projection, destin
 export function getTransform(source: ProjectionLike, destination: ProjectionLike): TransformFunction;
 /**
  * Transforms a coordinate from source projection to destination projection.
- * This returns a new coordinate (and does not modify the original).
+ * This returns a new coordinate (and does not modify the original). If there
+ * is no available transform between the two projection, the function will throw
+ * an error.
  *
  * See {@link module:ol/proj.transformExtent} for extent transformation.
  * See the transform method of {@link module:ol/geom/Geometry~Geometry} and its
@@ -308,6 +310,16 @@ export function addCommon(): void;
  * string or undefined.
  */
 export type ProjectionLike = Projection | string | undefined;
+export type Transforms = {
+    /**
+     * The forward transform (from geographic).
+     */
+    forward: TransformFunction;
+    /**
+     * The inverse transform (to geographic).
+     */
+    inverse: TransformFunction;
+};
 /**
  * A transform function accepts an array of input coordinate values, an optional
  * output array, and an optional dimension (default should be 2).  The function