@loaders.gl/tiles 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/pmtiles/raster.cjs

@@ -0,0 +1,1183 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../images/src/lib/utils/version.ts
+var VERSION;
+var init_version = __esm({
+  "../images/src/lib/utils/version.ts"() {
+    "use strict";
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  }
+});
+
+// ../images/src/lib/category-api/parsed-image-api.ts
+function getImageType(image) {
+  const format = getImageTypeOrNull(image);
+  if (!format) {
+    throw new Error("Not an image");
+  }
+  return format;
+}
+function getImageSize(image) {
+  return getImageData(image);
+}
+function getImageData(image) {
+  switch (getImageType(image)) {
+    case "data":
+      return image;
+    case "imagebitmap":
+      if (isNodeImageBitmap(image)) {
+        return getNodeImageData(image);
+      }
+      return getBrowserImageData(image);
+    case "image":
+      return getBrowserImageData(image);
+    default:
+      throw new Error("getImageData");
+  }
+}
+function isNodeImageBitmap(image) {
+  var _a2;
+  const isImageBitmapNode = (_a2 = globalThis.loaders) == null ? void 0 : _a2.isImageBitmapNode;
+  return Boolean(isImageBitmapNode == null ? void 0 : isImageBitmapNode(image));
+}
+function getNodeImageData(image) {
+  var _a2;
+  const getImageBitmapDataNode = (_a2 = globalThis.loaders) == null ? void 0 : _a2.getImageBitmapDataNode;
+  if (!getImageBitmapDataNode) {
+    throw new Error("getImageData");
+  }
+  return getImageBitmapDataNode(image);
+}
+function getBrowserImageData(image) {
+  const canvas = createBrowserCanvas(image.width, image.height);
+  const context = canvas.getContext("2d");
+  if (!context) {
+    throw new Error("getImageData");
+  }
+  canvas.width = image.width;
+  canvas.height = image.height;
+  context.drawImage(image, 0, 0);
+  return context.getImageData(0, 0, image.width, image.height);
+}
+function createBrowserCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(width, height);
+  }
+  if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+  throw new Error("getImageData");
+}
+function getImageTypeOrNull(image) {
+  if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+    return "imagebitmap";
+  }
+  if (typeof Image !== "undefined" && image instanceof Image) {
+    return "image";
+  }
+  if (image && typeof image === "object" && image.data && image.width && image.height) {
+    return "data";
+  }
+  return null;
+}
+var init_parsed_image_api = __esm({
+  "../images/src/lib/category-api/parsed-image-api.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/loader-utils/lib/module-utils/js-module-utils.ts
+function registerJSModules(modules) {
+  globalThis.loaders ||= {};
+  globalThis.loaders.modules ||= {};
+  Object.assign(globalThis.loaders.modules, modules);
+}
+var init_js_module_utils = __esm({
+  "../core/src/loader-utils/lib/module-utils/js-module-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/loader-utils/lib/binary-utils/array-buffer-utils.ts
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
+}
+function concatenateArrayBuffersFromArray(sources) {
+  const sourceArrays = sources.map(
+    (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+  );
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+var init_array_buffer_utils = __esm({
+  "../core/src/loader-utils/lib/binary-utils/array-buffer-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/loader-utils/lib/iterators/async-iteration.ts
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(copyToArrayBuffer(chunk));
+  }
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+function copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+  return copyFromBuffer(chunk);
+}
+function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+var init_async_iteration = __esm({
+  "../core/src/loader-utils/lib/iterators/async-iteration.ts"() {
+    "use strict";
+    init_array_buffer_utils();
+  }
+});
+
+// ../core/src/loader-utils/lib/request-utils/abort-utils.ts
+function waitForPromiseWithSignal(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    void promise.catch(() => {
+    });
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+var init_abort_utils = __esm({
+  "../core/src/loader-utils/lib/request-utils/abort-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/loader-utils/lib/sources/raster-sampling.ts
+function readRasterValue(raster, column, row, band) {
+  var _a2;
+  const index = row * raster.width + column;
+  if (Array.isArray(raster.data)) return Number((_a2 = raster.data[band]) == null ? void 0 : _a2[index]);
+  return Number(
+    raster.data[raster.interleaved ? index * raster.bandCount + band : band * raster.width * raster.height + index]
+  );
+}
+function isRasterSampleValid(raster, column, row, band) {
+  var _a2;
+  if (!Number.isInteger(column) || !Number.isInteger(row) || column < 0 || row < 0 || column >= raster.width || row >= raster.height || !Number.isInteger(band) || band < 0 || band >= raster.bandCount)
+    return false;
+  const value = readRasterValue(raster, column, row, band);
+  if (!Number.isFinite(value)) return false;
+  const metadata = (_a2 = raster.bands) == null ? void 0 : _a2[band];
+  const noData = (metadata == null ? void 0 : metadata.noData) === void 0 ? raster.noData : metadata.noData;
+  if (noData !== void 0 && noData !== null && value === (((metadata == null ? void 0 : metadata.dtype) ?? raster.dtype) === "float32" ? Math.fround(noData) : noData))
+    return false;
+  return (raster.validityMasks || []).every((mask) => {
+    if (mask.band !== void 0 && mask.band !== band) return true;
+    if (column >= mask.width || row >= mask.height) return false;
+    const index = (mask.offset ?? 0) + row * (mask.rowStride ?? mask.width) + column * (mask.pixelStride ?? 1);
+    return index >= 0 && index < mask.data.length && mask.data[index] !== void 0 && mask.data[index] !== 0;
+  });
+}
+function sampleRaster(raster, pixel, options = {}) {
+  const bands = options.bands ?? Array.from({ length: raster.bandCount }, (_, index) => index);
+  if (bands.some((band) => !Number.isInteger(band) || band < 0 || band >= raster.bandCount))
+    throw new Error("Invalid raster band index");
+  const [column, row] = pixel;
+  const nearestColumn = Math.floor(column + 0.5);
+  const nearestRow = Math.floor(row + 0.5);
+  const miss = !Number.isFinite(column) || !Number.isFinite(row) || nearestColumn < 0 || nearestRow < 0 || nearestColumn >= raster.width || nearestRow >= raster.height;
+  const values = bands.map((band) => {
+    var _a2;
+    if (miss) return void 0;
+    let value = 0;
+    const metadata = (_a2 = raster.bands) == null ? void 0 : _a2[band];
+    if (options.method !== "bilinear" || (metadata == null ? void 0 : metadata.categorical)) {
+      if (!isRasterSampleValid(raster, nearestColumn, nearestRow, band)) return void 0;
+      value = readRasterValue(raster, nearestColumn, nearestRow, band);
+    } else {
+      const left = Math.floor(column);
+      const top = Math.floor(row);
+      for (let vertical = 0; vertical < 2; vertical++) {
+        for (let horizontal = 0; horizontal < 2; horizontal++) {
+          const weight = (horizontal ? column - left : 1 - column + left) * (vertical ? row - top : 1 - row + top);
+          if (weight === 0) continue;
+          if (!isRasterSampleValid(raster, left + horizontal, top + vertical, band))
+            return void 0;
+          value += weight * readRasterValue(raster, left + horizontal, top + vertical, band);
+        }
+      }
+    }
+    const result = options.domain === "physical" ? value * ((metadata == null ? void 0 : metadata.scale) ?? 1) + ((metadata == null ? void 0 : metadata.offset) ?? 0) : value;
+    return Number.isFinite(result) ? result : void 0;
+  });
+  return {
+    miss,
+    values,
+    valid: values.map((value) => value !== void 0),
+    bands: bands.map((band) => {
+      var _a2, _b;
+      return ((_b = (_a2 = raster.bands) == null ? void 0 : _a2[band]) == null ? void 0 : _b.index) ?? band;
+    }),
+    overview: raster.overview,
+    provenance: raster.provenance
+  };
+}
+function rasterCoordinateToPixel(raster, coordinate, crs) {
+  if (!raster.crs || raster.crs !== crs)
+    throw new Error("Raster coordinate CRS must match payload CRS");
+  if (!raster.transform) throw new Error("Raster affine transform is unavailable");
+  const [columnScale, rowShear, originX, columnShear, rowScale, originY] = raster.transform;
+  const determinant = columnScale * rowScale - rowShear * columnShear;
+  if (!raster.transform.every(Number.isFinite) || !Number.isFinite(determinant) || determinant === 0)
+    throw new Error("Singular or invalid raster affine transform");
+  const deltaX = coordinate[0] - originX;
+  const deltaY = coordinate[1] - originY;
+  const shift = raster.pixelRegistration === "point" ? 0 : 0.5;
+  return [
+    (rowScale * deltaX - rowShear * deltaY) / determinant - shift + 0,
+    (columnScale * deltaY - columnShear * deltaX) / determinant - shift + 0
+  ];
+}
+var init_raster_sampling = __esm({
+  "../core/src/loader-utils/lib/sources/raster-sampling.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/loader-utils/index.ts
+var init_loader_utils = __esm({
+  "../core/src/loader-utils/index.ts"() {
+    "use strict";
+    init_js_module_utils();
+    init_async_iteration();
+    init_raster_sampling();
+    init_abort_utils();
+  }
+});
+
+// ../compression/src/lib/compression.ts
+var CompressionTransform, Compressor;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
+    "use strict";
+    init_loader_utils();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+    Compressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.compressBatches = this.compressBatches.bind(this);
+      }
+      /** Asynchronously compresses data. */
+      async compress(input) {
+        await this.preload();
+        return this.compressSync(input);
+      }
+      /** Synchronously compresses data. */
+      compressSync(input) {
+        throw new Error(`${this.name}: sync compression not supported`);
+      }
+      /** Compresses batches. */
+      async *compressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.compress(input);
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
+}
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
+}
+function isNativeCompressionSupported(format) {
+  return Boolean(createNativeCompressionStream(format));
+}
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
+  }
+  try {
+    const CompressionStreamConstructor = globalThis.CompressionStream;
+    return new CompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatches(inputBatches, compressionStream) {
+  const writer = compressionStream.writable.getWriter();
+  const reader = compressionStream.readable.getReader();
+  const writePromise = writeBatches(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield new Uint8Array(value).buffer;
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function writeBatches(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
+    }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+async function concatenateBatches(batches) {
+  const output = [];
+  let byteLength = 0;
+  for await (const batch of batches) {
+    const bytes = new Uint8Array(batch);
+    output.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
+  }
+  return result.buffer;
+}
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/native-compressor.ts
+var native_compressor_exports = {};
+__export(native_compressor_exports, {
+  NativeCompressor: () => NativeCompressor
+});
+var NativeCompressor;
+var init_native_compressor = __esm({
+  "../compression/src/lib/native-compressor.ts"() {
+    "use strict";
+    init_compression();
+    init_compression_stream();
+    NativeCompressor = class extends Compressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Compresses one buffer with the runtime-provided stream. */
+      async compress(input) {
+        const output = await compressWithNativeCompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
+        return output;
+      }
+      /** Compresses batches incrementally with the runtime-provided stream. */
+      async *compressBatches(inputBatches) {
+        const output = compressBatchesWithNativeCompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/compress-utils-compression.ts
+async function* transformBatches2(stream, inputBatches, maximumOutputByteLength = Number.POSITIVE_INFINITY) {
+  let outputByteLength = 0;
+  try {
+    for await (const input of inputBatches) {
+      const output2 = stream.write(new Uint8Array(input));
+      if (output2.byteLength > maximumOutputByteLength - outputByteLength)
+        throw new RangeError("Decompressed output exceeds maxOutputByteLength");
+      outputByteLength += output2.byteLength;
+      if (output2.byteLength > 0) yield copyArrayBuffer(output2);
+    }
+    const output = stream.finish();
+    if (output.byteLength > maximumOutputByteLength - outputByteLength)
+      throw new RangeError("Decompressed output exceeds maxOutputByteLength");
+    if (output.byteLength > 0) yield copyArrayBuffer(output);
+  } finally {
+    stream.destroy();
+  }
+}
+function copyArrayBuffer(bytes) {
+  return bytes.slice().buffer;
+}
+var CompressUtilsCompressor;
+var init_compress_utils_compression = __esm({
+  "../compression/src/lib/compress-utils-compression.ts"() {
+    "use strict";
+    init_compression();
+    CompressUtilsCompressor = class extends Compressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      options;
+      loadModule;
+      /** Module initialized for synchronous operations. */
+      module = null;
+      /** Shared import and WASM initialization for concurrent callers. */
+      modulePromise = null;
+      /** Creates a format-specific compress-utils encoder. */
+      constructor(metadata, loadModule, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = metadata.extensions || [];
+        this.contentEncodings = metadata.contentEncodings || [];
+        this.loadModule = loadModule;
+        this.options = options;
+      }
+      /** Imports and initializes the codec without loading the opposite direction. */
+      async preload(modules = {}) {
+        await super.preload(modules);
+        this.modulePromise ||= this.loadModule().then(async (module2) => {
+          var _a2;
+          await ((_a2 = module2.preload) == null ? void 0 : _a2.call(module2));
+          this.module = module2;
+        });
+        try {
+          await this.modulePromise;
+        } catch (error) {
+          this.modulePromise = null;
+          throw error;
+        }
+      }
+      /** Runs synchronously after preload has initialized the WASM codec. */
+      compressSync(input) {
+        var _a2;
+        if (!((_a2 = this.module) == null ? void 0 : _a2.compressSync))
+          throw new Error(`${this.name}: call preload() before compressSync()`);
+        return copyArrayBuffer(
+          this.module.compressSync(new Uint8Array(input), this.options.compressUtils)
+        );
+      }
+      /** Compresses one buffer with the selected compress-utils encoder. */
+      async compress(input) {
+        await this.preload();
+        const module2 = this.module;
+        const output = await module2.compress(new Uint8Array(input), this.options.compressUtils);
+        return copyArrayBuffer(output);
+      }
+      /** Incrementally compresses input batches with compress-utils. */
+      async *compressBatches(inputBatches) {
+        await this.preload();
+        const module2 = this.module;
+        if (!module2.createCompressStream) {
+          yield await this.compress(await this.concatenate(inputBatches));
+          return;
+        }
+        const stream = await module2.createCompressStream(this.options.compressUtils);
+        yield* transformBatches2(stream, inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/gzip-compressor-compress-utils.ts
+var GZipCompressUtilsCompressor;
+var init_gzip_compressor_compress_utils = __esm({
+  "../compression/src/gzip-compressor-compress-utils.ts"() {
+    "use strict";
+    init_compress_utils_compression();
+    GZipCompressUtilsCompressor = class extends CompressUtilsCompressor {
+      constructor(options = {}) {
+        super(
+          { name: "gzip", extensions: ["gz", "gzip"], contentEncodings: ["gzip", "x-gzip"] },
+          () => import("compress-utils/gzip/compress"),
+          options
+        );
+      }
+    };
+  }
+});
+
+// ../compression/src/gzip-compressor.ts
+var gzip_compressor_exports = {};
+__export(gzip_compressor_exports, {
+  GZipCompressor: () => GZipCompressor
+});
+var GZipCompressor;
+var init_gzip_compressor = __esm({
+  "../compression/src/gzip-compressor.ts"() {
+    "use strict";
+    init_gzip_compressor_compress_utils();
+    init_compression_stream();
+    GZipCompressor = class extends GZipCompressUtilsCompressor {
+      /** Compresses with native streams when available, otherwise lazily initializes WASM. */
+      async compress(input) {
+        if (this.options.useNative !== false) {
+          const output = await compressWithNativeCompressionStream(input, "gzip");
+          if (output) return output;
+        }
+        return super.compress(input);
+      }
+      /** Streams native batches when available, otherwise uses the WASM stream. */
+      async *compressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const output = compressBatchesWithNativeCompressionStream(inputBatches, "gzip");
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        yield* super.compressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// dist/pmtiles/raster.js
+var raster_exports = {};
+__export(raster_exports, {
+  encodeRasterPMTiles: () => encodeRasterPMTiles
+});
+module.exports = __toCommonJS(raster_exports);
+
+// ../images/src/image-writer.ts
+init_version();
+
+// ../images/src/lib/encoders/encode-image.ts
+init_parsed_image_api();
+var _a;
+var encodeImageNode = (_a = globalThis.loaders) == null ? void 0 : _a.encodeImageNode;
+async function encodeImage(image, options) {
+  options = options || {};
+  options.image = options.image || {};
+  return encodeImageNode ? encodeImageNode(image, { type: options.image.mimeType }) : encodeImageInBrowser(image, options);
+}
+var qualityParamSupported = true;
+async function encodeImageInBrowser(image, options) {
+  const { mimeType, jpegQuality } = options.image;
+  const { width, height } = getImageSize(image);
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  drawImageToCanvas(image, canvas);
+  if ("convertToBlob" in canvas) {
+    const blob2 = await canvas.convertToBlob({ type: mimeType, quality: jpegQuality ?? void 0 });
+    return blob2.arrayBuffer();
+  }
+  const blob = await new Promise((resolve) => {
+    if (jpegQuality && qualityParamSupported) {
+      try {
+        canvas.toBlob(resolve, mimeType, jpegQuality);
+        return;
+      } catch (_error) {
+        qualityParamSupported = false;
+      }
+    }
+    canvas.toBlob(resolve, mimeType);
+  });
+  if (!blob) {
+    throw new Error("image encoding failed");
+  }
+  return await blob.arrayBuffer();
+}
+function drawImageToCanvas(image, canvas, x = 0, y = 0) {
+  if (x === 0 && y === 0 && typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+    const context2 = canvas.getContext("bitmaprenderer");
+    if (context2) {
+      context2.transferFromImageBitmap(image);
+      return canvas;
+    }
+  }
+  const context = canvas.getContext("2d");
+  if (image.data) {
+    const clampedArray = new Uint8ClampedArray(image.data);
+    const imageData = new ImageData(clampedArray, image.width, image.height);
+    context.putImageData(imageData, 0, 0);
+    return canvas;
+  }
+  context.drawImage(image, 0, 0);
+  return canvas;
+}
+
+// ../images/src/image-writer.ts
+var ImageWriter = {
+  name: "Images",
+  id: "image",
+  module: "images",
+  version: VERSION,
+  extensions: ["jpeg"],
+  mimeTypes: [],
+  options: {
+    image: {
+      mimeType: "image/png",
+      jpegQuality: null
+    }
+  },
+  encode: encodeImage
+};
+
+// dist/pmtiles/raster.js
+init_loader_utils();
+
+// ../compression/src/lib/lazy-compression.ts
+init_compression();
+init_compression_stream();
+var LazyCompressor = class extends Compressor {
+  name;
+  extensions;
+  contentEncodings;
+  isSupported = true;
+  /** Constructor options retained until a concrete implementation is selected. */
+  options;
+  /** Built-in stream format to probe, or null when the format has no built-in path. */
+  nativeFormat;
+  /** Returns whether built-in selection remains eligible for the merged preload options. */
+  shouldUseNative;
+  /** Dynamically imports the balanced fallback constructor. */
+  loadFallback;
+  /** Selected concrete implementation after preload completes. */
+  implementation = null;
+  /** Shared in-flight selection used by concurrent asynchronous calls. */
+  implementationPromise = null;
+  constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+    super(options);
+    this.name = metadata.name;
+    this.extensions = [...metadata.extensions];
+    this.contentEncodings = [...metadata.contentEncodings];
+    this.options = options;
+    this.nativeFormat = nativeFormat;
+    this.shouldUseNative = shouldUseNative;
+    this.loadFallback = loadFallback;
+  }
+  /** Selects and returns the built-in or dynamically imported fallback compressor. */
+  async preload(modules = {}) {
+    if (this.implementation) return this.implementation;
+    const options = mergeModules(this.options, modules);
+    this.implementationPromise ||= this.loadImplementation(options);
+    try {
+      this.implementation = await this.implementationPromise;
+      return this.implementation;
+    } catch (error) {
+      this.implementationPromise = null;
+      throw error;
+    }
+  }
+  /** Loads the selected concrete compressor. */
+  async loadImplementation(options) {
+    if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeCompressionSupported(this.nativeFormat)) {
+      const { NativeCompressor: NativeCompressor2 } = await Promise.resolve().then(() => (init_native_compressor(), native_compressor_exports));
+      return new NativeCompressor2(this, this.nativeFormat, options);
+    }
+    const Compressor2 = await this.loadFallback();
+    const implementation = new Compressor2({ ...options, useNative: false });
+    await implementation.preload(options.modules);
+    return implementation;
+  }
+  /** Compresses after lazily selecting the default implementation. */
+  async compress(input) {
+    return (await this.preload()).compress(input);
+  }
+  /** Compresses synchronously after an implementation has been preloaded. */
+  compressSync(input) {
+    if (!this.implementation) throw new Error(`${this.name}: call preload() before compressSync()`);
+    return this.implementation.compressSync(input);
+  }
+  /** Compresses batches after lazily selecting the default implementation. */
+  async *compressBatches(inputBatches) {
+    yield* (await this.preload()).compressBatches(inputBatches);
+  }
+};
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+
+// ../compression/src/default-codecs.ts
+var GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
+var GZipCompressor2 = class extends LazyCompressor {
+  constructor(options = {}) {
+    super(GZIP, async () => (await Promise.resolve().then(() => (init_gzip_compressor(), gzip_compressor_exports))).GZipCompressor, options, "gzip");
+  }
+};
+
+// dist/pmtiles/lib/encode-pmtiles.js
+var import_pmtiles = require("pmtiles");
+var HEADER_BYTES = 127;
+var MAX_ROOT_BYTES = 16384 - HEADER_BYTES;
+var TILE_TYPES = { mvt: 1, png: 2, jpeg: 3, webp: 4, avif: 5, mlt: 6 };
+var COMPRESSIONS = { none: 1, gzip: 2, brotli: 3, zstd: 4 };
+async function encodePMTiles(input, options) {
+  var _a2, _b, _c, _d, _e, _f;
+  (_a2 = options == null ? void 0 : options.signal) == null ? void 0 : _a2.throwIfAborted();
+  if (!options || !Object.hasOwn(TILE_TYPES, options.tileType))
+    throw new TypeError("PMTiles requires a supported tileType");
+  options = {
+    ...options,
+    bounds: (_b = options.bounds) == null ? void 0 : _b.slice(),
+    center: (_c = options.center) == null ? void 0 : _c.slice()
+  };
+  const tileCompression = options.tileCompression ?? "none";
+  const internalCompression = options.internalCompression ?? "none";
+  if (!Object.hasOwn(COMPRESSIONS, tileCompression) || !["none", "gzip"].includes(internalCompression))
+    throw new TypeError("Unsupported PMTiles compression");
+  const maxTiles = validateLimit(options.maxTiles ?? 1e5, "tile");
+  const maxOutputBytes = validateLimit(options.maxOutputBytes ?? 256 * 1024 * 1024, "output");
+  const maxMetadataBytes = validateLimit(options.maxMetadataBytes ?? 1024 * 1024, "metadata");
+  const metadata = encodeMetadata(options.metadata ?? {}, options.tileType === "mvt", maxMetadataBytes);
+  const tiles = [];
+  const tileIds = /* @__PURE__ */ new Set();
+  const bounds = [180, 90, -180, -90];
+  let minZoom = 26;
+  let maxZoom = 0;
+  let payloadBytes = 0;
+  for await (const tile of input) {
+    (_d = options.signal) == null ? void 0 : _d.throwIfAborted();
+    if (tiles.length >= maxTiles)
+      throw new RangeError("PMTiles tile limit exceeded");
+    if (!Number.isInteger(tile.z) || tile.z < 0 || tile.z > 26 || !Number.isInteger(tile.x) || !Number.isInteger(tile.y) || tile.x < 0 || tile.y < 0 || tile.x >= 2 ** tile.z || tile.y >= 2 ** tile.z)
+      throw new RangeError("Invalid PMTiles XYZ tile coordinate");
+    const tileId = (0, import_pmtiles.zxyToTileId)(tile.z, tile.x, tile.y);
+    if (tileIds.has(tileId))
+      throw new Error("Duplicate PMTiles tile coordinate");
+    const data = tile.data;
+    if (!(data instanceof Blob) && !(data instanceof ArrayBuffer) && !ArrayBuffer.isView(data))
+      throw new TypeError("PMTiles tile data must be a Blob, ArrayBuffer or typed-array view");
+    const size = data instanceof Blob ? data.size : data.byteLength;
+    if (!size)
+      throw new RangeError("PMTiles tile payload must be nonempty");
+    payloadBytes += size;
+    if (HEADER_BYTES + payloadBytes > maxOutputBytes)
+      throw new RangeError("PMTiles output limit exceeded");
+    const bytes = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data instanceof ArrayBuffer ? new Uint8Array(data).slice() : new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice();
+    (_e = options.signal) == null ? void 0 : _e.throwIfAborted();
+    tileIds.add(tileId);
+    tiles.push({ tileId, bytes });
+    minZoom = Math.min(minZoom, tile.z);
+    maxZoom = Math.max(maxZoom, tile.z);
+    const width = 2 ** tile.z;
+    bounds[0] = Math.min(bounds[0], tile.x / width * 360 - 180);
+    bounds[1] = Math.min(bounds[1], getLatitude((tile.y + 1) / width));
+    bounds[2] = Math.max(bounds[2], (tile.x + 1) / width * 360 - 180);
+    bounds[3] = Math.max(bounds[3], getLatitude(tile.y / width));
+  }
+  if (!tiles.length)
+    throw new RangeError("PMTiles requires at least one tile");
+  const outputBounds = options.bounds ?? bounds;
+  validateBounds(outputBounds);
+  const center = options.center ?? [
+    (outputBounds[0] + outputBounds[2]) / 2,
+    (outputBounds[1] + outputBounds[3]) / 2,
+    minZoom
+  ];
+  if (center.length !== 3 || !Number.isFinite(center[0]) || Math.abs(center[0]) > 180 || !Number.isFinite(center[1]) || Math.abs(center[1]) > 90 || !Number.isInteger(center[2]) || center[2] < minZoom || center[2] > maxZoom)
+    throw new RangeError("Invalid PMTiles center");
+  tiles.sort((first, second) => first.tileId - second.tileId);
+  let offset = 0;
+  const entries = tiles.map((tile) => {
+    const entry = { tileId: tile.tileId, offset, length: tile.bytes.byteLength, runLength: 1 };
+    offset += entry.length;
+    return entry;
+  });
+  const compress = async (bytes) => {
+    var _a3, _b2;
+    (_a3 = options.signal) == null ? void 0 : _a3.throwIfAborted();
+    const result = internalCompression === "gzip" ? new Uint8Array(await new GZipCompressor2().compress(bytes.buffer)) : bytes;
+    (_b2 = options.signal) == null ? void 0 : _b2.throwIfAborted();
+    return result;
+  };
+  let root = await compress(encodeDirectory(entries));
+  const leaves = [];
+  let leafBytes = 0;
+  if (root.byteLength > MAX_ROOT_BYTES) {
+    const pointers = [];
+    const entriesPerLeaf = Math.max(1024, Math.ceil(entries.length / 512));
+    for (let index = 0; index < entries.length; index += entriesPerLeaf) {
+      const leaf = await compress(encodeDirectory(entries.slice(index, index + entriesPerLeaf)));
+      pointers.push({
+        tileId: entries[index].tileId,
+        offset: leafBytes,
+        length: leaf.byteLength,
+        runLength: 0
+      });
+      leaves.push(leaf);
+      leafBytes += leaf.byteLength;
+      if (HEADER_BYTES + leafBytes + payloadBytes > maxOutputBytes)
+        throw new RangeError("PMTiles output limit exceeded");
+    }
+    root = await compress(encodeDirectory(pointers));
+  }
+  if (root.byteLength > MAX_ROOT_BYTES)
+    throw new RangeError("PMTiles root directory limit exceeded");
+  const encodedMetadata = await compress(metadata);
+  const metadataOffset = HEADER_BYTES + root.byteLength;
+  const leafOffset = metadataOffset + encodedMetadata.byteLength;
+  const tileOffset = leafOffset + leafBytes;
+  const outputLength = tileOffset + payloadBytes;
+  if (outputLength > maxOutputBytes)
+    throw new RangeError("PMTiles output limit exceeded");
+  const output = new Uint8Array(outputLength);
+  output.set(new TextEncoder().encode("PMTiles"));
+  output[7] = 3;
+  const header = new DataView(output.buffer);
+  const fields = [
+    HEADER_BYTES,
+    root.byteLength,
+    metadataOffset,
+    encodedMetadata.byteLength,
+    leafOffset,
+    leafBytes,
+    tileOffset,
+    payloadBytes,
+    tiles.length,
+    tiles.length,
+    tiles.length
+  ];
+  fields.forEach((value, index) => header.setBigUint64(8 + index * 8, BigInt(value), true));
+  output.set([
+    1,
+    COMPRESSIONS[internalCompression],
+    COMPRESSIONS[tileCompression],
+    TILE_TYPES[options.tileType],
+    minZoom,
+    maxZoom
+  ], 96);
+  outputBounds.forEach((value, index) => header.setInt32(102 + index * 4, Math.round(value * 1e7), true));
+  output[118] = center[2];
+  header.setInt32(119, Math.round(center[0] * 1e7), true);
+  header.setInt32(123, Math.round(center[1] * 1e7), true);
+  offset = HEADER_BYTES;
+  for (const section of [root, encodedMetadata, ...leaves, ...tiles.map((tile) => tile.bytes)]) {
+    output.set(section, offset);
+    offset += section.byteLength;
+  }
+  (_f = options.signal) == null ? void 0 : _f.throwIfAborted();
+  return output.buffer;
+}
+function encodeDirectory(entries) {
+  const bytes = [];
+  writeVarint(bytes, entries.length);
+  let previousTileId = 0;
+  for (const entry of entries) {
+    writeVarint(bytes, entry.tileId - previousTileId);
+    previousTileId = entry.tileId;
+  }
+  for (const entry of entries)
+    writeVarint(bytes, entry.runLength);
+  for (const entry of entries)
+    writeVarint(bytes, entry.length);
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const previous = entries[index - 1];
+    writeVarint(bytes, previous && entry.offset === previous.offset + previous.length ? 0 : entry.offset + 1);
+  }
+  return Uint8Array.from(bytes);
+}
+function writeVarint(output, value) {
+  while (value >= 128) {
+    output.push(value % 128 + 128);
+    value = Math.floor(value / 128);
+  }
+  output.push(value);
+}
+function validateLimit(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new RangeError(`Invalid PMTiles ${name} limit`);
+  return value;
+}
+function validateBounds(bounds) {
+  if (bounds.length !== 4 || bounds.some((value) => !Number.isFinite(value)) || Math.abs(bounds[0]) > 180 || Math.abs(bounds[2]) > 180 || Math.abs(bounds[1]) > 90 || Math.abs(bounds[3]) > 90 || bounds[0] > bounds[2] || bounds[1] > bounds[3])
+    throw new RangeError("Invalid PMTiles bounds");
+}
+function getLatitude(value) {
+  return Math.atan(Math.sinh(Math.PI * (1 - 2 * value))) * 180 / Math.PI;
+}
+function encodeMetadata(metadata, mvt, limit) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    throw new TypeError("PMTiles metadata must be a JSON object");
+  const json = JSON.stringify(metadata);
+  const normalized = JSON.parse(json);
+  if (!normalized || typeof normalized !== "object" || Array.isArray(normalized))
+    throw new TypeError("PMTiles metadata must serialize to a JSON object");
+  if (mvt || normalized.vector_layers !== void 0) {
+    const layers = normalized.vector_layers;
+    const ids = /* @__PURE__ */ new Set();
+    if (!Array.isArray(layers) || !layers.length)
+      throw new TypeError("PMTiles vector_layers must declare at least one layer");
+    for (const layer of layers) {
+      if (!layer || typeof layer.id !== "string" || !layer.id || ids.has(layer.id) || !layer.fields || typeof layer.fields !== "object" || Array.isArray(layer.fields) || Object.values(layer.fields).some((value) => !["String", "Number", "Boolean"].includes(value)))
+        throw new TypeError("Invalid PMTiles vector_layers declaration");
+      ids.add(layer.id);
+    }
+  }
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength > limit)
+    throw new RangeError("PMTiles metadata limit exceeded");
+  return bytes;
+}
+
+// dist/pmtiles/raster.js
+var HALF_WORLD = Math.PI * 6378137;
+async function encodeRasterPMTiles(source, options) {
+  var _a2;
+  const configuration = {
+    ...options,
+    bands: (_a2 = options.bands) == null ? void 0 : _a2.slice(),
+    selection: options.selection ? { ...options.selection } : void 0,
+    pmtiles: { ...options.pmtiles }
+  };
+  const signal = configuration.pmtiles.signal;
+  signal == null ? void 0 : signal.throwIfAborted();
+  const tileSize = configuration.tileSize ?? 256;
+  const maxSourcePixels = configuration.maxSourcePixels ?? 1024 * 1024;
+  const maxDecodedBytes = configuration.maxDecodedBytes ?? 32 * 1024 * 1024;
+  const maxTiles = configuration.pmtiles.maxTiles ?? 1e5;
+  if (!Number.isSafeInteger(tileSize) || tileSize < 1 || tileSize > 1024 || !Number.isSafeInteger(maxSourcePixels) || maxSourcePixels < tileSize * tileSize || !Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < tileSize * tileSize * 4 || !Number.isSafeInteger(maxTiles) || maxTiles < 1)
+    throw new Error("Invalid raster PMTiles size or budget");
+  const metadata = await waitForPromiseWithSignal(source.getMetadata({ signal }), signal);
+  signal == null ? void 0 : signal.throwIfAborted();
+  const sourceCRS = metadata.crs;
+  if (sourceCRS !== "EPSG:3857" && sourceCRS !== "EPSG:4326" && sourceCRS !== "OGC:CRS84")
+    throw new Error("Raster PMTiles requires EPSG:3857, EPSG:4326 or OGC:CRS84");
+  const crs = sourceCRS;
+  if (!Number.isSafeInteger(metadata.bandCount) || metadata.bandCount < 1)
+    throw new Error("Invalid raster source band count");
+  const bands = configuration.bands ?? Array.from({ length: Math.min(metadata.bandCount, 5) }, (_, index) => index);
+  if (![1, 2, 3, 4].includes(bands.length) || new Set(bands).size !== bands.length || bands.some((band) => !Number.isSafeInteger(band) || band < 0 || band >= metadata.bandCount))
+    throw new Error("Select one through four distinct raster bands");
+  const sampleOptions = { bands: bands.map((_band, index) => index) };
+  const archiveMetadata = { ...configuration.pmtiles.metadata };
+  for (const name of [
+    "vector_layers",
+    "bounds",
+    "minzoom",
+    "maxzoom",
+    "center",
+    "tiles",
+    "tilestats"
+  ])
+    delete archiveMetadata[name];
+  return encodePMTiles(encodeTiles(), {
+    ...configuration.pmtiles,
+    metadata: archiveMetadata,
+    tileType: "png",
+    tileCompression: "none"
+  });
+  async function* encodeTiles() {
+    const seen = /* @__PURE__ */ new Set();
+    let requested = 0;
+    for await (const address of configuration.tiles) {
+      signal == null ? void 0 : signal.throwIfAborted();
+      const tile = { ...address };
+      if (++requested > maxTiles)
+        throw new Error("Raster PMTiles requested tile limit exceeded");
+      if (!Number.isInteger(tile.z) || tile.z < 0 || tile.z > 26 || !Number.isInteger(tile.x) || !Number.isInteger(tile.y) || tile.x < 0 || tile.y < 0 || tile.x >= 2 ** tile.z || tile.y >= 2 ** tile.z)
+        throw new Error("Invalid raster PMTiles selected XYZ address");
+      const key = `${tile.z}/${tile.x}/${tile.y}`;
+      if (seen.has(key))
+        throw new Error("Duplicate raster PMTiles selected XYZ address");
+      seen.add(key);
+      const scale = 2 ** tile.z;
+      const west = tile.x / scale;
+      const east = (tile.x + 1) / scale;
+      const north = tile.y / scale;
+      const south = (tile.y + 1) / scale;
+      const bounds = crs === "EPSG:3857" ? [
+        [(2 * west - 1) * HALF_WORLD, (1 - 2 * south) * HALF_WORLD],
+        [(2 * east - 1) * HALF_WORLD, (1 - 2 * north) * HALF_WORLD]
+      ] : [
+        [360 * west - 180, getLatitude2(south)],
+        [360 * east - 180, getLatitude2(north)]
+      ];
+      const raster = await waitForPromiseWithSignal(source.getRasterForRegion({
+        bounds,
+        crs,
+        width: tileSize,
+        height: tileSize,
+        bands: bands.slice(),
+        selection: configuration.selection,
+        interleaved: false,
+        resampleMethod: "nearest",
+        maxPixels: maxSourcePixels,
+        maxDecodedBytes,
+        signal
+      }), signal);
+      signal == null ? void 0 : signal.throwIfAborted();
+      validateRaster(raster, bands.length, tileSize, maxSourcePixels, maxDecodedBytes);
+      const pixels = new Uint8Array(tileSize * tileSize * 4);
+      let visible = false;
+      const firstX = bounds[0][0] + (bounds[1][0] - bounds[0][0]) / (2 * tileSize);
+      const lastX = bounds[1][0] - (bounds[1][0] - bounds[0][0]) / (2 * tileSize);
+      for (let row = 0; row < tileSize; row++) {
+        if (row % 32 === 0) {
+          signal == null ? void 0 : signal.throwIfAborted();
+          if (row)
+            await new Promise((resolve) => setTimeout(resolve, 0));
+          signal == null ? void 0 : signal.throwIfAborted();
+        }
+        const normalizedY = north + (row + 0.5) / (tileSize * scale);
+        const sourceY = crs === "EPSG:3857" ? (1 - 2 * normalizedY) * HALF_WORLD : getLatitude2(normalizedY);
+        const firstPixel = rasterCoordinateToPixel(raster, [firstX, sourceY], crs);
+        const lastPixel = rasterCoordinateToPixel(raster, [lastX, sourceY], crs);
+        for (let column = 0; column < tileSize; column++) {
+          const fraction = tileSize === 1 ? 0 : column / (tileSize - 1);
+          const sample = sampleRaster(raster, [
+            firstPixel[0] + (lastPixel[0] - firstPixel[0]) * fraction,
+            firstPixel[1] + (lastPixel[1] - firstPixel[1]) * fraction
+          ], sampleOptions);
+          if (!sample.valid.every(Boolean))
+            continue;
+          const values = sample.values;
+          const offset = (row * tileSize + column) * 4;
+          const grayscale = values.length < 3;
+          pixels[offset] = values[0];
+          pixels[offset + 1] = grayscale ? values[0] : values[1];
+          pixels[offset + 2] = grayscale ? values[0] : values[2];
+          pixels[offset + 3] = values.length === 2 ? values[1] : values.length === 4 ? values[3] : 255;
+          visible ||= pixels[offset + 3] > 0;
+        }
+      }
+      if (!visible)
+        continue;
+      const data = await waitForPromiseWithSignal(ImageWriter.encode({ data: pixels, width: tileSize, height: tileSize }, { image: { mimeType: "image/png" } }), signal);
+      signal == null ? void 0 : signal.throwIfAborted();
+      yield { ...tile, data };
+    }
+  }
+}
+function getLatitude2(normalizedY) {
+  return Math.atan(Math.sinh(Math.PI * (1 - 2 * normalizedY))) * 180 / Math.PI;
+}
+function validateRaster(raster, bandCount, tileSize, maxPixels, maxBytes) {
+  var _a2;
+  const pixels = raster.width * raster.height;
+  if (!Number.isSafeInteger(raster.width) || raster.width < 1 || !Number.isSafeInteger(raster.height) || raster.height < 1 || !Number.isSafeInteger(pixels) || pixels > maxPixels || raster.bandCount !== bandCount || raster.dtype !== "uint8" || raster.bands && raster.bands.length !== bandCount || ((_a2 = raster.bands) == null ? void 0 : _a2.some((band) => band.dtype !== "uint8" || (band.scale ?? 1) !== 1 || (band.offset ?? 0) !== 0)))
+    throw new Error("Raster PMTiles requires bounded raw uint8 imagery with matching selected bands");
+  const buffers = Array.isArray(raster.data) ? raster.data : [raster.data];
+  const expectedLength = Array.isArray(raster.data) ? pixels : pixels * bandCount;
+  if (Array.isArray(raster.data) && buffers.length !== bandCount || buffers.some((buffer) => !(buffer instanceof Uint8Array) && !(buffer instanceof Uint8ClampedArray) || buffer.length !== expectedLength))
+    throw new Error("Invalid raster PMTiles sample buffers");
+  for (const mask of raster.validityMasks ?? []) {
+    const offset = mask.offset ?? 0;
+    const pixelStride = mask.pixelStride ?? 1;
+    const rowStride = mask.rowStride ?? mask.width;
+    if (!(mask.data instanceof Uint8Array) || mask.width !== raster.width || mask.height !== raster.height || !Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(pixelStride) || pixelStride < 1 || !Number.isSafeInteger(rowStride) || rowStride < 1 || offset + (mask.height - 1) * rowStride + (mask.width - 1) * pixelStride >= mask.data.length || mask.band !== void 0 && (!Number.isInteger(mask.band) || mask.band < 0 || mask.band >= bandCount))
+      throw new Error("Invalid raster PMTiles validity mask");
+  }
+  const bytes = buffers.reduce((total, buffer) => total + buffer.byteLength, tileSize * tileSize * 4) + (raster.validityMasks ?? []).reduce((total, mask) => total + mask.data.byteLength, 0);
+  if (bytes > maxBytes)
+    throw new Error("Raster PMTiles decoded-byte budget exceeded");
+}
+//# sourceMappingURL=raster.cjs.map