@georeferencing/plugins 0.2.0 → 0.3.0

package/README.md

@@ -20,9 +20,10 @@ pnpm add @georeferencing/react react@19 react-dom@19 ol@10
 The package ships ESM, TypeScript declarations and codec-worker assets. Node.js
 22.12+ is the declared tooling requirement; repository development uses pnpm 12.x.
 **Install the same version of `@georeferencing/plugins`, `@georeferencing/core`
-and (if used) `@georeferencing/react`**, and upgrade them together. Plugins depend
-on core; a mismatched version can install a second copy of core whose projection
-registry and worker code are separate from the controller's. See
+and (if used) `@georeferencing/react`**, and upgrade them together. Plugins declare
+core as a peer dependency and use your application's copy; a mismatched version is
+reported as a peer-dependency conflict rather than installing a second core whose
+projection registry and worker code are separate from the controller's. See
 [keep package versions aligned](https://georeferencing-api-docs.gh.tobilg.com/Getting_started/#keep-package-versions-aligned).
 
 Core alone enables no exports. Import only the factories your application uses.
@@ -80,7 +81,7 @@ its host-owned engine when the session is permanently finished.
 | `geoTiff()` | `/geotiff` | `geotiff` | Georeferenced TIFF; valid fit |
 | `jpeg()` | `/jpeg` | `jpeg` | JPEG, `.jgw`, `.crs.json`; valid fit |
 | `pdf()` | `/pdf` | `pdf` | PDF alignment/map report; valid fit and preview |
-| `worldFile()` | `/data` | `world-file` | Original-resolution normalized PNG, `.pgw`, CRS sidecar; Linear/Helmert without reprojection |
+| `worldFile()` | `/data` | `world-file` | Original-resolution normalized PNG, `.pgw`, CRS sidecar; Linear/Helmert (or also affine with `{ affine: true }`) without reprojection |
 | `session()` | `/data` | `session` | Complete session JSON; fit may be unfinished |
 | `points(definitions?)` | `/data` | `points` | QGIS `.points`; fit may be unfinished |
 | `accuracy()` | `/data` | `accuracy` | Full-precision JSON diagnostics; valid fit |
@@ -188,7 +189,9 @@ partial alpha; choose a value that does not collide with valid RGB data. Deflate
 requires browser CompressionStream support.
 
 This encoder writes classic TIFF below 4 GiB and requires an EPSG code below
-32767. BigTIFF, COG layout, arbitrary-WKT GeoKeys, scientific sample preservation
+32767; EPSG URI/URN aliases are accepted (`geoTiffEpsg` from `/tiff` resolves them).
+The `geoTiff()` format reports an ineligible output CRS or TIFF option before any
+rendering starts. BigTIFF, COG layout, arbitrary-WKT GeoKeys, scientific sample preservation
 and multipage output are outside the supported envelope. See the
 [capabilities and limits](https://github.com/tobilg/georeferencing/blob/main/packages/documentation/guides/capabilities.md)
 for the supported output envelope and QGIS compatibility boundaries.

package/dist/data-export.d.ts

@@ -1,4 +1,5 @@
 import type { Definitions, Exporter } from "@georeferencing/core";
+import type { WorldFileOptions } from "./serializers.js";
 /** @internal */
 export declare const sessionExporter: Exporter;
 /** @internal */
@@ -6,4 +7,4 @@ export declare function pointsExporter(definitions: Definitions): Exporter;
 /** @internal */
 export declare const accuracyExporter: Exporter;
 /** @internal */
-export declare const worldFileExporter: Exporter;
+export declare const worldFileExporter: (options: WorldFileOptions) => Exporter;

package/dist/data-export.js

@@ -29,11 +29,11 @@ export const accuracyExporter = {
     },
 };
 /** @internal */
-export const worldFileExporter = {
+export const worldFileExporter = (options) => ({
     async run({ document, fit, file, engine, tag, signal, onProgress }) {
         if (!fit || !file || !document.sourceImage)
             throw Error("A matching image and fit are required.");
-        const placement = worldFile(fit, document.workingCrs, document.output.crs);
+        const placement = worldFile(fit, document.workingCrs, document.output.crs, options);
         const result = await engine.run({ kind: "normalize", file, metadata: document.sourceImage }, tag, { signal, onProgress });
         signal.throwIfAborted();
         if (!result.blob)
@@ -54,4 +54,4 @@ export const worldFileExporter = {
             ],
         };
     },
-};
+});

