@math.gl/geospatial 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/tile-matrix.cjs

@@ -0,0 +1,235 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/tile-matrix.js
+var tile_matrix_exports = {};
+__export(tile_matrix_exports, {
+  getTileBounds: () => getTileBounds,
+  getTileIndex: () => getTileIndex,
+  getTileRange: () => getTileRange,
+  getTileRanges: () => getTileRanges,
+  isTileIndexInRange: () => isTileIndexInRange,
+  selectTileMatrix: () => selectTileMatrix,
+  validateTileMatrix: () => validateTileMatrix
+});
+module.exports = __toCommonJS(tile_matrix_exports);
+function validateTileMatrix(matrix) {
+  validateTileMatrixGeometry(matrix);
+}
+function validateTileMatrixGeometry(matrix) {
+  if (typeof matrix.id !== "string" || !matrix.id || matrix.origin.length !== 2 || matrix.tileSize.length !== 2 || matrix.matrixSize.length !== 2 || !Number.isFinite(matrix.resolution) || matrix.resolution <= 0 || matrix.resolutionY !== void 0 && (!Number.isFinite(matrix.resolutionY) || matrix.resolutionY <= 0) || !matrix.origin.every(Number.isFinite) || ![...matrix.tileSize, ...matrix.matrixSize].every((value) => Number.isSafeInteger(value) && value > 0) || !["topLeft", "bottomLeft"].includes(matrix.cornerOfOrigin)) {
+    throw new RangeError("Invalid tile matrix geometry");
+  }
+  const bands = [...matrix.variableMatrixWidths ?? []].sort((first, second) => first.minTileRow - second.minTileRow);
+  let previousRow = -1;
+  for (const band of bands) {
+    if (!Number.isSafeInteger(band.coalesce) || band.coalesce <= 1 || matrix.matrixSize[0] % band.coalesce !== 0 || !Number.isSafeInteger(band.minTileRow) || !Number.isSafeInteger(band.maxTileRow) || band.minTileRow <= previousRow || band.maxTileRow < band.minTileRow || band.maxTileRow >= matrix.matrixSize[1])
+      throw new RangeError("Invalid variable matrix width");
+    previousRow = band.maxTileRow;
+  }
+  for (let axis = 0; axis < 2; axis++) {
+    const resolution = axis === 1 ? matrix.resolutionY ?? matrix.resolution : matrix.resolution;
+    const tileSpan = resolution * matrix.tileSize[axis];
+    const span = tileSpan * matrix.matrixSize[axis];
+    const direction = axis === 1 && matrix.cornerOfOrigin === "topLeft" ? -1 : 1;
+    const end = matrix.origin[axis] + direction * span;
+    if (!Number.isFinite(span) || span <= 0 || !Number.isFinite(end) || matrix.origin[axis] + direction * tileSpan === matrix.origin[axis] || end - direction * tileSpan === end) {
+      throw new RangeError("Tile matrix extent must be finite");
+    }
+  }
+  return bands;
+}
+function isTileIndexInRange(matrix, column, row, limits) {
+  validateTileMatrix(matrix);
+  if (limits)
+    validateTileMatrixLimits(matrix, limits);
+  return Number.isSafeInteger(column) && Number.isSafeInteger(row) && column >= 0 && row >= 0 && column < matrix.matrixSize[0] && row < matrix.matrixSize[1] && (!limits || column >= limits.minTileColumn && column <= limits.maxTileColumn && row >= limits.minTileRow && row <= limits.maxTileRow);
+}
+function getTileBounds(matrix, column, row) {
+  if (!isTileIndexInRange(matrix, column, row))
+    throw new RangeError("Tile index outside matrix");
+  const width = matrix.resolution * matrix.tileSize[0];
+  const height = (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1];
+  const coalesce = getRowCoalesce(matrix, row);
+  const canonicalColumn = Math.floor(column / coalesce) * coalesce;
+  const minimumX = matrix.origin[0] + canonicalColumn * width;
+  const minimumY = matrix.cornerOfOrigin === "topLeft" ? matrix.origin[1] - (row + 1) * height : matrix.origin[1] + row * height;
+  return [
+    minimumX,
+    minimumY,
+    matrix.origin[0] + (canonicalColumn + coalesce) * width,
+    matrix.cornerOfOrigin === "topLeft" ? matrix.origin[1] - row * height : matrix.origin[1] + (row + 1) * height
+  ];
+}
+function getTileIndex(matrix, coordinate) {
+  validateTileMatrix(matrix);
+  if (!coordinate.every(Number.isFinite))
+    return null;
+  const row = getTileAxisIndex(matrix.origin[1], matrix.cornerOfOrigin === "topLeft" ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], coordinate[1]);
+  if (row === null)
+    return null;
+  const coalesce = getRowCoalesce(matrix, row);
+  const column = getTileAxisIndex(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], coordinate[0], coalesce);
+  return column === null ? null : [column, row];
+}
+function getTileAxisIndex(origin, direction, tileSpan, matrixSize, coordinate, columnStep = 1) {
+  const end = origin + direction * (matrixSize * tileSpan);
+  if (direction === 1 ? coordinate < origin || coordinate >= end : coordinate > origin || coordinate <= end) {
+    return null;
+  }
+  return (findTileAxisBoundary(origin, direction, tileSpan, matrixSize, coordinate, false, columnStep) - 1) * columnStep;
+}
+function findTileAxisBoundary(origin, direction, tileSpan, matrixSize, coordinate, includeEqualEdge, columnStep = 1) {
+  let lower = 0;
+  let upper = matrixSize / columnStep;
+  while (lower < upper) {
+    const middle = lower + Math.floor((upper - lower) / 2);
+    const edge = origin + direction * (middle * columnStep * tileSpan);
+    const precedesCoordinate = direction === 1 ? includeEqualEdge ? edge < coordinate : edge <= coordinate : includeEqualEdge ? edge > coordinate : edge >= coordinate;
+    if (precedesCoordinate)
+      lower = middle + 1;
+    else
+      upper = middle;
+  }
+  return lower;
+}
+function validateTileMatrixLimits(matrix, limits) {
+  const values = [limits.minTileColumn, limits.maxTileColumn, limits.minTileRow, limits.maxTileRow];
+  if (!values.every((value) => Number.isSafeInteger(value) && value >= 0) || limits.minTileColumn > limits.maxTileColumn || limits.minTileRow > limits.maxTileRow || limits.maxTileColumn >= matrix.matrixSize[0] || limits.maxTileRow >= matrix.matrixSize[1]) {
+    throw new RangeError("Invalid tile matrix limits");
+  }
+}
+function getRegularTileRange(matrix, bounds, limits) {
+  validateTileQueryBounds(bounds);
+  const columns = getTileAxisRange(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], bounds[0], bounds[2]);
+  const topLeft = matrix.cornerOfOrigin === "topLeft";
+  const rows = getTileAxisRange(matrix.origin[1], topLeft ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], topLeft ? bounds[3] : bounds[1], topLeft ? bounds[1] : bounds[3]);
+  if (!columns || !rows)
+    return null;
+  const range = {
+    minTileColumn: Math.max(columns[0], (limits == null ? void 0 : limits.minTileColumn) ?? 0),
+    maxTileColumn: Math.min(columns[1], (limits == null ? void 0 : limits.maxTileColumn) ?? matrix.matrixSize[0] - 1),
+    minTileRow: Math.max(rows[0], (limits == null ? void 0 : limits.minTileRow) ?? 0),
+    maxTileRow: Math.min(rows[1], (limits == null ? void 0 : limits.maxTileRow) ?? matrix.matrixSize[1] - 1)
+  };
+  return range.minTileColumn > range.maxTileColumn || range.minTileRow > range.maxTileRow ? null : range;
+}
+function validateTileQueryBounds(bounds) {
+  if (bounds.length !== 4 || !bounds.every(Number.isFinite) || bounds[0] > bounds[2] || bounds[1] > bounds[3]) {
+    throw new RangeError("Tile query bounds must be finite and ordered");
+  }
+}
+function getTileRange(matrix, bounds, limits) {
+  var _a;
+  validateTileMatrix(matrix);
+  if ((_a = matrix.variableMatrixWidths) == null ? void 0 : _a.length) {
+    throw new RangeError("Use getTileRanges for variable-width matrices");
+  }
+  if (limits)
+    validateTileMatrixLimits(matrix, limits);
+  return getRegularTileRange(matrix, bounds, limits);
+}
+function getRowCoalesce(matrix, row) {
+  var _a, _b;
+  return ((_b = (_a = matrix.variableMatrixWidths) == null ? void 0 : _a.find((band) => row >= band.minTileRow && row <= band.maxTileRow)) == null ? void 0 : _b.coalesce) ?? 1;
+}
+function getTileRanges(matrix, bounds, limits) {
+  const declaredBands = validateTileMatrixGeometry(matrix);
+  if (limits)
+    validateTileMatrixLimits(matrix, limits);
+  validateTileQueryBounds(bounds);
+  const bands = [];
+  let nextRow = 0;
+  for (const band of declaredBands) {
+    if (nextRow < band.minTileRow) {
+      bands.push({ coalesce: 1, minTileRow: nextRow, maxTileRow: band.minTileRow - 1 });
+    }
+    bands.push(band);
+    nextRow = band.maxTileRow + 1;
+  }
+  if (nextRow < matrix.matrixSize[1]) {
+    bands.push({ coalesce: 1, minTileRow: nextRow, maxTileRow: matrix.matrixSize[1] - 1 });
+  }
+  const topLeft = matrix.cornerOfOrigin === "topLeft";
+  const rows = getTileAxisRange(matrix.origin[1], topLeft ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], topLeft ? bounds[3] : bounds[1], topLeft ? bounds[1] : bounds[3]);
+  if (!rows)
+    return [];
+  const ranges = [];
+  for (const band of bands) {
+    const minimumRow = Math.max(band.minTileRow, rows[0], (limits == null ? void 0 : limits.minTileRow) ?? 0);
+    const maximumRow = Math.min(band.maxTileRow, rows[1], (limits == null ? void 0 : limits.maxTileRow) ?? matrix.matrixSize[1] - 1);
+    if (minimumRow > maximumRow)
+      continue;
+    const columns = getTileAxisRange(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], bounds[0], bounds[2], band.coalesce);
+    if (!columns)
+      continue;
+    const minimumColumn = Math.max(columns[0], Math.floor(((limits == null ? void 0 : limits.minTileColumn) ?? 0) / band.coalesce) * band.coalesce);
+    const maximumColumn = Math.min(columns[1], Math.floor(((limits == null ? void 0 : limits.maxTileColumn) ?? matrix.matrixSize[0] - 1) / band.coalesce) * band.coalesce);
+    if (minimumColumn <= maximumColumn)
+      ranges.push({
+        minTileColumn: minimumColumn,
+        maxTileColumn: maximumColumn,
+        minTileRow: minimumRow,
+        maxTileRow: maximumRow,
+        columnStep: band.coalesce
+      });
+  }
+  return ranges;
+}
+function getTileAxisRange(origin, direction, tileSpan, matrixSize, start, end, columnStep = 1) {
+  if (start === end) {
+    const index = getTileAxisIndex(origin, direction, tileSpan, matrixSize, start, columnStep);
+    return index === null ? null : [index, index];
+  }
+  const matrixEnd = origin + direction * (matrixSize * tileSpan);
+  const clippedStart = direction === 1 ? Math.max(start, origin) : Math.min(start, origin);
+  const clippedEnd = direction === 1 ? Math.min(end, matrixEnd) : Math.max(end, matrixEnd);
+  if (direction === 1 ? clippedStart >= clippedEnd : clippedStart <= clippedEnd)
+    return null;
+  return [
+    (findTileAxisBoundary(origin, direction, tileSpan, matrixSize, clippedStart, false, columnStep) - 1) * columnStep,
+    (findTileAxisBoundary(origin, direction, tileSpan, matrixSize, clippedEnd, true, columnStep) - 1) * columnStep
+  ];
+}
+function selectTileMatrix(matrixSet, targetResolution) {
+  if (!Number.isFinite(targetResolution) || targetResolution <= 0) {
+    throw new RangeError("Target resolution must be positive and finite");
+  }
+  let selected = null;
+  let finest = null;
+  let selectedResolution = -Infinity;
+  let finestResolution = Infinity;
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const matrix of matrixSet.matrices) {
+    validateTileMatrix(matrix);
+    if (identifiers.has(matrix.id))
+      throw new RangeError("Tile matrix identifiers must be unique");
+    identifiers.add(matrix.id);
+    const resolution = Math.max(matrix.resolution, matrix.resolutionY ?? matrix.resolution);
+    if (!finest || resolution < finestResolution) {
+      finest = matrix;
+      finestResolution = resolution;
+    }
+    if (resolution <= targetResolution && (!selected || resolution > selectedResolution)) {
+      selected = matrix;
+      selectedResolution = resolution;
+    }
+  }
+  return selected ?? finest;
+}
+//# sourceMappingURL=tile-matrix.cjs.map

