@loaders.gl/wms 3.3.0-alpha.13 → 3.3.0-alpha.14

package/dist/dist.min.js

@@ -1770,6 +1770,15 @@ var init_wms_capabilities_loader = __esm({
   }
 });
 
+// src/lib/data-sources/image-source.ts
+var ImageSource;
+var init_image_source = __esm({
+  "src/lib/data-sources/image-source.ts"() {
+    ImageSource = class {
+    };
+  }
+});
+
 // ../images/src/lib/utils/version.ts
 var VERSION4;
 var init_version = __esm({
@@ -1937,13 +1946,13 @@ var init_svg_utils = __esm({
 // ../images/src/lib/parsers/parse-to-image.ts
 async function parseToImage(arrayBuffer, options, url) {
   const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-  const URL2 = self.URL || self.webkitURL;
-  const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
+  const URL = self.URL || self.webkitURL;
+  const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
   try {
     return await loadToImage(objectUrl || blobOrDataUrl, options);
   } finally {
     if (objectUrl) {
-      URL2.revokeObjectURL(objectUrl);
+      URL.revokeObjectURL(objectUrl);
     }
   }
 }
@@ -2225,12 +2234,63 @@ var init_src3 = __esm({
   }
 });
 
-// src/lib/data-sources/image-source.ts
-var ImageSource;
-var init_image_source = __esm({
-  "src/lib/data-sources/image-source.ts"() {
-    ImageSource = class {
+// src/lib/data-sources/image-services/image-service.ts
+function getFetchFunction(options) {
+  const fetchFunction = options?.fetch;
+  if (fetchFunction && typeof fetchFunction === "function") {
+    return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
+  }
+  const fetchOptions = options?.fetch;
+  if (fetchOptions && typeof fetchOptions !== "function") {
+    return (url) => fetch(url, fetchOptions);
+  }
+  return (url) => fetch(url);
+}
+function mergeImageServiceProps(props) {
+  return {
+    ...props,
+    loadOptions: {
+      ...props.loadOptions,
+      fetch: getFetchFunction(props.loadOptions)
+    }
+  };
+}
+var ImageService;
+var init_image_service = __esm({
+  "src/lib/data-sources/image-services/image-service.ts"() {
+    init_src3();
+    init_image_source();
+    ImageService = class extends ImageSource {
+      constructor(props) {
+        super();
+        this.props = mergeImageServiceProps(props);
+        this.fetch = getFetchFunction(props);
+      }
+      async getMetadata() {
+        throw new Error("ImageSource.getMetadata not implemented");
+      }
+      async getImage(parameters) {
+        const granularParameters = this.getGranularParameters(parameters);
+        const url = this.getURLFromTemplate(granularParameters);
+        const response = await this.fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        return await ImageLoader.parse(arrayBuffer);
+      }
+      getGranularParameters(parameters) {
+        const [east, north, west, south] = parameters.bbox;
+        return { ...parameters, east, north, south, west };
+      }
+      getURLFromTemplate(parameters) {
+        let url = this.props.url;
+        for (const [key, value] of Object.entries(parameters)) {
+          url = url.replace(`\${${key}}`, String(value));
+          url = url.replace(`{${key}}`, String(value));
+        }
+        return url;
+      }
     };
+    ImageService.type = "template";
+    ImageService.testURL = (url) => url.toLowerCase().includes("{");
   }
 });
 
@@ -2266,12 +2326,13 @@ var init_wms_layer_description_loader = __esm({
   }
 });
 
-// src/lib/data-sources/wms-service.ts
+// src/lib/data-sources/image-services/wms-service.ts
 var WMSService;
 var init_wms_service = __esm({
-  "src/lib/data-sources/wms-service.ts"() {
+  "src/lib/data-sources/image-services/wms-service.ts"() {
     init_src3();
     init_image_source();
+    init_image_service();
     init_wms_capabilities_loader();
     init_wms_feature_info_loader();
     init_wms_layer_description_loader();
@@ -2279,9 +2340,7 @@ var init_wms_service = __esm({
     WMSService = class extends ImageSource {
       constructor(props) {
         super();
-        this.loadOptions = {
-          wms: { throwOnError: true }
-        };
+        this.capabilities = null;
         this.loaders = [
           ImageLoader,
           WMSErrorLoader,
@@ -2289,9 +2348,12 @@ var init_wms_service = __esm({
           WMSFeatureInfoLoader,
           WMSLayerDescriptionLoader
         ];
-        this.serviceUrl = props.serviceUrl;
-        Object.assign(this.loadOptions, props.loadOptions);
-        this.fetch = props.fetch || fetch;
+        this.props = mergeImageServiceProps(props);
+        this.fetch = getFetchFunction(this.props);
+        this.props.loadOptions = {
+          ...this.props.loadOptions,
+          wms: { ...this.props.loadOptions?.wms, throwOnError: true }
+        };
       }
       getMetadata() {
         return this.getCapabilities();
@@ -2301,45 +2363,53 @@ var init_wms_service = __esm({
       }
       async getCapabilities(wmsParameters, vendorParameters) {
         const url = this.getCapabilitiesURL(wmsParameters, vendorParameters);
-        const { fetch: fetch2 } = this;
-        const response = await fetch2(url, this.loadOptions);
+        const response = await this.fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         this._checkResponse(response, arrayBuffer);
-        return await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
+        const capabilities = await WMSCapabilitiesLoader.parse(arrayBuffer, this.props.loadOptions);
+        this.capabilities = capabilities;
+        return capabilities;
       }
       async getMap(options, vendorParameters) {
         const url = this.getMapURL(options, vendorParameters);
-        const { fetch: fetch2 } = this;
-        const response = await fetch2(url, this.loadOptions);
+        const response = await this.fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         this._checkResponse(response, arrayBuffer);
         try {
-          return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+          return await ImageLoader.parse(arrayBuffer, this.props.loadOptions);
         } catch {
           throw this._parseError(arrayBuffer);
         }
       }
       async getFeatureInfo(options, vendorParameters) {
         const url = this.getFeatureInfoURL(options, vendorParameters);
-        const response = await this.fetch(url, this.loadOptions);
+        const response = await this.fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         this._checkResponse(response, arrayBuffer);
-        return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
+        return await WMSFeatureInfoLoader.parse(arrayBuffer, this.props.loadOptions);
+      }
+      async getFeatureInfoText(options, vendorParameters) {
+        options = { ...options, info_format: "text/plain" };
+        const url = this.getFeatureInfoURL(options, vendorParameters);
+        const response = await this.fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        this._checkResponse(response, arrayBuffer);
+        return new TextDecoder().decode(arrayBuffer);
       }
       async describeLayer(options, vendorParameters) {
         const url = this.describeLayerURL(options, vendorParameters);
-        const response = await this.fetch(url, this.loadOptions);
+        const response = await this.fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         this._checkResponse(response, arrayBuffer);
-        return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
+        return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.props.loadOptions);
       }
       async getLegendGraphic(options, vendorParameters) {
         const url = this.getLegendGraphicURL(options, vendorParameters);
-        const response = await this.fetch(url, this.loadOptions);
+        const response = await this.fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         this._checkResponse(response, arrayBuffer);
         try {
-          return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+          return await ImageLoader.parse(arrayBuffer, this.props.loadOptions);
         } catch {
           throw this._parseError(arrayBuffer);
         }
@@ -2402,7 +2472,7 @@ var init_wms_service = __esm({
         return this._getWMSUrl(options, vendorParameters);
       }
       _getWMSUrl(options, vendorParameters) {
-        let url = `${this.serviceUrl}`;
+        let url = this.props.url;
         let first = true;
         for (const [key, value] of Object.entries(options)) {
           url += first ? "?" : "&";
@@ -2418,51 +2488,103 @@ var init_wms_service = __esm({
       _checkResponse(response, arrayBuffer) {
         const contentType = response.headers["content-type"];
         if (!response.ok || WMSErrorLoader.mimeTypes.includes(contentType)) {
-          const error = WMSErrorLoader.parseSync(arrayBuffer, this.loadOptions);
+          const error = WMSErrorLoader.parseSync(arrayBuffer, this.props.loadOptions);
           throw new Error(error);
         }
       }
       _parseError(arrayBuffer) {
-        const error = WMSErrorLoader.parseSync(arrayBuffer, this.loadOptions);
+        const error = WMSErrorLoader.parseSync(arrayBuffer, this.props.loadOptions);
         return new Error(error);
       }
     };
+    WMSService.type = "wms";
+    WMSService.testURL = (url) => url.toLowerCase().includes("wms");
   }
 });
 
-// src/lib/data-sources/adhoc-image-service.ts
-var AdHocImageService;
-var init_adhoc_image_service = __esm({
-  "src/lib/data-sources/adhoc-image-service.ts"() {
-    init_src3();
+// src/lib/data-sources/image-services/arcgis-image-service.ts
+var ArcGISImageService;
+var init_arcgis_image_service = __esm({
+  "src/lib/data-sources/image-services/arcgis-image-service.ts"() {
     init_image_source();
-    AdHocImageService = class extends ImageSource {
+    init_image_service();
+    ArcGISImageService = class extends ImageSource {
       constructor(props) {
         super();
-        this.templateUrl = props.templateUrl;
+        this.props = mergeImageServiceProps(props);
+        this.fetch = getFetchFunction(this.props);
       }
       async getMetadata() {
-        throw new Error("ImageSource.getMetadata not implemented");
+        return await this.info();
       }
       async getImage(parameters) {
-        const granularParameters = this.getGranularParameters(parameters);
-        const url = this.getURLFromTemplate(granularParameters);
-        const response = await fetch(url);
-        const arrayBuffer = await response.arrayBuffer();
-        return await ImageLoader.parse(arrayBuffer);
+        throw new Error("not implemented");
       }
-      getGranularParameters(parameters) {
-        const [east, north, west, south] = parameters.bbox;
-        return { ...parameters, east, north, south, west };
+      async info() {
+        throw new Error("not implemented");
       }
-      getURLFromTemplate(parameters) {
-        let url = this.templateUrl;
-        for (const [key, value] of Object.entries(parameters)) {
-          url = url.replace(`\${${key}}`, String(value));
+      exportImage(options) {
+        throw new Error("not implemented");
+      }
+      infoURL(options) {
+        return this.props.url;
+      }
+      exportImageURL(options) {
+        return this.props.url;
+      }
+      getUrl(options, extra) {
+        let url = `${this.props.url}`;
+        let first = true;
+        for (const [key, value] of Object.entries(options)) {
+          url += first ? "?" : "&";
+          first = false;
+          if (Array.isArray(value)) {
+            url += `${key.toUpperCase()}=${value.join(",")}`;
+          } else {
+            url += `${key.toUpperCase()}=${value ? String(value) : ""}`;
+          }
         }
         return url;
       }
+      async checkResponse(response) {
+        if (!response.ok) {
+          throw new Error("error");
+        }
+      }
     };
+    ArcGISImageService.type = "arcgis-image-server";
+    ArcGISImageService.testURL = (url) => url.toLowerCase().includes("ImageServer");
+  }
+});
+
+// src/lib/data-sources/create-image-source.ts
+function createImageSource(props) {
+  const { type = "auto" } = props;
+  const serviceType = type === "auto" ? guessServiceType(props.url) : type;
+  switch (serviceType) {
+    case "template":
+      return new ImageService(props);
+    case "wms":
+      return new WMSService(props);
+    default:
+      throw new Error("Not a valid image source type");
+  }
+}
+function guessServiceType(url) {
+  for (const Service of SERVICES) {
+    if (Service.testURL && Service.testURL(url)) {
+      return Service.type;
+    }
+  }
+  return "wms";
+}
+var SERVICES;
+var init_create_image_source = __esm({
+  "src/lib/data-sources/create-image-source.ts"() {
+    init_image_service();
+    init_wms_service();
+    init_arcgis_image_service();
+    SERVICES = [WMSService, ArcGISImageService, ImageService];
   }
 });
 
@@ -4187,1006 +4309,36 @@ var init_gml_loader = __esm({
   }
 });
 
-// ../../node_modules/lerc/LercDecode.js
-var require_LercDecode = __commonJS({
-  "../../node_modules/lerc/LercDecode.js"(exports2, module2) {
-    (function(global2, factory) {
-      typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.Lerc = {}));
-    })(exports2, function(exports3) {
-      "use strict";
-      var Module = (() => {
-        var _scriptDir = typeof document === "undefined" && typeof location === "undefined" ? new (require("url")).URL("file:" + __filename).href : typeof document === "undefined" ? location.href : document.currentScript && document.currentScript.src || new URL("LercDecode.js", document.baseURI).href;
-        return function(Module2) {
-          Module2 = Module2 || {};
-          var Module2 = typeof Module2 != "undefined" ? Module2 : {};
-          var readyPromiseResolve, readyPromiseReject;
-          Module2["ready"] = new Promise(function(resolve, reject) {
-            readyPromiseResolve = resolve;
-            readyPromiseReject = reject;
-          });
-          var moduleOverrides = Object.assign({}, Module2);
-          var ENVIRONMENT_IS_WEB = typeof window == "object";
-          var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
-          var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
-          var scriptDirectory = "";
-          function locateFile(path) {
-            if (Module2["locateFile"]) {
-              return Module2["locateFile"](path, scriptDirectory);
-            }
-            return scriptDirectory + path;
-          }
-          var read_, readAsync, readBinary;
-          var fs;
-          var nodePath;
-          var requireNodeFS;
-          if (ENVIRONMENT_IS_NODE) {
-            if (ENVIRONMENT_IS_WORKER) {
-              scriptDirectory = require("path").dirname(scriptDirectory) + "/";
-            } else {
-              scriptDirectory = __dirname + "/";
-            }
-            requireNodeFS = () => {
-              if (!nodePath) {
-                fs = require("fs");
-                nodePath = require("path");
-              }
-            };
-            read_ = function shell_read(filename, binary) {
-              requireNodeFS();
-              filename = nodePath["normalize"](filename);
-              return fs.readFileSync(filename, binary ? void 0 : "utf8");
-            };
-            readBinary = (filename) => {
-              var ret = read_(filename, true);
-              if (!ret.buffer) {
-                ret = new Uint8Array(ret);
-              }
-              return ret;
-            };
-            readAsync = (filename, onload, onerror) => {
-              requireNodeFS();
-              filename = nodePath["normalize"](filename);
-              fs.readFile(filename, function(err2, data) {
-                if (err2)
-                  onerror(err2);
-                else
-                  onload(data.buffer);
-              });
-            };
-            if (process["argv"].length > 1) {
-              process["argv"][1].replace(/\\/g, "/");
-            }
-            process["argv"].slice(2);
-            process["on"]("uncaughtException", function(ex) {
-              if (!(ex instanceof ExitStatus)) {
-                throw ex;
-              }
-            });
-            process["on"]("unhandledRejection", function(reason) {
-              throw reason;
-            });
-            Module2["inspect"] = function() {
-              return "[Emscripten Module object]";
-            };
-          } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-            if (ENVIRONMENT_IS_WORKER) {
-              scriptDirectory = self.location.href;
-            } else if (typeof document != "undefined" && document.currentScript) {
-              scriptDirectory = document.currentScript.src;
-            }
-            if (_scriptDir) {
-              scriptDirectory = _scriptDir;
-            }
-            if (scriptDirectory.indexOf("blob:") !== 0) {
-              scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
-            } else {
-              scriptDirectory = "";
-            }
-            {
-              read_ = (url) => {
-                var xhr = new XMLHttpRequest();
-                xhr.open("GET", url, false);
-                xhr.send(null);
-                return xhr.responseText;
-              };
-              if (ENVIRONMENT_IS_WORKER) {
-                readBinary = (url) => {
-                  var xhr = new XMLHttpRequest();
-                  xhr.open("GET", url, false);
-                  xhr.responseType = "arraybuffer";
-                  xhr.send(null);
-                  return new Uint8Array(xhr.response);
-                };
-              }
-              readAsync = (url, onload, onerror) => {
-                var xhr = new XMLHttpRequest();
-                xhr.open("GET", url, true);
-                xhr.responseType = "arraybuffer";
-                xhr.onload = () => {
-                  if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    onload(xhr.response);
-                    return;
-                  }
-                  onerror();
-                };
-                xhr.onerror = onerror;
-                xhr.send(null);
-              };
-            }
-          } else
-            ;
-          Module2["print"] || console.log.bind(console);
-          var err = Module2["printErr"] || console.warn.bind(console);
-          Object.assign(Module2, moduleOverrides);
-          moduleOverrides = null;
-          if (Module2["arguments"])
-            ;
-          if (Module2["thisProgram"])
-            ;
-          if (Module2["quit"])
-            ;
-          var wasmBinary;
-          if (Module2["wasmBinary"])
-            wasmBinary = Module2["wasmBinary"];
-          Module2["noExitRuntime"] || true;
-          if (typeof WebAssembly != "object") {
-            abort("no native wasm support detected");
-          }
-          var wasmMemory;
-          var ABORT = false;
-          var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
-          function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
-            var endIdx = idx + maxBytesToRead;
-            var endPtr = idx;
-            while (heapOrArray[endPtr] && !(endPtr >= endIdx))
-              ++endPtr;
-            if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-              return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-            } else {
-              var str = "";
-              while (idx < endPtr) {
-                var u0 = heapOrArray[idx++];
-                if (!(u0 & 128)) {
-                  str += String.fromCharCode(u0);
-                  continue;
-                }
-                var u1 = heapOrArray[idx++] & 63;
-                if ((u0 & 224) == 192) {
-                  str += String.fromCharCode((u0 & 31) << 6 | u1);
-                  continue;
-                }
-                var u2 = heapOrArray[idx++] & 63;
-                if ((u0 & 240) == 224) {
-                  u0 = (u0 & 15) << 12 | u1 << 6 | u2;
-                } else {
-                  u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
-                }
-                if (u0 < 65536) {
-                  str += String.fromCharCode(u0);
-                } else {
-                  var ch = u0 - 65536;
-                  str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-                }
-              }
-            }
-            return str;
-          }
-          function UTF8ToString(ptr, maxBytesToRead) {
-            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
-          }
-          var buffer, HEAP8, HEAPU8, HEAP32, HEAPU32;
-          function updateGlobalBufferAndViews(buf) {
-            buffer = buf;
-            Module2["HEAP8"] = HEAP8 = new Int8Array(buf);
-            Module2["HEAP16"] = new Int16Array(buf);
-            Module2["HEAP32"] = HEAP32 = new Int32Array(buf);
-            Module2["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
-            Module2["HEAPU16"] = new Uint16Array(buf);
-            Module2["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
-            Module2["HEAPF32"] = new Float32Array(buf);
-            Module2["HEAPF64"] = new Float64Array(buf);
-          }
-          Module2["INITIAL_MEMORY"] || 16777216;
-          var wasmTable;
-          var __ATPRERUN__ = [];
-          var __ATINIT__ = [];
-          var __ATPOSTRUN__ = [];
-          function preRun() {
-            if (Module2["preRun"]) {
-              if (typeof Module2["preRun"] == "function")
-                Module2["preRun"] = [Module2["preRun"]];
-              while (Module2["preRun"].length) {
-                addOnPreRun(Module2["preRun"].shift());
-              }
-            }
-            callRuntimeCallbacks(__ATPRERUN__);
-          }
-          function initRuntime() {
-            callRuntimeCallbacks(__ATINIT__);
-          }
-          function postRun() {
-            if (Module2["postRun"]) {
-              if (typeof Module2["postRun"] == "function")
-                Module2["postRun"] = [Module2["postRun"]];
-              while (Module2["postRun"].length) {
-                addOnPostRun(Module2["postRun"].shift());
-              }
-            }
-            callRuntimeCallbacks(__ATPOSTRUN__);
-          }
-          function addOnPreRun(cb) {
-            __ATPRERUN__.unshift(cb);
-          }
-          function addOnInit(cb) {
-            __ATINIT__.unshift(cb);
-          }
-          function addOnPostRun(cb) {
-            __ATPOSTRUN__.unshift(cb);
-          }
-          var runDependencies = 0;
-          var dependenciesFulfilled = null;
-          function addRunDependency(id) {
-            runDependencies++;
-            if (Module2["monitorRunDependencies"]) {
-              Module2["monitorRunDependencies"](runDependencies);
-            }
-          }
-          function removeRunDependency(id) {
-            runDependencies--;
-            if (Module2["monitorRunDependencies"]) {
-              Module2["monitorRunDependencies"](runDependencies);
-            }
-            if (runDependencies == 0) {
-              if (dependenciesFulfilled) {
-                var callback = dependenciesFulfilled;
-                dependenciesFulfilled = null;
-                callback();
-              }
-            }
-          }
-          function abort(what) {
-            {
-              if (Module2["onAbort"]) {
-                Module2["onAbort"](what);
-              }
-            }
-            what = "Aborted(" + what + ")";
-            err(what);
-            ABORT = true;
-            what += ". Build with -sASSERTIONS for more info.";
-            var e = new WebAssembly.RuntimeError(what);
-            readyPromiseReject(e);
-            throw e;
-          }
-          var dataURIPrefix = "data:application/octet-stream;base64,";
-          function isDataURI(filename) {
-            return filename.startsWith(dataURIPrefix);
-          }
-          function isFileURI(filename) {
-            return filename.startsWith("file://");
-          }
-          var wasmBinaryFile;
-          if (Module2["locateFile"]) {
-            wasmBinaryFile = "lerc-wasm.wasm";
-            if (!isDataURI(wasmBinaryFile)) {
-              wasmBinaryFile = locateFile(wasmBinaryFile);
-            }
-          } else {
-            wasmBinaryFile = new URL("lerc-wasm.wasm", typeof document === "undefined" && typeof location === "undefined" ? new (require("url")).URL("file:" + __filename).href : typeof document === "undefined" ? location.href : document.currentScript && document.currentScript.src || new URL("LercDecode.js", document.baseURI).href).toString();
-          }
-          function getBinary(file) {
-            try {
-              if (file == wasmBinaryFile && wasmBinary) {
-                return new Uint8Array(wasmBinary);
-              }
-              if (readBinary) {
-                return readBinary(file);
-              } else {
-                throw "both async and sync fetching of the wasm failed";
-              }
-            } catch (err2) {
-              abort(err2);
-            }
-          }
-          function getBinaryPromise() {
-            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
-              if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) {
-                return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
-                  if (!response["ok"]) {
-                    throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
-                  }
-                  return response["arrayBuffer"]();
-                }).catch(function() {
-                  return getBinary(wasmBinaryFile);
-                });
-              } else {
-                if (readAsync) {
-                  return new Promise(function(resolve, reject) {
-                    readAsync(wasmBinaryFile, function(response) {
-                      resolve(new Uint8Array(response));
-                    }, reject);
-                  });
-                }
-              }
-            }
-            return Promise.resolve().then(function() {
-              return getBinary(wasmBinaryFile);
-            });
-          }
-          function createWasm() {
-            var info = { "a": asmLibraryArg };
-            function receiveInstance(instance, module3) {
-              var exports5 = instance.exports;
-              Module2["asm"] = exports5;
-              wasmMemory = Module2["asm"]["g"];
-              updateGlobalBufferAndViews(wasmMemory.buffer);
-              wasmTable = Module2["asm"]["m"];
-              addOnInit(Module2["asm"]["h"]);
-              removeRunDependency();
-            }
-            addRunDependency();
-            function receiveInstantiationResult(result) {
-              receiveInstance(result["instance"]);
-            }
-            function instantiateArrayBuffer(receiver) {
-              return getBinaryPromise().then(function(binary) {
-                return WebAssembly.instantiate(binary, info);
-              }).then(function(instance) {
-                return instance;
-              }).then(receiver, function(reason) {
-                err("failed to asynchronously prepare wasm: " + reason);
-                abort(reason);
-              });
-            }
-            function instantiateAsync() {
-              if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
-                return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
-                  var result = WebAssembly.instantiateStreaming(response, info);
-                  return result.then(receiveInstantiationResult, function(reason) {
-                    err("wasm streaming compile failed: " + reason);
-                    err("falling back to ArrayBuffer instantiation");
-                    return instantiateArrayBuffer(receiveInstantiationResult);
-                  });
-                });
-              } else {
-                return instantiateArrayBuffer(receiveInstantiationResult);
-              }
-            }
-            if (Module2["instantiateWasm"]) {
-              try {
-                var exports4 = Module2["instantiateWasm"](info, receiveInstance);
-                return exports4;
-              } catch (e) {
-                err("Module.instantiateWasm callback failed with error: " + e);
-                return false;
-              }
-            }
-            instantiateAsync().catch(readyPromiseReject);
-            return {};
-          }
-          function callRuntimeCallbacks(callbacks) {
-            while (callbacks.length > 0) {
-              var callback = callbacks.shift();
-              if (typeof callback == "function") {
-                callback(Module2);
-                continue;
-              }
-              var func = callback.func;
-              if (typeof func == "number") {
-                if (callback.arg === void 0) {
-                  getWasmTableEntry(func)();
-                } else {
-                  getWasmTableEntry(func)(callback.arg);
-                }
-              } else {
-                func(callback.arg === void 0 ? null : callback.arg);
-              }
-            }
-          }
-          var wasmTableMirror = [];
-          function getWasmTableEntry(funcPtr) {
-            var func = wasmTableMirror[funcPtr];
-            if (!func) {
-              if (funcPtr >= wasmTableMirror.length)
-                wasmTableMirror.length = funcPtr + 1;
-              wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
-            }
-            return func;
-          }
-          function ___assert_fail(condition, filename, line, func) {
-            abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
-          }
-          function ___cxa_allocate_exception(size) {
-            return _malloc(size + 24) + 24;
-          }
-          function ExceptionInfo(excPtr) {
-            this.excPtr = excPtr;
-            this.ptr = excPtr - 24;
-            this.set_type = function(type) {
-              HEAPU32[this.ptr + 4 >> 2] = type;
-            };
-            this.get_type = function() {
-              return HEAPU32[this.ptr + 4 >> 2];
-            };
-            this.set_destructor = function(destructor) {
-              HEAPU32[this.ptr + 8 >> 2] = destructor;
-            };
-            this.get_destructor = function() {
-              return HEAPU32[this.ptr + 8 >> 2];
-            };
-            this.set_refcount = function(refcount) {
-              HEAP32[this.ptr >> 2] = refcount;
-            };
-            this.set_caught = function(caught) {
-              caught = caught ? 1 : 0;
-              HEAP8[this.ptr + 12 >> 0] = caught;
-            };
-            this.get_caught = function() {
-              return HEAP8[this.ptr + 12 >> 0] != 0;
-            };
-            this.set_rethrown = function(rethrown) {
-              rethrown = rethrown ? 1 : 0;
-              HEAP8[this.ptr + 13 >> 0] = rethrown;
-            };
-            this.get_rethrown = function() {
-              return HEAP8[this.ptr + 13 >> 0] != 0;
-            };
-            this.init = function(type, destructor) {
-              this.set_adjusted_ptr(0);
-              this.set_type(type);
-              this.set_destructor(destructor);
-              this.set_refcount(0);
-              this.set_caught(false);
-              this.set_rethrown(false);
-            };
-            this.add_ref = function() {
-              var value = HEAP32[this.ptr >> 2];
-              HEAP32[this.ptr >> 2] = value + 1;
-            };
-            this.release_ref = function() {
-              var prev = HEAP32[this.ptr >> 2];
-              HEAP32[this.ptr >> 2] = prev - 1;
-              return prev === 1;
-            };
-            this.set_adjusted_ptr = function(adjustedPtr) {
-              HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
-            };
-            this.get_adjusted_ptr = function() {
-              return HEAPU32[this.ptr + 16 >> 2];
-            };
-            this.get_exception_ptr = function() {
-              var isPointer = ___cxa_is_pointer_type(this.get_type());
-              if (isPointer) {
-                return HEAPU32[this.excPtr >> 2];
-              }
-              var adjusted = this.get_adjusted_ptr();
-              if (adjusted !== 0)
-                return adjusted;
-              return this.excPtr;
-            };
-          }
-          function ___cxa_throw(ptr, type, destructor) {
-            var info = new ExceptionInfo(ptr);
-            info.init(type, destructor);
-            throw ptr;
-          }
-          function _abort() {
-            abort("");
-          }
-          function _emscripten_memcpy_big(dest, src, num) {
-            HEAPU8.copyWithin(dest, src, src + num);
-          }
-          function getHeapMax() {
-            return 2147483648;
-          }
-          function emscripten_realloc_buffer(size) {
-            try {
-              wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
-              updateGlobalBufferAndViews(wasmMemory.buffer);
-              return 1;
-            } catch (e) {
-            }
-          }
-          function _emscripten_resize_heap(requestedSize) {
-            var oldSize = HEAPU8.length;
-            requestedSize = requestedSize >>> 0;
-            var maxHeapSize = getHeapMax();
-            if (requestedSize > maxHeapSize) {
-              return false;
-            }
-            let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
-            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-              var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-              overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
-              var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
-              var replacement = emscripten_realloc_buffer(newSize);
-              if (replacement) {
-                return true;
-              }
-            }
-            return false;
-          }
-          var asmLibraryArg = { "a": ___assert_fail, "c": ___cxa_allocate_exception, "b": ___cxa_throw, "d": _abort, "f": _emscripten_memcpy_big, "e": _emscripten_resize_heap };
-          createWasm();
-          Module2["___wasm_call_ctors"] = function() {
-            return (Module2["___wasm_call_ctors"] = Module2["asm"]["h"]).apply(null, arguments);
-          };
-          Module2["_lerc_getBlobInfo"] = function() {
-            return (Module2["_lerc_getBlobInfo"] = Module2["asm"]["i"]).apply(null, arguments);
-          };
-          Module2["_lerc_getDataRanges"] = function() {
-            return (Module2["_lerc_getDataRanges"] = Module2["asm"]["j"]).apply(null, arguments);
-          };
-          Module2["_lerc_decode"] = function() {
-            return (Module2["_lerc_decode"] = Module2["asm"]["k"]).apply(null, arguments);
-          };
-          Module2["_lerc_decode_4D"] = function() {
-            return (Module2["_lerc_decode_4D"] = Module2["asm"]["l"]).apply(null, arguments);
-          };
-          var _malloc = Module2["_malloc"] = function() {
-            return (_malloc = Module2["_malloc"] = Module2["asm"]["n"]).apply(null, arguments);
-          };
-          Module2["_free"] = function() {
-            return (Module2["_free"] = Module2["asm"]["o"]).apply(null, arguments);
-          };
-          var ___cxa_is_pointer_type = Module2["___cxa_is_pointer_type"] = function() {
-            return (___cxa_is_pointer_type = Module2["___cxa_is_pointer_type"] = Module2["asm"]["p"]).apply(null, arguments);
-          };
-          var calledRun;
-          function ExitStatus(status) {
-            this.name = "ExitStatus";
-            this.message = "Program terminated with exit(" + status + ")";
-            this.status = status;
-          }
-          dependenciesFulfilled = function runCaller() {
-            if (!calledRun)
-              run();
-            if (!calledRun)
-              dependenciesFulfilled = runCaller;
-          };
-          function run(args) {
-            if (runDependencies > 0) {
-              return;
-            }
-            preRun();
-            if (runDependencies > 0) {
-              return;
-            }
-            function doRun() {
-              if (calledRun)
-                return;
-              calledRun = true;
-              Module2["calledRun"] = true;
-              if (ABORT)
-                return;
-              initRuntime();
-              readyPromiseResolve(Module2);
-              if (Module2["onRuntimeInitialized"])
-                Module2["onRuntimeInitialized"]();
-              postRun();
-            }
-            if (Module2["setStatus"]) {
-              Module2["setStatus"]("Running...");
-              setTimeout(function() {
-                setTimeout(function() {
-                  Module2["setStatus"]("");
-                }, 1);
-                doRun();
-              }, 1);
-            } else {
-              doRun();
-            }
-          }
-          Module2["run"] = run;
-          if (Module2["preInit"]) {
-            if (typeof Module2["preInit"] == "function")
-              Module2["preInit"] = [Module2["preInit"]];
-            while (Module2["preInit"].length > 0) {
-              Module2["preInit"].pop()();
-            }
-          }
-          run();
-          return Module2.ready;
-        };
-      })();
-      const pixelTypeInfoMap = [
-        {
-          pixelType: "S8",
-          size: 1,
-          ctor: Int8Array,
-          range: [-128, 128]
-        },
-        {
-          pixelType: "U8",
-          size: 1,
-          ctor: Uint8Array,
-          range: [0, 255]
-        },
-        {
-          pixelType: "S16",
-          size: 2,
-          ctor: Int16Array,
-          range: [-32768, 32767]
-        },
-        {
-          pixelType: "U16",
-          size: 2,
-          ctor: Uint16Array,
-          range: [0, 65536]
-        },
-        {
-          pixelType: "S32",
-          size: 4,
-          ctor: Int32Array,
-          range: [-2147483648, 2147483647]
-        },
-        {
-          pixelType: "U32",
-          size: 4,
-          ctor: Uint32Array,
-          range: [0, 4294967296]
-        },
-        {
-          pixelType: "F32",
-          size: 4,
-          ctor: Float32Array,
-          range: [-34027999387901484e22, 34027999387901484e22]
-        },
-        {
-          pixelType: "F64",
-          size: 8,
-          ctor: Float64Array,
-          range: [-17976931348623157e292, 17976931348623157e292]
-        }
-      ];
-      let loadPromise = null;
-      let loaded = false;
-      function load2(options = {}) {
-        if (loadPromise) {
-          return loadPromise;
-        }
-        const locateFile = options.locateFile || ((wasmFileName, scriptDir) => `${scriptDir}${wasmFileName}`);
-        loadPromise = Module({ locateFile }).then((lercFactory) => lercFactory.ready.then(() => {
-          initLercLib(lercFactory);
-          loaded = true;
-        }));
-        return loadPromise;
-      }
-      function isLoaded() {
-        return loaded;
-      }
-      const lercLib = {
-        getBlobInfo: null,
-        decode: null
-      };
-      function normalizeByteLength(n) {
-        return (n >> 3 << 3) + 16;
-      }
-      function copyBytesFromWasm(wasmHeapU8, ptr_data, data) {
-        data.set(wasmHeapU8.slice(ptr_data, ptr_data + data.length));
-      }
-      function initLercLib(lercFactory) {
-        const { _malloc, _free, _lerc_getBlobInfo, _lerc_getDataRanges, _lerc_decode_4D, asm } = lercFactory;
-        let heapU8;
-        const memory = Object.values(asm).find((val) => val && "buffer" in val && val.buffer === lercFactory.HEAPU8.buffer);
-        const mallocMultiple = (byteLengths) => {
-          const lens = byteLengths.map((len) => normalizeByteLength(len));
-          const byteLength = lens.reduce((a, b) => a + b);
-          const ret = _malloc(byteLength);
-          heapU8 = new Uint8Array(memory.buffer);
-          let prev = lens[0];
-          lens[0] = ret;
-          for (let i = 1; i < lens.length; i++) {
-            const next = lens[i];
-            lens[i] = lens[i - 1] + prev;
-            prev = next;
-          }
-          return lens;
-        };
-        lercLib.getBlobInfo = (blob) => {
-          const infoArrSize = 12;
-          const rangeArrSize = 3;
-          const infoArr = new Uint8Array(infoArrSize * 4);
-          const rangeArr = new Uint8Array(rangeArrSize * 8);
-          const [ptr, ptr_info, ptr_range] = mallocMultiple([blob.length, infoArr.length, rangeArr.length]);
-          heapU8.set(blob, ptr);
-          heapU8.set(infoArr, ptr_info);
-          heapU8.set(rangeArr, ptr_range);
-          let hr = _lerc_getBlobInfo(ptr, blob.length, ptr_info, ptr_range, infoArrSize, rangeArrSize);
-          if (hr) {
-            _free(ptr);
-            throw `lerc-getBlobInfo: error code is ${hr}`;
-          }
-          heapU8 = new Uint8Array(memory.buffer);
-          copyBytesFromWasm(heapU8, ptr_info, infoArr);
-          copyBytesFromWasm(heapU8, ptr_range, rangeArr);
-          const lercInfoArr = new Uint32Array(infoArr.buffer);
-          const statsArr = new Float64Array(rangeArr.buffer);
-          const [version, dataType, dimCount, width, height, bandCount, validPixelCount, blobSize, maskCount, depthCount, bandCountWithNoData] = lercInfoArr;
-          const headerInfo = {
-            version,
-            dimCount,
-            width,
-            height,
-            validPixelCount,
-            bandCount,
-            blobSize,
-            maskCount,
-            depthCount,
-            dataType,
-            minValue: statsArr[0],
-            maxValue: statsArr[1],
-            maxZerror: statsArr[2],
-            statistics: [],
-            bandCountWithNoData
-          };
-          if (bandCountWithNoData) {
-            return headerInfo;
-          }
-          if (depthCount === 1 && bandCount === 1) {
-            _free(ptr);
-            headerInfo.statistics.push({
-              minValue: statsArr[0],
-              maxValue: statsArr[1]
-            });
-            return headerInfo;
-          }
-          const numStatsBytes = depthCount * bandCount * 8;
-          const bandStatsMinArr = new Uint8Array(numStatsBytes);
-          const bandStatsMaxArr = new Uint8Array(numStatsBytes);
-          let ptr_blob = ptr, ptr_min = 0, ptr_max = 0, blob_freed = false;
-          if (heapU8.byteLength < ptr + numStatsBytes * 2) {
-            _free(ptr);
-            blob_freed = true;
-            [ptr_blob, ptr_min, ptr_max] = mallocMultiple([blob.length, numStatsBytes, numStatsBytes]);
-            heapU8.set(blob, ptr_blob);
-          } else {
-            [ptr_min, ptr_max] = mallocMultiple([numStatsBytes, numStatsBytes]);
-          }
-          heapU8.set(bandStatsMinArr, ptr_min);
-          heapU8.set(bandStatsMaxArr, ptr_max);
-          hr = _lerc_getDataRanges(ptr_blob, blob.length, depthCount, bandCount, ptr_min, ptr_max);
-          if (hr) {
-            _free(ptr_blob);
-            if (!blob_freed) {
-              _free(ptr_min);
-            }
-            throw `lerc-getDataRanges: error code is ${hr}`;
-          }
-          heapU8 = new Uint8Array(memory.buffer);
-          copyBytesFromWasm(heapU8, ptr_min, bandStatsMinArr);
-          copyBytesFromWasm(heapU8, ptr_max, bandStatsMaxArr);
-          const allMinValues = new Float64Array(bandStatsMinArr.buffer);
-          const allMaxValues = new Float64Array(bandStatsMaxArr.buffer);
-          const statistics = headerInfo.statistics;
-          for (let i = 0; i < bandCount; i++) {
-            if (depthCount > 1) {
-              const minValues = allMinValues.slice(i * depthCount, (i + 1) * depthCount);
-              const maxValues = allMaxValues.slice(i * depthCount, (i + 1) * depthCount);
-              const minValue = Math.min.apply(null, minValues);
-              const maxValue = Math.max.apply(null, maxValues);
-              statistics.push({
-                minValue,
-                maxValue,
-                dimStats: { minValues, maxValues },
-                depthStats: { minValues, maxValues }
-              });
-            } else {
-              statistics.push({
-                minValue: allMinValues[i],
-                maxValue: allMaxValues[i]
-              });
-            }
-          }
-          _free(ptr_blob);
-          if (!blob_freed) {
-            _free(ptr_min);
-          }
-          return headerInfo;
-        };
-        lercLib.decode = (blob, blobInfo) => {
-          const { maskCount, depthCount, bandCount, width, height, dataType, bandCountWithNoData } = blobInfo;
-          const pixelTypeInfo = pixelTypeInfoMap[dataType];
-          const numPixels = width * height;
-          const maskData = new Uint8Array(numPixels * bandCount);
-          const numDataBytes = numPixels * depthCount * bandCount * pixelTypeInfo.size;
-          const data = new Uint8Array(numDataBytes);
-          const useNoDataArr = new Uint8Array(bandCount);
-          const noDataArr = new Uint8Array(bandCount * 8);
-          const [ptr, ptr_mask, ptr_data, ptr_useNoData, ptr_noData] = mallocMultiple([
-            blob.length,
-            maskData.length,
-            data.length,
-            useNoDataArr.length,
-            noDataArr.length
-          ]);
-          heapU8.set(blob, ptr);
-          heapU8.set(maskData, ptr_mask);
-          heapU8.set(data, ptr_data);
-          heapU8.set(useNoDataArr, ptr_useNoData);
-          heapU8.set(noDataArr, ptr_noData);
-          const hr = _lerc_decode_4D(ptr, blob.length, maskCount, ptr_mask, depthCount, width, height, bandCount, dataType, ptr_data, ptr_useNoData, ptr_noData);
-          if (hr) {
-            _free(ptr);
-            throw `lerc-decode: error code is ${hr}`;
-          }
-          heapU8 = new Uint8Array(memory.buffer);
-          copyBytesFromWasm(heapU8, ptr_data, data);
-          copyBytesFromWasm(heapU8, ptr_mask, maskData);
-          let noDataValues = null;
-          if (bandCountWithNoData) {
-            copyBytesFromWasm(heapU8, ptr_useNoData, useNoDataArr);
-            copyBytesFromWasm(heapU8, ptr_noData, noDataArr);
-            noDataValues = [];
-            const noDataArr64 = new Float64Array(noDataArr.buffer);
-            for (let i = 0; i < useNoDataArr.length; i++) {
-              noDataValues.push(useNoDataArr[i] ? noDataArr64[i] : null);
-            }
-          }
-          _free(ptr);
-          return {
-            data,
-            maskData,
-            noDataValues
-          };
-        };
-      }
-      function swapDepthValuesOrder(pixels, numPixels, depthCount, OutPixelTypeArray, inputIsBIP) {
-        if (depthCount < 2) {
-          return pixels;
-        }
-        const swap = new OutPixelTypeArray(numPixels * depthCount);
-        if (inputIsBIP) {
-          for (let i = 0, j = 0; i < numPixels; i++) {
-            for (let iDim = 0, temp = i; iDim < depthCount; iDim++, temp += numPixels) {
-              swap[temp] = pixels[j++];
-            }
-          }
-        } else {
-          for (let i = 0, j = 0; i < numPixels; i++) {
-            for (let iDim = 0, temp = i; iDim < depthCount; iDim++, temp += numPixels) {
-              swap[j++] = pixels[temp];
-            }
-          }
-        }
-        return swap;
-      }
-      function decode2(input, options = {}) {
-        var _a, _b;
-        const inputOffset = (_a = options.inputOffset) !== null && _a !== void 0 ? _a : 0;
-        const blob = input instanceof Uint8Array ? input.subarray(inputOffset) : new Uint8Array(input, inputOffset);
-        const blobInfo = lercLib.getBlobInfo(blob);
-        const { data, maskData } = lercLib.decode(blob, blobInfo);
-        const { width, height, bandCount, dimCount, depthCount, dataType, maskCount, statistics } = blobInfo;
-        const pixelTypeInfo = pixelTypeInfoMap[dataType];
-        const data1 = new pixelTypeInfo.ctor(data.buffer);
-        const pixels = [];
-        const masks = [];
-        const numPixels = width * height;
-        const numElementsPerBand = numPixels * depthCount;
-        const swap = (_b = options.returnInterleaved) !== null && _b !== void 0 ? _b : options.returnPixelInterleavedDims;
-        for (let i = 0; i < bandCount; i++) {
-          const band = data1.subarray(i * numElementsPerBand, (i + 1) * numElementsPerBand);
-          if (swap) {
-            pixels.push(band);
-          } else {
-            const bsq = swapDepthValuesOrder(band, numPixels, depthCount, pixelTypeInfo.ctor, true);
-            pixels.push(bsq);
-          }
-          masks.push(maskData.subarray(i * numElementsPerBand, (i + 1) * numElementsPerBand));
-        }
-        const mask = maskCount === 0 ? null : maskCount === 1 ? masks[0] : new Uint8Array(numPixels);
-        if (maskCount > 1) {
-          mask.set(masks[0]);
-          for (let i = 1; i < masks.length; i++) {
-            const bandMask = masks[i];
-            for (let j = 0; j < numPixels; j++) {
-              mask[j] = mask[j] & bandMask[j];
-            }
-          }
-        }
-        const { noDataValue } = options;
-        const applyNoDataValue = noDataValue != null && pixelTypeInfo.range[0] <= noDataValue && pixelTypeInfo.range[1] >= noDataValue;
-        if (maskCount > 0 && applyNoDataValue) {
-          for (let i = 0; i < bandCount; i++) {
-            const band = pixels[i];
-            const bandMask = masks[i] || mask;
-            for (let j = 0; j < numPixels; j++) {
-              if (bandMask[j] === 0) {
-                band[j] = noDataValue;
-              }
-            }
-          }
-        }
-        const bandMasks = maskCount === bandCount && bandCount > 1 ? masks : null;
-        const { pixelType } = pixelTypeInfo;
-        return {
-          width,
-          height,
-          pixelType,
-          statistics,
-          pixels,
-          mask,
-          dimCount,
-          depthCount,
-          bandMasks
-        };
-      }
-      function getBlobInfo(input, options = {}) {
-        var _a;
-        const inputOffset = (_a = options.inputOffset) !== null && _a !== void 0 ? _a : 0;
-        const blob = input instanceof Uint8Array ? input.subarray(inputOffset) : new Uint8Array(input, inputOffset);
-        return lercLib.getBlobInfo(blob);
-      }
-      function getBandCount(input, options = {}) {
-        const info = getBlobInfo(input, options);
-        return info.bandCount;
-      }
-      exports3.decode = decode2;
-      exports3.getBandCount = getBandCount;
-      exports3.getBlobInfo = getBlobInfo;
-      exports3.isLoaded = isLoaded;
-      exports3.load = load2;
-      Object.defineProperty(exports3, "__esModule", { value: true });
-    });
-  }
-});
-
-// src/lerc-loader.ts
-async function parseLERC(arrayBuffer, options) {
-  await Lerc.load();
-  const pixelBlock = Lerc.decode(arrayBuffer, options?.lerc);
-  return pixelBlock;
-}
-var Lerc, VERSION8, LERCLoader;
-var init_lerc_loader = __esm({
-  "src/lerc-loader.ts"() {
-    Lerc = __toModule(require_LercDecode());
-    VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    LERCLoader = {
-      id: "lerc",
-      name: "LERC",
-      module: "wms",
-      version: VERSION8,
-      worker: false,
-      extensions: ["lrc", "lerc", "lerc2", "lerc1"],
-      mimeTypes: ["application/octet-stream"],
-      options: {
-        wms: {}
-      },
-      parse: async (arrayBuffer, options) => parseLERC(arrayBuffer, options)
-    };
-  }
-});
-
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  LERCLoader: () => LERCLoader,
+  ImageService: () => ImageService,
+  ImageSource: () => ImageSource,
   WMSCapabilitiesLoader: () => WMSCapabilitiesLoader,
   WMSErrorLoader: () => WMSErrorLoader,
   WMSService: () => WMSService,
-  _AdHocImageService: () => AdHocImageService,
+  _ArcGISImageService: () => ArcGISImageService,
   _GMLLoader: () => GMLLoader,
-  _ImageSource: () => ImageSource,
   _WFSCapabilitiesLoader: () => WFSCapabilitiesLoader,
   _WMSFeatureInfoLoader: () => WMSFeatureInfoLoader,
   _WMSLayerDescriptionLoader: () => WMSLayerDescriptionLoader,
-  _WMTSCapabilitiesLoader: () => WMTSCapabilitiesLoader
+  _WMTSCapabilitiesLoader: () => WMTSCapabilitiesLoader,
+  createImageSource: () => createImageSource
 });
 var init_src4 = __esm({
   "src/index.ts"() {
     init_wms_error_loader();
     init_wms_capabilities_loader();
-    init_wms_service();
     init_image_source();
-    init_adhoc_image_service();
+    init_create_image_source();
+    init_image_service();
+    init_wms_service();
+    init_arcgis_image_service();
     init_wms_feature_info_loader();
     init_wms_layer_description_loader();
     init_wmts_capabilities_loader();
     init_wfs_capabilities_loader();
     init_gml_loader();
-    init_lerc_loader();
   }
 });
 
@@ -5194,19 +4346,3 @@ var init_src4 = __esm({
 var moduleExports = (init_src4(), src_exports);
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
-/*! Lerc 4.0
-Copyright 2015 - 2022 Esri
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-A local copy of the license and additional notices are located with the
-source distribution at:
-http://github.com/Esri/lerc/
-Contributors:  Thomas Maurer, Wenxue Ju
-*/