package/dist/data.d.ts

@@ -1,13 +1,19 @@
 /**
  * Optional session, QGIS points, world-file and accuracy exports.
- * @module data
+ * @module @georeferencing/plugins/data
+ * @group @georeferencing/plugins
  */
 import type { Definitions, ExportFormat } from "@georeferencing/core";
+import type { WorldFileOptions } from "./serializers.js";
+export type { WorldFileOptions } from "./serializers.js";
 /** Register a complete version-1 JSON session download, even before a valid fit. */
 export declare function session(): ExportFormat;
 /** Register QGIS .points download, projecting targets with the supplied definitions. */
 export declare function points(definitions?: Definitions): ExportFormat;
 /** Register a full-precision JSON alignment report with training residual formulas. */
 export declare function accuracy(): ExportFormat;
-/** Register original-resolution normalized PNG, world file and explicit CRS sidecar. */
-export declare function worldFile(): ExportFormat;
+/**
+ * Register original-resolution normalized PNG, world file and explicit CRS sidecar.
+ * @param options - Set `affine` to also offer world files for Polynomial 1 fits.
+ */
+export declare function worldFile(options?: WorldFileOptions): ExportFormat;

package/dist/data.js

@@ -1,3 +1,5 @@
+import { normalizeCrs } from "@georeferencing/core";
+import { worldFileModels } from "./serializers.js";
 /** Register a complete version-1 JSON session download, even before a valid fit. */
 export function session() {
     return {
@@ -24,15 +26,21 @@ export function accuracy() {
         load: async () => (await import("./data-export.js")).accuracyExporter,
     };
 }
-/** Register original-resolution normalized PNG, world file and explicit CRS sidecar. */
-export function worldFile() {
+/**
+ * Register original-resolution normalized PNG, world file and explicit CRS sidecar.
+ * @param options - Set `affine` to also offer world files for Polynomial 1 fits.
+ */
+export function worldFile(options = {}) {
+    const models = worldFileModels(options);
     return {
         id: "world-file",
         label: "World file & CRS",
-        unavailable: (doc) => ["linear", "helmert"].includes(doc.model) &&
-            doc.workingCrs === doc.output.crs
+        unavailable: (doc) => models.includes(doc.model) &&
+            normalizeCrs(doc.workingCrs) === normalizeCrs(doc.output.crs)
             ? null
-            : "World-file output requires Linear/Helmert without reprojection.",
-        load: async () => (await import("./data-export.js")).worldFileExporter,
+            : options.affine
+                ? "World-file output requires a Linear, Helmert or affine fit without reprojection."
+                : "World-file output requires Linear/Helmert without reprojection.",
+        load: async () => (await import("./data-export.js")).worldFileExporter(options),
     };
 }

package/dist/geotiff.d.ts

@@ -1,6 +1,7 @@
 /**
  * Optional GeoTIFF export; import from `@georeferencing/plugins/geotiff`.
- * @module geotiff
+ * @module @georeferencing/plugins/geotiff
+ * @group @georeferencing/plugins
  */
 import type { ExportFormat } from "@georeferencing/core";
 import type { RasterPluginOptions } from "./types.js";

package/dist/geotiff.js

@@ -1,3 +1,4 @@
+import { geoTiffUnavailable } from "./tiff-options.js";
 /**
  * Register lazy GeoTIFF export. Encoding runs in a dedicated plugin worker using
  * the controller engine's limits, projections, scheduler and cancellation.
@@ -8,6 +9,7 @@ export function geoTiff(options = {}) {
         id: "geotiff",
         label: "Export GeoTIFF",
         raster: true,
+        unavailable: (document) => geoTiffUnavailable(document.output),
         load: async () => {
             const { renderAndEncode } = await import("./raster-export.js");
             return {

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 /**
  * Optional lazy export formats. Prefer per-format imports to give bundlers the
  * narrowest dependency graph. Register descriptors with ControllerOptions.exports.
- * @module plugins
+ * @module @georeferencing/plugins
+ * @group @georeferencing/plugins
  */
+export type { WorldFileOptions } from "./data.js";
 export { accuracy, points, session, worldFile } from "./data.js";
 export { geoTiff } from "./geotiff.js";
 export { jpeg } from "./jpeg.js";

package/dist/index.js

@@ -1,7 +1,8 @@
 /**
  * Optional lazy export formats. Prefer per-format imports to give bundlers the
  * narrowest dependency graph. Register descriptors with ControllerOptions.exports.
- * @module plugins
+ * @module @georeferencing/plugins
+ * @group @georeferencing/plugins
  */
 export { accuracy, points, session, worldFile } from "./data.js";
 export { geoTiff } from "./geotiff.js";

package/dist/jpeg.d.ts

@@ -1,6 +1,7 @@
 /**
  * Optional georeferenced JPEG export; import from `@georeferencing/plugins/jpeg`.
- * @module jpeg
+ * @module @georeferencing/plugins/jpeg
+ * @group @georeferencing/plugins
  */
 import type { ExportFormat } from "@georeferencing/core";
 import type { JpegOptions } from "./types.js";

package/dist/pdf.d.ts

@@ -1,6 +1,7 @@
 /**
  * Optional PDF report; import from `@georeferencing/plugins/pdf`.
- * @module pdf
+ * @module @georeferencing/plugins/pdf
+ * @group @georeferencing/plugins
  */
 import type { ExportFormat } from "@georeferencing/core";
 import type { ReportMap, ReportOptions } from "./report.js";

package/dist/report.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Low-level PDF report creation and optional OpenLayers map capture; pdf-lib loads lazily.
+ * Import from `@georeferencing/plugins/report`.
+ * @module @georeferencing/plugins/report
+ * @group @georeferencing/plugins
+ */
 import type { Definitions, Document, Fit } from "@georeferencing/core";
 import type { Raster } from "@georeferencing/core/engine";
 /** Minimal view contract needed to annotate a captured map; OpenLayers View satisfies it. */
@@ -64,7 +70,7 @@ export interface ReportOptions {
  *
  * Calls renderSync and copies available canvas content; does not await outstanding tiles or capture arbitrary DOM overlays. WebGL/non-canvas renderers are outside this capture contract.
  * @param map - Visible initialized host map.
- * @throws {@link core.GeoreferenceError} If the viewport is unavailable or a source taints canvas export.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} If the viewport is unavailable or a source taints canvas export.
  */
 export declare function captureMap(map: ReportMap): Promise<Blob>;
 /**

package/dist/report.js

@@ -15,7 +15,7 @@ async function png(canvas) {
  *
  * Calls renderSync and copies available canvas content; does not await outstanding tiles or capture arbitrary DOM overlays. WebGL/non-canvas renderers are outside this capture contract.
  * @param map - Visible initialized host map.
- * @throws {@link core.GeoreferenceError} If the viewport is unavailable or a source taints canvas export.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} If the viewport is unavailable or a source taints canvas export.
  */
 export async function captureMap(map) {
     map.renderSync();
@@ -99,8 +99,14 @@ export async function createPdfReport(doc, fit, raster, options = {}) {
         page = pdf.addPage([pageWidth, pageHeight]);
         y = pageHeight - margin;
     };
+    // Standard fonts use WinAnsi: keep every encodable character (such as umlauts and
+    // accents) and replace the rest; the attached JSON retains the full Unicode text.
+    const encodable = new Set(font.getCharacterSet());
     const text = (value, size = 10, fixed = false) => {
-        const safe = value.replace(/[^\x20-\x7e]/g, "?"), width = Math.max(1, Math.floor(contentWidth / (size * (fixed ? 0.6 : 0.55))));
+        const safe = Array.from(value.normalize("NFC"), (character) => {
+            const code = character.codePointAt(0);
+            return code >= 0x20 && encodable.has(code) ? character : "?";
+        }).join(""), width = Math.max(1, Math.floor(contentWidth / (size * (fixed ? 0.6 : 0.55))));
         for (let i = 0; i < safe.length || i === 0; i += width) {
             if (y < margin + size)
                 newPage();

package/dist/serializers.d.ts

@@ -1,7 +1,8 @@
 /**
  * Pure serializers for QGIS points, world files and alignment accuracy reports.
  * Import from `@georeferencing/plugins/serializers`; no workers or UI are loaded.
- * @module serializers
+ * @module @georeferencing/plugins/serializers
+ * @group @georeferencing/plugins
  */
 import type { Definitions, Document, Fit } from "@georeferencing/core";
 /**
@@ -10,13 +11,26 @@ import type { Definitions, Document, Fit } from "@georeferencing/core";
  * Residual columns are placeholders set to zero; use `accuracyReport` for actual diagnostics. IDs and snap provenance are not represented by this format.
  */
 export declare function exportPoints(doc: Document, definitions?: Definitions): string;
+/** Options for world-file placement. */
+export interface WorldFileOptions {
+    /**
+     * Also accept Polynomial 1 (affine) fits. A world file represents any affine transform
+     * exactly, including rotation and shear; QGIS offers world files only for Linear and
+     * Helmert, so this is opt-in.
+     * @defaultValue `false`
+     */
+    affine?: boolean;
+}
+/** Models a world file can represent with the given options. @internal */
+export declare function worldFileModels(options?: WorldFileOptions): string[];
 /**
- * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits without reprojection.
+ * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits (and optionally affine fits) without reprojection.
  *
  * Line order is A, D, B, E, C, F. The final two values locate the first pixel centre, `[0.5, 0.5]`. A world file alone contains no CRS.
- * @throws {@link core.GeoreferenceError} For ineligible models or different working/output CRSs.
+ * @param options - Set `affine` to also accept Polynomial 1 fits.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} For ineligible models or different working/output CRSs.
  */
-export declare function worldFile(fit: Fit, workingCrs: string, outputCrs: string): {
+export declare function worldFile(fit: Fit, workingCrs: string, outputCrs: string, options?: WorldFileOptions): {
     /**
      * Six newline-separated values in A, D, B, E, C, F order, including the pixel-centre
      * offset.

package/dist/serializers.js

@@ -1,4 +1,4 @@
-import { ENGINE_VERSION, fail, forward, project } from "@georeferencing/core";
+import { ENGINE_VERSION, fail, forward, normalizeCrs, project, } from "@georeferencing/core";
 /**
  * Export a QGIS-compatible `.points` text file. Targets are projected into the document working CRS; canonical image y is negated to QGIS source y-up coordinates.
  *
@@ -19,15 +19,25 @@ export function exportPoints(doc, definitions = {}) {
             .join("\n") +
         "\n");
 }
+/** Models a world file can represent with the given options. @internal */
+export function worldFileModels(options = {}) {
+    return options.affine
+        ? ["linear", "helmert", "polynomial1"]
+        : ["linear", "helmert"];
+}
 /**
- * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits without reprojection.
+ * Create a six-line world file plus an explicit CRS sidecar value for Linear or Helmert fits (and optionally affine fits) without reprojection.
  *
  * Line order is A, D, B, E, C, F. The final two values locate the first pixel centre, `[0.5, 0.5]`. A world file alone contains no CRS.
- * @throws {@link core.GeoreferenceError} For ineligible models or different working/output CRSs.
+ * @param options - Set `affine` to also accept Polynomial 1 fits.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} For ineligible models or different working/output CRSs.
  */
-export function worldFile(fit, workingCrs, outputCrs) {
-    if (!["linear", "helmert"].includes(fit.model) || workingCrs !== outputCrs)
-        fail("WORLD_FILE", "World-file-only output requires Linear/Helmert without reprojection.");
+export function worldFile(fit, workingCrs, outputCrs, options = {}) {
+    if (!worldFileModels(options).includes(fit.model) ||
+        normalizeCrs(workingCrs) !== normalizeCrs(outputCrs))
+        fail("WORLD_FILE", options.affine
+            ? "World-file-only output requires a Linear, Helmert or affine fit without reprojection."
+            : "World-file-only output requires Linear/Helmert without reprojection.");
     const a = forward(fit, [0, 0]), b = forward(fit, [1, 0]), c = forward(fit, [0, 1]), center = forward(fit, [0.5, 0.5]);
     return {
         /**

package/dist/tiff-options.d.ts

@@ -0,0 +1,27 @@
+import type { OutputSettings } from "@georeferencing/core";
+/**
+ * Supported TIFF strip creation and no-data options, shared with raster output settings.
+ */
+export type TiffOptions = Pick<OutputSettings, "compression" | "noData" | "rowsPerStrip" | "predictor">;
+/** TIFF compression tag values by setting. @internal */
+export declare const compressionCodes: {
+    none: number;
+    deflate: number;
+    packbits: number;
+};
+/**
+ * Return the GeoTIFF EPSG code for a CRS identifier, accepting EPSG URI/URN aliases, or
+ * null when the CRS cannot be written as a GeoKey (custom WKT or codes from 32767).
+ */
+export declare function geoTiffEpsg(crs: string): number | null;
+/**
+ * Validate byte no-data, strip height, compression and predictor compatibility before
+ * encoding.
+ */
+export declare function validateTiffOptions(options: TiffOptions): void;
+/**
+ * Explain why GeoTIFF output is unavailable for these settings, or return null. Runs
+ * before rendering, so ineligible settings never cost a full-resolution render.
+ * @internal
+ */
+export declare function geoTiffUnavailable(output: OutputSettings): string | null;

package/dist/tiff-options.js

@@ -0,0 +1,48 @@
+import { fail, normalizeCrs } from "@georeferencing/core";
+/** TIFF compression tag values by setting. @internal */
+export const compressionCodes = { none: 1, deflate: 8, packbits: 32773 };
+/**
+ * Return the GeoTIFF EPSG code for a CRS identifier, accepting EPSG URI/URN aliases, or
+ * null when the CRS cannot be written as a GeoKey (custom WKT or codes from 32767).
+ */
+export function geoTiffEpsg(crs) {
+    const code = Number(/^EPSG:(\d+)$/.exec(normalizeCrs(crs))?.[1]);
+    return code > 0 && code < 32767 ? code : null;
+}
+/**
+ * Validate byte no-data, strip height, compression and predictor compatibility before
+ * encoding.
+ */
+export function validateTiffOptions(options) {
+    if (!Object.hasOwn(compressionCodes, options.compression ?? "none"))
+        fail("OUTPUT", "Unsupported TIFF compression.");
+    if (options.noData !== undefined &&
+        (!Number.isInteger(options.noData) ||
+            options.noData < 0 ||
+            options.noData > 255))
+        fail("NODATA", "Byte-image no-data must be an integer from 0 to 255.");
+    if (options.rowsPerStrip !== undefined &&
+        (!Number.isInteger(options.rowsPerStrip) ||
+            options.rowsPerStrip < 1 ||
+            options.rowsPerStrip > 4096))
+        fail("OUTPUT", "Rows per strip must be an integer from 1 to 4096.");
+    if (![1, 2].includes(options.predictor ?? 1) ||
+        (options.predictor === 2 && options.compression !== "deflate"))
+        fail("OUTPUT", "Horizontal prediction requires Deflate compression.");
+}
+/**
+ * Explain why GeoTIFF output is unavailable for these settings, or return null. Runs
+ * before rendering, so ineligible settings never cost a full-resolution render.
+ * @internal
+ */
+export function geoTiffUnavailable(output) {
+    if (!geoTiffEpsg(output.crs))
+        return "GeoTIFF output requires an EPSG output CRS with a code below 32767.";
+    try {
+        validateTiffOptions(output);
+        return null;
+    }
+    catch (error) {
+        return error.message;
+    }
+}

package/dist/tiff.d.ts

@@ -1,13 +1,13 @@
-import type { Extent, OutputSettings } from "@georeferencing/core";
-/**
- * Supported TIFF strip creation and no-data options, shared with raster output settings.
- */
-export type TiffOptions = Pick<OutputSettings, "compression" | "noData" | "rowsPerStrip" | "predictor">;
 /**
- * Validate byte no-data, strip height, compression and predictor compatibility before
- * encoding.
+ * Low-level GeoTIFF encoding and TIFF creation-option validation, used by the GeoTIFF worker.
+ * Import from `@georeferencing/plugins/tiff`.
+ * @module @georeferencing/plugins/tiff
+ * @group @georeferencing/plugins
  */
-export declare function validateTiffOptions(options: TiffOptions): void;
+import type { Extent, OutputSettings } from "@georeferencing/core";
+import type { TiffOptions } from "./tiff-options.js";
+export type { TiffOptions } from "./tiff-options.js";
+export { geoTiffEpsg, validateTiffOptions } from "./tiff-options.js";
 /**
  * Encode an uncompressed north-up RGBA GeoTIFF synchronously using PixelIsArea. Allocates a complete ArrayBuffer; prefer encodeGeoTiffBlob for bounded-strip encoding.
  * @param data - Row-major 8-bit RGBA with unassociated alpha.
@@ -29,7 +29,7 @@ export declare function encodeGeoTiff(data: Uint8ClampedArray, width: number, he
  * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
  * @param options - Compression, strip height, predictor and optional RGB no-data.
  * @param progress - Encoding progress fraction per completed strip.
- * @throws {@link core.GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
  */
 export declare function encodeGeoTiffBlob(data: Uint8ClampedArray, width: number, height: number, bounds: Extent, crs: string, geographic: boolean, options?: TiffOptions, progress?: (value: number) => void): Promise<Blob>;
 /**

package/dist/tiff.js

@@ -1,26 +1,6 @@
 import { fail } from "@georeferencing/core";
-const compressionCodes = { none: 1, deflate: 8, packbits: 32773 };
-/**
- * Validate byte no-data, strip height, compression and predictor compatibility before
- * encoding.
- */
-export function validateTiffOptions(options) {
-    if (!Object.hasOwn(compressionCodes, options.compression ?? "none"))
-        fail("OUTPUT", "Unsupported TIFF compression.");
-    if (options.noData !== undefined &&
-        (!Number.isInteger(options.noData) ||
-            options.noData < 0 ||
-            options.noData > 255))
-        fail("NODATA", "Byte-image no-data must be an integer from 0 to 255.");
-    if (options.rowsPerStrip !== undefined &&
-        (!Number.isInteger(options.rowsPerStrip) ||
-            options.rowsPerStrip < 1 ||
-            options.rowsPerStrip > 4096))
-        fail("OUTPUT", "Rows per strip must be an integer from 1 to 4096.");
-    if (![1, 2].includes(options.predictor ?? 1) ||
-        (options.predictor === 2 && options.compression !== "deflate"))
-        fail("OUTPUT", "Horizontal prediction requires Deflate compression.");
-}
+import { compressionCodes, geoTiffEpsg, validateTiffOptions, } from "./tiff-options.js";
+export { geoTiffEpsg, validateTiffOptions } from "./tiff-options.js";
 function check(data, width, height, bounds) {
     if (!Number.isSafeInteger(width) ||
         !Number.isSafeInteger(height) ||
@@ -61,7 +41,7 @@ export function encodeGeoTiff(data, width, height, bounds, crs, geographic) {
  * @param geographic - True for geographic CRS GeoKeys, false for projected CRS GeoKeys; must agree with crs.
  * @param options - Compression, strip height, predictor and optional RGB no-data.
  * @param progress - Encoding progress fraction per completed strip.
- * @throws {@link core.GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
+ * @throws {@link "@georeferencing/core".GeoreferenceError} For invalid layouts/settings, unavailable Deflate or partial transparency with numeric no-data.
  */
 export async function encodeGeoTiffBlob(data, width, height, bounds, crs, geographic, options = {}, progress) {
     check(data, width, height, bounds);
@@ -152,8 +132,8 @@ function packBits(data) {
  * and strip offsets. Rejects offsets reaching the 4 GiB classic-TIFF limit.
  */
 function tiffHeader(width, height, bounds, crs, geographic, options, lengths, rows, channels) {
-    const epsg = Number(/^EPSG:(\d+)$/.exec(crs)?.[1]);
-    if (!epsg || epsg >= 32767)
+    const epsg = geoTiffEpsg(crs);
+    if (!epsg)
         fail("CRS", "GeoTIFF requires an EPSG code below 32767 with a registered definition.");
     const keys = [
         1,