package/dist/tile-matrix.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/tile-matrix.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/tile-matrix.d.ts

@@ -0,0 +1,87 @@
+/** Bounds in the matrix coordinate system: minimum X/Y followed by maximum X/Y. */
+export type TileMatrixBounds = readonly [number, number, number, number];
+/** Coalescence of contiguous base-grid columns over an inclusive band of rows. */
+export type VariableMatrixWidth = {
+    /** Number of base columns per tile; an integer greater than one dividing matrix width. */
+    readonly coalesce: number;
+    /** First row in this band, in the matrix's native row direction. */
+    readonly minTileRow: number;
+    /** Last row in this band, inclusive. */
+    readonly maxTileRow: number;
+};
+/** A rectangular tile grid at one resolution, independent of service protocols. */
+export type TileMatrix = {
+    /** Opaque identifier; it is not a numeric zoom or array index. */
+    readonly id: string;
+    /** X coordinate units per pixel, positive and finite; also used for Y unless overridden. */
+    readonly resolution: number;
+    /** Y coordinate units per pixel, positive and finite; defaults to resolution. */
+    readonly resolutionY?: number;
+    /** Origin in X/Y order in the matrix coordinate system. */
+    readonly origin: readonly [number, number];
+    /** Origin corner; columns increase in X, rows decrease/increase in Y for top/bottom left. */
+    readonly cornerOfOrigin: 'topLeft' | 'bottomLeft';
+    /** Positive integer tile width and height in pixels. */
+    readonly tileSize: readonly [number, number];
+    /** Positive integer base-grid width and height in tiles, before coalescence. */
+    readonly matrixSize: readonly [number, number];
+    /** Optional disjoint row bands; omitted rows have coalescence one. Order is immaterial. */
+    readonly variableMatrixWidths?: readonly VariableMatrixWidth[];
+};
+/** Matrices sharing a coordinate system; no ordering or quadtree relationship is assumed. */
+export type TileMatrixSet = {
+    /** Opaque coordinate-system identifier. Utilities do not transform coordinates. */
+    readonly crs: string;
+    /** Matrices with unique identifiers. */
+    readonly matrices: readonly TileMatrix[];
+};
+/** Inclusive column and row limits for a rectangular subset of a matrix. */
+export type TileMatrixLimits = {
+    /** First available column. */
+    readonly minTileColumn: number;
+    /** Last available column. */
+    readonly maxTileColumn: number;
+    /** First available row. */
+    readonly minTileRow: number;
+    /** Last available row. */
+    readonly maxTileRow: number;
+};
+/** An exact row-band range of canonical columns, enumerated using columnStep. */
+export type TileMatrixRowRange = TileMatrixLimits & {
+    /** Increment between canonical columns; rows increment by one. */
+    readonly columnStep: number;
+};
+/** Rejects malformed or numerically unrepresentable matrix geometry. */
+export declare function validateTileMatrix(matrix: TileMatrix): void;
+/** Tests integer indices against the matrix and optional inclusive coverage limits. Does not wrap. */
+export declare function isTileIndexInRange(matrix: TileMatrix, column: number, row: number, limits?: TileMatrixLimits): boolean;
+/** Returns the entire tile footprint, including column aliases. Throws for out-of-range indices. */
+export declare function getTileBounds(matrix: TileMatrix, column: number, row: number): TileMatrixBounds;
+/**
+ * Finds the containing tile without clamping or wrapping. Tile intervals are half-open in column
+ * and row direction: the origin edge belongs to the matrix, the opposite outer edge does not.
+ * Returns a canonical column for coalesced rows, or null for nonfinite/outside coordinates.
+ */
+export declare function getTileIndex(matrix: TileMatrix, coordinate: readonly [number, number]): [number, number] | null;
+/**
+ * Returns a rectangular range for a regular matrix. Variable-width matrices require getTileRanges
+ * so callers cannot accidentally enumerate aliases as separate tiles.
+ */
+export declare function getTileRange(matrix: TileMatrix, bounds: TileMatrixBounds, limits?: TileMatrixLimits): TileMatrixLimits | null;
+/**
+ * Returns exact canonical-column ranges, ordered by native row, split at coalescence changes.
+ * Columns advance by columnStep, rows by one. Limits use base-grid indices: a tile is included
+ * when any of its aliases falls within those limits. Canonical columns may precede minTileColumn.
+ * Work and output scale with row bands rather than the number of tiles or rows.
+ */
+export declare function getTileRanges(matrix: TileMatrix, bounds: TileMatrixBounds, limits?: TileMatrixLimits): TileMatrixRowRange[];
+/**
+ * Selects the coarsest matrix with resolution at or below the positive finite target, or the
+ * finest available matrix when all levels are coarser. Target units must match the matrix set's
+ * coordinate units per pixel. Returns null for an empty set; ties retain the first matrix.
+ * Uses nominal uncoalesced resolution; selection is independent of row.
+ * Uses the larger axis resolution for anisotropic pixels, so both axes meet the target.
+ * Validates every matrix and unique identifiers. Does not sort or mutate the set.
+ */
+export declare function selectTileMatrix(matrixSet: TileMatrixSet, targetResolution: number): TileMatrix | null;
+//# sourceMappingURL=tile-matrix.d.ts.map

package/dist/tile-matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-matrix.d.ts","sourceRoot":"","sources":["../src/tile-matrix.ts"],"names":[],"mappings":"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"}

package/dist/tile-matrix.js

@@ -0,0 +1,307 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Rejects malformed or numerically unrepresentable matrix geometry. */
+export function validateTileMatrix(matrix) {
+    validateTileMatrixGeometry(matrix);
+}
+/** Validates geometry and returns a sorted copy of the declared coalescence bands. */
+function validateTileMatrixGeometry(matrix) {
+    if (typeof matrix.id !== 'string' ||
+        !matrix.id ||
+        matrix.origin.length !== 2 ||
+        matrix.tileSize.length !== 2 ||
+        matrix.matrixSize.length !== 2 ||
+        !Number.isFinite(matrix.resolution) ||
+        matrix.resolution <= 0 ||
+        (matrix.resolutionY !== undefined &&
+            (!Number.isFinite(matrix.resolutionY) || matrix.resolutionY <= 0)) ||
+        !matrix.origin.every(Number.isFinite) ||
+        ![...matrix.tileSize, ...matrix.matrixSize].every(value => Number.isSafeInteger(value) && value > 0) ||
+        !['topLeft', 'bottomLeft'].includes(matrix.cornerOfOrigin)) {
+        throw new RangeError('Invalid tile matrix geometry');
+    }
+    const bands = [...(matrix.variableMatrixWidths ?? [])].sort((first, second) => first.minTileRow - second.minTileRow);
+    let previousRow = -1;
+    for (const band of bands) {
+        if (!Number.isSafeInteger(band.coalesce) ||
+            band.coalesce <= 1 ||
+            matrix.matrixSize[0] % band.coalesce !== 0 ||
+            !Number.isSafeInteger(band.minTileRow) ||
+            !Number.isSafeInteger(band.maxTileRow) ||
+            band.minTileRow <= previousRow ||
+            band.maxTileRow < band.minTileRow ||
+            band.maxTileRow >= matrix.matrixSize[1])
+            throw new RangeError('Invalid variable matrix width');
+        previousRow = band.maxTileRow;
+    }
+    for (let axis = 0; axis < 2; axis++) {
+        const resolution = axis === 1 ? (matrix.resolutionY ?? matrix.resolution) : matrix.resolution;
+        const tileSpan = resolution * matrix.tileSize[axis];
+        const span = tileSpan * matrix.matrixSize[axis];
+        const direction = axis === 1 && matrix.cornerOfOrigin === 'topLeft' ? -1 : 1;
+        const end = matrix.origin[axis] + direction * span;
+        if (!Number.isFinite(span) ||
+            span <= 0 ||
+            !Number.isFinite(end) ||
+            matrix.origin[axis] + direction * tileSpan === matrix.origin[axis] ||
+            end - direction * tileSpan === end) {
+            throw new RangeError('Tile matrix extent must be finite');
+        }
+    }
+    return bands;
+}
+/** Tests integer indices against the matrix and optional inclusive coverage limits. Does not wrap. */
+export function isTileIndexInRange(matrix, column, row, limits) {
+    validateTileMatrix(matrix);
+    if (limits)
+        validateTileMatrixLimits(matrix, limits);
+    return (Number.isSafeInteger(column) &&
+        Number.isSafeInteger(row) &&
+        column >= 0 &&
+        row >= 0 &&
+        column < matrix.matrixSize[0] &&
+        row < matrix.matrixSize[1] &&
+        (!limits ||
+            (column >= limits.minTileColumn &&
+                column <= limits.maxTileColumn &&
+                row >= limits.minTileRow &&
+                row <= limits.maxTileRow)));
+}
+/** Returns the entire tile footprint, including column aliases. Throws for out-of-range indices. */
+export function getTileBounds(matrix, column, row) {
+    if (!isTileIndexInRange(matrix, column, row))
+        throw new RangeError('Tile index outside matrix');
+    const width = matrix.resolution * matrix.tileSize[0];
+    const height = (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1];
+    const coalesce = getRowCoalesce(matrix, row);
+    const canonicalColumn = Math.floor(column / coalesce) * coalesce;
+    const minimumX = matrix.origin[0] + canonicalColumn * width;
+    const minimumY = matrix.cornerOfOrigin === 'topLeft'
+        ? matrix.origin[1] - (row + 1) * height
+        : matrix.origin[1] + row * height;
+    return [
+        minimumX,
+        minimumY,
+        matrix.origin[0] + (canonicalColumn + coalesce) * width,
+        matrix.cornerOfOrigin === 'topLeft'
+            ? matrix.origin[1] - row * height
+            : matrix.origin[1] + (row + 1) * height
+    ];
+}
+/**
+ * Finds the containing tile without clamping or wrapping. Tile intervals are half-open in column
+ * and row direction: the origin edge belongs to the matrix, the opposite outer edge does not.
+ * Returns a canonical column for coalesced rows, or null for nonfinite/outside coordinates.
+ */
+export function getTileIndex(matrix, coordinate) {
+    validateTileMatrix(matrix);
+    if (!coordinate.every(Number.isFinite))
+        return null;
+    const row = getTileAxisIndex(matrix.origin[1], matrix.cornerOfOrigin === 'topLeft' ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], coordinate[1]);
+    if (row === null)
+        return null;
+    const coalesce = getRowCoalesce(matrix, row);
+    const column = getTileAxisIndex(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], coordinate[0], coalesce);
+    return column === null ? null : [column, row];
+}
+/** Finds half-open edge ownership using the same arithmetic as bounds, without division drift. */
+function getTileAxisIndex(origin, direction, tileSpan, matrixSize, coordinate, columnStep = 1) {
+    const end = origin + direction * (matrixSize * tileSpan);
+    if (direction === 1
+        ? coordinate < origin || coordinate >= end
+        : coordinate > origin || coordinate <= end) {
+        return null;
+    }
+    return ((findTileAxisBoundary(origin, direction, tileSpan, matrixSize, coordinate, false, columnStep) -
+        1) *
+        columnStep);
+}
+/** Finds the first edge beyond a coordinate, optionally including an equal edge. */
+function findTileAxisBoundary(origin, direction, tileSpan, matrixSize, coordinate, includeEqualEdge, columnStep = 1) {
+    // Binary search avoids enumerating edges or assuming division is accurate near an integer.
+    let lower = 0;
+    let upper = matrixSize / columnStep;
+    while (lower < upper) {
+        const middle = lower + Math.floor((upper - lower) / 2);
+        const edge = origin + direction * (middle * columnStep * tileSpan);
+        const precedesCoordinate = direction === 1
+            ? includeEqualEdge
+                ? edge < coordinate
+                : edge <= coordinate
+            : includeEqualEdge
+                ? edge > coordinate
+                : edge >= coordinate;
+        if (precedesCoordinate)
+            lower = middle + 1;
+        else
+            upper = middle;
+    }
+    return lower;
+}
+/** Validates inclusive coverage limits against the dimensions of an already validated matrix. */
+function validateTileMatrixLimits(matrix, limits) {
+    const values = [limits.minTileColumn, limits.maxTileColumn, limits.minTileRow, limits.maxTileRow];
+    if (!values.every(value => Number.isSafeInteger(value) && value >= 0) ||
+        limits.minTileColumn > limits.maxTileColumn ||
+        limits.minTileRow > limits.maxTileRow ||
+        limits.maxTileColumn >= matrix.matrixSize[0] ||
+        limits.maxTileRow >= matrix.matrixSize[1]) {
+        throw new RangeError('Invalid tile matrix limits');
+    }
+}
+/**
+ * Returns a compact inclusive tile range intersecting an X/Y extent, clipped to the matrix and
+ * optional coverage limits, or null for no intersection. Positive-area queries exclude tiles
+ * that only touch an edge. Zero-width/height queries use point edge ownership on that axis.
+ * Bounds must be finite and ordered; no wrapping or coordinate transformation is performed.
+ */
+function getRegularTileRange(matrix, bounds, limits) {
+    validateTileQueryBounds(bounds);
+    const columns = getTileAxisRange(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], bounds[0], bounds[2]);
+    const topLeft = matrix.cornerOfOrigin === 'topLeft';
+    const rows = getTileAxisRange(matrix.origin[1], topLeft ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], topLeft ? bounds[3] : bounds[1], topLeft ? bounds[1] : bounds[3]);
+    if (!columns || !rows)
+        return null;
+    const range = {
+        minTileColumn: Math.max(columns[0], limits?.minTileColumn ?? 0),
+        maxTileColumn: Math.min(columns[1], limits?.maxTileColumn ?? matrix.matrixSize[0] - 1),
+        minTileRow: Math.max(rows[0], limits?.minTileRow ?? 0),
+        maxTileRow: Math.min(rows[1], limits?.maxTileRow ?? matrix.matrixSize[1] - 1)
+    };
+    return range.minTileColumn > range.maxTileColumn || range.minTileRow > range.maxTileRow
+        ? null
+        : range;
+}
+/** Rejects nonfinite or unordered query bounds independently of matrix validation. */
+function validateTileQueryBounds(bounds) {
+    if (bounds.length !== 4 ||
+        !bounds.every(Number.isFinite) ||
+        bounds[0] > bounds[2] ||
+        bounds[1] > bounds[3]) {
+        throw new RangeError('Tile query bounds must be finite and ordered');
+    }
+}
+/**
+ * Returns a rectangular range for a regular matrix. Variable-width matrices require getTileRanges
+ * so callers cannot accidentally enumerate aliases as separate tiles.
+ */
+export function getTileRange(matrix, bounds, limits) {
+    validateTileMatrix(matrix);
+    if (matrix.variableMatrixWidths?.length) {
+        throw new RangeError('Use getTileRanges for variable-width matrices');
+    }
+    if (limits)
+        validateTileMatrixLimits(matrix, limits);
+    return getRegularTileRange(matrix, bounds, limits);
+}
+/** Returns the coalescence factor for an already validated row. */
+function getRowCoalesce(matrix, row) {
+    return (matrix.variableMatrixWidths?.find(band => row >= band.minTileRow && row <= band.maxTileRow)
+        ?.coalesce ?? 1);
+}
+/**
+ * Returns exact canonical-column ranges, ordered by native row, split at coalescence changes.
+ * Columns advance by columnStep, rows by one. Limits use base-grid indices: a tile is included
+ * when any of its aliases falls within those limits. Canonical columns may precede minTileColumn.
+ * Work and output scale with row bands rather than the number of tiles or rows.
+ */
+export function getTileRanges(matrix, bounds, limits) {
+    const declaredBands = validateTileMatrixGeometry(matrix);
+    if (limits)
+        validateTileMatrixLimits(matrix, limits);
+    validateTileQueryBounds(bounds);
+    const bands = [];
+    let nextRow = 0;
+    for (const band of declaredBands) {
+        if (nextRow < band.minTileRow) {
+            bands.push({ coalesce: 1, minTileRow: nextRow, maxTileRow: band.minTileRow - 1 });
+        }
+        bands.push(band);
+        nextRow = band.maxTileRow + 1;
+    }
+    if (nextRow < matrix.matrixSize[1]) {
+        bands.push({ coalesce: 1, minTileRow: nextRow, maxTileRow: matrix.matrixSize[1] - 1 });
+    }
+    const topLeft = matrix.cornerOfOrigin === 'topLeft';
+    const rows = getTileAxisRange(matrix.origin[1], topLeft ? -1 : 1, (matrix.resolutionY ?? matrix.resolution) * matrix.tileSize[1], matrix.matrixSize[1], topLeft ? bounds[3] : bounds[1], topLeft ? bounds[1] : bounds[3]);
+    if (!rows)
+        return [];
+    const ranges = [];
+    for (const band of bands) {
+        const minimumRow = Math.max(band.minTileRow, rows[0], limits?.minTileRow ?? 0);
+        const maximumRow = Math.min(band.maxTileRow, rows[1], limits?.maxTileRow ?? matrix.matrixSize[1] - 1);
+        if (minimumRow > maximumRow)
+            continue;
+        const columns = getTileAxisRange(matrix.origin[0], 1, matrix.resolution * matrix.tileSize[0], matrix.matrixSize[0], bounds[0], bounds[2], band.coalesce);
+        if (!columns)
+            continue;
+        const minimumColumn = Math.max(columns[0], Math.floor((limits?.minTileColumn ?? 0) / band.coalesce) * band.coalesce);
+        const maximumColumn = Math.min(columns[1], Math.floor((limits?.maxTileColumn ?? matrix.matrixSize[0] - 1) / band.coalesce) *
+            band.coalesce);
+        if (minimumColumn <= maximumColumn)
+            ranges.push({
+                minTileColumn: minimumColumn,
+                maxTileColumn: maximumColumn,
+                minTileRow: minimumRow,
+                maxTileRow: maximumRow,
+                columnStep: band.coalesce
+            });
+    }
+    return ranges;
+}
+/** Finds an inclusive range along one directed axis, clipping before comparing computed edges. */
+function getTileAxisRange(origin, direction, tileSpan, matrixSize, start, end, columnStep = 1) {
+    if (start === end) {
+        const index = getTileAxisIndex(origin, direction, tileSpan, matrixSize, start, columnStep);
+        return index === null ? null : [index, index];
+    }
+    const matrixEnd = origin + direction * (matrixSize * tileSpan);
+    const clippedStart = direction === 1 ? Math.max(start, origin) : Math.min(start, origin);
+    const clippedEnd = direction === 1 ? Math.min(end, matrixEnd) : Math.max(end, matrixEnd);
+    if (direction === 1 ? clippedStart >= clippedEnd : clippedStart <= clippedEnd)
+        return null;
+    return [
+        (findTileAxisBoundary(origin, direction, tileSpan, matrixSize, clippedStart, false, columnStep) -
+            1) *
+            columnStep,
+        (findTileAxisBoundary(origin, direction, tileSpan, matrixSize, clippedEnd, true, columnStep) -
+            1) *
+            columnStep
+    ];
+}
+/**
+ * Selects the coarsest matrix with resolution at or below the positive finite target, or the
+ * finest available matrix when all levels are coarser. Target units must match the matrix set's
+ * coordinate units per pixel. Returns null for an empty set; ties retain the first matrix.
+ * Uses nominal uncoalesced resolution; selection is independent of row.
+ * Uses the larger axis resolution for anisotropic pixels, so both axes meet the target.
+ * Validates every matrix and unique identifiers. Does not sort or mutate the set.
+ */
+export function selectTileMatrix(matrixSet, targetResolution) {
+    if (!Number.isFinite(targetResolution) || targetResolution <= 0) {
+        throw new RangeError('Target resolution must be positive and finite');
+    }
+    let selected = null;
+    let finest = null;
+    let selectedResolution = -Infinity;
+    let finestResolution = Infinity;
+    const identifiers = new Set();
+    for (const matrix of matrixSet.matrices) {
+        validateTileMatrix(matrix);
+        if (identifiers.has(matrix.id))
+            throw new RangeError('Tile matrix identifiers must be unique');
+        identifiers.add(matrix.id);
+        const resolution = Math.max(matrix.resolution, matrix.resolutionY ?? matrix.resolution);
+        if (!finest || resolution < finestResolution) {
+            finest = matrix;
+            finestResolution = resolution;
+        }
+        if (resolution <= targetResolution && (!selected || resolution > selectedResolution)) {
+            selected = matrix;
+            selectedResolution = resolution;
+        }
+    }
+    return selected ?? finest;
+}
+//# sourceMappingURL=tile-matrix.js.map