@loaders.gl/wms 3.3.0-alpha.8 → 3.3.0-alpha.9

package/dist/dist.min.js

@@ -38,7 +38,7 @@
       var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
       var regexName = new RegExp("^" + nameRegexp + "$");
       var getAllMatches = function(string, regex) {
-        const matches = [];
+        const matches2 = [];
         let match = regex.exec(string);
         while (match) {
           const allmatches = [];
@@ -47,10 +47,10 @@
           for (let index = 0; index < len; index++) {
             allmatches.push(match[index]);
           }
-          matches.push(allmatches);
+          matches2.push(allmatches);
           match = regex.exec(string);
         }
-        return matches;
+        return matches2;
       };
       var isName = function(string) {
         const match = regexName.exec(string);
@@ -311,24 +311,24 @@
       }
       var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
       function validateAttributeString(attrStr, options) {
-        const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
+        const matches2 = util.getAllMatches(attrStr, validAttrStrRegxp);
         const attrNames = {};
-        for (let i = 0; i < matches.length; i++) {
-          if (matches[i][1].length === 0) {
-            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
-          } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
-            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
-          } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
-            return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
+        for (let i = 0; i < matches2.length; i++) {
+          if (matches2[i][1].length === 0) {
+            return getErrorObject("InvalidAttr", "Attribute '" + matches2[i][2] + "' has no space in starting.", getPositionFromMatch(matches2[i]));
+          } else if (matches2[i][3] !== void 0 && matches2[i][4] === void 0) {
+            return getErrorObject("InvalidAttr", "Attribute '" + matches2[i][2] + "' is without value.", getPositionFromMatch(matches2[i]));
+          } else if (matches2[i][3] === void 0 && !options.allowBooleanAttributes) {
+            return getErrorObject("InvalidAttr", "boolean attribute '" + matches2[i][2] + "' is not allowed.", getPositionFromMatch(matches2[i]));
           }
-          const attrName = matches[i][2];
+          const attrName = matches2[i][2];
           if (!validateAttrName(attrName)) {
-            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
+            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches2[i]));
           }
           if (!attrNames.hasOwnProperty(attrName)) {
             attrNames[attrName] = 1;
           } else {
-            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
+            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches2[i]));
           }
         }
         return true;
@@ -725,12 +725,12 @@
       var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
       function buildAttributesMap(attrStr, jPath) {
         if (!this.options.ignoreAttributes && typeof attrStr === "string") {
-          const matches = util.getAllMatches(attrStr, attrsRegx);
-          const len = matches.length;
+          const matches2 = util.getAllMatches(attrStr, attrsRegx);
+          const len = matches2.length;
           const attrs = {};
           for (let i = 0; i < len; i++) {
-            const attrName = this.resolveNameSpace(matches[i][1]);
-            let oldVal = matches[i][4];
+            const attrName = this.resolveNameSpace(matches2[i][1]);
+            let oldVal = matches2[i][4];
             const aName = this.options.attributeNamePrefix + attrName;
             if (attrName.length) {
               if (oldVal !== void 0) {
@@ -1574,7 +1574,11 @@
 
   // ../xml/src/lib/parse-xml.ts
   function parseXML(text, options) {
-    const parser = new import_fast_xml_parser.XMLParser({ ...options });
+    const parser = new import_fast_xml_parser.XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "",
+      ...options
+    });
     const parsedXML = parser.parse(text);
     return parsedXML;
   }
@@ -1619,19 +1623,60 @@
     }
   });
 
-  // src/lib/parse-wms-capabilities.ts
+  // src/lib/parse-wms.ts
   function parseWMSCapabilities(text, options) {
     const parsedXML = XMLLoader.parseTextSync(text, options);
-    if (parsedXML.WMT_MS_Capabilities) {
-      return parsedXML.WMT_MS_Capabilities;
+    const xmlCapabilities = parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
+    return extractCapabilities(xmlCapabilities);
+  }
+  function extractCapabilities(xml) {
+    const capabilities = {
+      name: xml.Service?.Name || "unnamed",
+      title: xml.Service?.Title,
+      keywords: [],
+      requests: {},
+      layer: extractLayer(xml.Capability?.Layer),
+      raw: xml
+    };
+    for (const keyword of xml.Service?.KeywordList?.Keyword || []) {
+      capabilities.keywords.push(keyword);
     }
-    if (parsedXML.WMS_Capabilities) {
-      return parsedXML.WMS_Capabilities;
+    for (const [name, xmlRequest] of Object.entries(xml.Capability?.Request || {})) {
+      capabilities.requests[name] = extractRequest(name, xmlRequest);
     }
-    return parsedXML;
+    return capabilities;
+  }
+  function extractRequest(name, xmlRequest) {
+    const format = xmlRequest?.Format;
+    const mimeTypes = Array.isArray(format) ? format : [format];
+    return { name, mimeTypes };
+  }
+  function extractLayer(xmlLayer) {
+    const layer = {
+      name: xmlLayer?.Name,
+      title: xmlLayer?.Title,
+      srs: xmlLayer?.SRS || [],
+      layers: []
+    };
+    for (const xmlSubLayer of xmlLayer?.Layer || []) {
+      layer.layers?.push(extractLayer(xmlSubLayer));
+    }
+    return layer;
   }
-  var init_parse_wms_capabilities = __esm({
-    "src/lib/parse-wms-capabilities.ts"() {
+  function parseWMSFeatureInfo(text, options) {
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    const xmlFeatureInfo = parsedXML.FeatureInfoResponse?.FIELDS || [];
+    const xmlFeatures = Array.isArray(xmlFeatureInfo) ? xmlFeatureInfo : [xmlFeatureInfo];
+    return {
+      features: xmlFeatures.map((xmlFeature) => extractFeature(xmlFeature))
+    };
+  }
+  function extractFeature(xmlFeature) {
+    const xmlFields = xmlFeature || {};
+    return { attributes: xmlFields };
+  }
+  var init_parse_wms = __esm({
+    "src/lib/parse-wms.ts"() {
       init_src();
     }
   });
@@ -1643,11 +1688,11 @@
   var VERSION2, WMSCapabilitiesLoader;
   var init_wms_capabilities_loader = __esm({
     "src/wms-capabilities-loader.ts"() {
-      init_parse_wms_capabilities();
+      init_parse_wms();
       VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       WMSCapabilitiesLoader = {
         name: "WMS Capabilities",
-        id: "wms",
+        id: "wms-capabilities",
         module: "wms",
         version: VERSION2,
         worker: false,
@@ -1655,7 +1700,7 @@
         mimeTypes: ["application/vnd.ogc.wms_xml", "application/xml", "text/xml"],
         testText: testXMLFile2,
         options: {
-          obj: {}
+          wms: {}
         },
         parse: async (arrayBuffer, options) => parseWMSCapabilities(new TextDecoder().decode(arrayBuffer), options),
         parseTextSync: (text, options) => parseWMSCapabilities(text, options)
@@ -1663,21 +1708,567 @@
     }
   });
 
+  // src/wms-feature-info-loader.ts
+  var WMSFeatureInfoLoader;
+  var init_wms_feature_info_loader = __esm({
+    "src/wms-feature-info-loader.ts"() {
+      init_wms_capabilities_loader();
+      init_parse_wms();
+      WMSFeatureInfoLoader = {
+        ...WMSCapabilitiesLoader,
+        name: "WMS FeatureInfo",
+        id: "wms-feature-info",
+        parse: async (arrayBuffer, options) => parseWMSFeatureInfo(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWMSFeatureInfo(text, options)
+      };
+    }
+  });
+
+  // src/wms-layer-description-loader.ts
+  var WMSLayerDescriptionLoader;
+  var init_wms_layer_description_loader = __esm({
+    "src/wms-layer-description-loader.ts"() {
+      init_wms_capabilities_loader();
+      init_parse_wms();
+      WMSLayerDescriptionLoader = {
+        ...WMSCapabilitiesLoader,
+        name: "WMS DescribeLayer",
+        id: "wms-layer-description",
+        parse: async (arrayBuffer, options) => parseWMSFeatureInfo(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWMSFeatureInfo(text, options)
+      };
+    }
+  });
+
+  // ../images/src/lib/utils/version.ts
+  var VERSION3;
+  var init_version = __esm({
+    "../images/src/lib/utils/version.ts"() {
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    }
+  });
+
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+  var init_assert = __esm({
+    "../loader-utils/src/lib/env-utils/assert.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
+  var init_globals = __esm({
+    "../loader-utils/src/lib/env-utils/globals.ts"() {
+      globals = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global,
+        document: typeof document !== "undefined" && document
+      };
+      self_ = globals.self || globals.window || globals.global || {};
+      window_ = globals.window || globals.self || globals.global || {};
+      global_ = globals.global || globals.self || globals.window || {};
+      document_ = globals.document || {};
+      isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+      matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+      nodeVersion = matches && parseFloat(matches[1]) || 0;
+    }
+  });
+
+  // ../loader-utils/src/index.ts
+  var init_src2 = __esm({
+    "../loader-utils/src/index.ts"() {
+      init_assert();
+      init_globals();
+    }
+  });
+
+  // ../images/src/lib/category-api/image-type.ts
+  function isImageTypeSupported(type) {
+    switch (type) {
+      case "auto":
+        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+      case "imagebitmap":
+        return IMAGE_BITMAP_SUPPORTED;
+      case "image":
+        return IMAGE_SUPPORTED;
+      case "data":
+        return DATA_SUPPORTED;
+      default:
+        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+    }
+  }
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
+    }
+    if (IMAGE_SUPPORTED) {
+      return "image";
+    }
+    if (DATA_SUPPORTED) {
+      return "data";
+    }
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+  }
+  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
+  var init_image_type = __esm({
+    "../images/src/lib/category-api/image-type.ts"() {
+      init_src2();
+      ({ _parseImageNode } = globalThis);
+      IMAGE_SUPPORTED = typeof Image !== "undefined";
+      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+    }
+  });
+
+  // ../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 getImageData(image) {
+    switch (getImageType(image)) {
+      case "data":
+        return image;
+      case "image":
+      case "imagebitmap":
+        const canvas = document.createElement("canvas");
+        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);
+      default:
+        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"() {
+    }
+  });
+
+  // ../images/src/lib/parsers/svg-utils.ts
+  function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+  }
+  function getBlobOrSVGDataUrl(arrayBuffer, url) {
+    if (isSVG(url)) {
+      const textDecoder = new TextDecoder();
+      let xmlText = textDecoder.decode(arrayBuffer);
+      try {
+        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+          xmlText = unescape(encodeURIComponent(xmlText));
+        }
+      } catch (error) {
+        throw new Error(error.message);
+      }
+      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+      return src;
+    }
+    return getBlob(arrayBuffer, url);
+  }
+  function getBlob(arrayBuffer, url) {
+    if (isSVG(url)) {
+      throw new Error("SVG cannot be parsed directly to imagebitmap");
+    }
+    return new Blob([new Uint8Array(arrayBuffer)]);
+  }
+  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
+  var init_svg_utils = __esm({
+    "../images/src/lib/parsers/svg-utils.ts"() {
+      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image.ts
+  async function parseToImage(arrayBuffer, options, url) {
+    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    try {
+      return await loadToImage(objectUrl || blobOrDataUrl, options);
+    } finally {
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
+      }
+    }
+  }
+  async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    if (options.image && options.image.decode && image.decode) {
+      await image.decode();
+      return image;
+    }
+    return await new Promise((resolve, reject) => {
+      try {
+        image.onload = () => resolve(image);
+        image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  var init_parse_to_image = __esm({
+    "../images/src/lib/parsers/parse-to-image.ts"() {
+      init_svg_utils();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
+  async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    if (isSVG(url)) {
+      const image = await parseToImage(arrayBuffer, options, url);
+      blob = image;
+    } else {
+      blob = getBlob(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+  }
+  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+      imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+      try {
+        return await createImageBitmap(blob, imagebitmapOptions);
+      } catch (error) {
+        console.warn(error);
+        imagebitmapOptionsSupported = false;
+      }
+    }
+    return await createImageBitmap(blob);
+  }
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
+    }
+    return true;
+  }
+  var EMPTY_OBJECT, imagebitmapOptionsSupported;
+  var init_parse_to_image_bitmap = __esm({
+    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
+      init_svg_utils();
+      init_parse_to_image();
+      EMPTY_OBJECT = {};
+      imagebitmapOptionsSupported = true;
+    }
+  });
+
+  // ../images/src/lib/category-api/binary-image-api.ts
+  function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView);
+  }
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
+    }
+    return {
+      mimeType: "image/png",
+      width: dataView.getUint32(16, BIG_ENDIAN),
+      height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+  }
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
+    }
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
+  }
+  function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+      return null;
+    }
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
+  }
+  function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+    if (!isJpeg) {
+      return null;
+    }
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
+    let i = 2;
+    while (i + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i, BIG_ENDIAN);
+      if (sofMarkers.has(marker)) {
+        return {
+          mimeType: "image/jpeg",
+          height: dataView.getUint16(i + 5, BIG_ENDIAN),
+          width: dataView.getUint16(i + 7, BIG_ENDIAN)
+        };
+      }
+      if (!tableMarkers.has(marker)) {
+        return null;
+      }
+      i += 2;
+      i += dataView.getUint16(i, BIG_ENDIAN);
+    }
+    return null;
+  }
+  function getJpegMarkers() {
+    const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
+    for (let i = 65504; i < 65520; ++i) {
+      tableMarkers.add(i);
+    }
+    const sofMarkers = new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
+  }
+  function toDataView(data) {
+    if (data instanceof DataView) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new DataView(data.buffer);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new DataView(data);
+    }
+    throw new Error("toDataView");
+  }
+  var BIG_ENDIAN, LITTLE_ENDIAN;
+  var init_binary_image_api = __esm({
+    "../images/src/lib/category-api/binary-image-api.ts"() {
+      BIG_ENDIAN = false;
+      LITTLE_ENDIAN = true;
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-node-image.ts
+  async function parseToNodeImage(arrayBuffer, options) {
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
+    const _parseImageNode2 = globalThis._parseImageNode;
+    assert(_parseImageNode2);
+    return await _parseImageNode2(arrayBuffer, mimeType);
+  }
+  var init_parse_to_node_image = __esm({
+    "../images/src/lib/parsers/parse-to-node-image.ts"() {
+      init_src2();
+      init_binary_image_api();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-image.ts
+  async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const { url } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
+      default:
+        assert(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+  var init_parse_image = __esm({
+    "../images/src/lib/parsers/parse-image.ts"() {
+      init_src2();
+      init_image_type();
+      init_parsed_image_api();
+      init_parse_to_image();
+      init_parse_to_image_bitmap();
+      init_parse_to_node_image();
+    }
+  });
+
+  // ../images/src/image-loader.ts
+  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
+  var init_image_loader = __esm({
+    "../images/src/image-loader.ts"() {
+      init_version();
+      init_parse_image();
+      init_binary_image_api();
+      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg"];
+      MIME_TYPES = [
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp",
+        "image/bmp",
+        "image/vnd.microsoft.icon",
+        "image/svg+xml"
+      ];
+      DEFAULT_IMAGE_LOADER_OPTIONS = {
+        image: {
+          type: "auto",
+          decode: true
+        }
+      };
+      ImageLoader = {
+        id: "image",
+        module: "images",
+        name: "Images",
+        version: VERSION3,
+        mimeTypes: MIME_TYPES,
+        extensions: EXTENSIONS,
+        parse: parseImage,
+        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+        options: DEFAULT_IMAGE_LOADER_OPTIONS
+      };
+    }
+  });
+
+  // ../images/src/index.ts
+  var init_src3 = __esm({
+    "../images/src/index.ts"() {
+      init_image_loader();
+    }
+  });
+
+  // src/lib/data-sources/wms-data-source.ts
+  var WMSDataSource;
+  var init_wms_data_source = __esm({
+    "src/lib/data-sources/wms-data-source.ts"() {
+      init_src4();
+      init_src3();
+      WMSDataSource = class {
+        constructor(props) {
+          this.url = props.url;
+          this.loadOptions = props.loadOptions || {};
+          this.fetch = props.fetch || fetch;
+        }
+        async getCapabilities(options) {
+          const url = this.getUrl({ request: "GetCapabilities", ...options });
+          const response = await this.fetch(url, this.loadOptions);
+          const arrayBuffer = await response.arrayBuffer();
+          return await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
+        }
+        async getImage(options) {
+          const url = this.getUrl({ request: "GetMap", ...options });
+          const response = await this.fetch(url, this.loadOptions);
+          const arrayBuffer = await response.arrayBuffer();
+          return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+        }
+        async getFeatureInfo(options) {
+          const url = this.getUrl({ request: "GetFeatureInfo", ...options });
+          const response = await this.fetch(url, this.loadOptions);
+          const arrayBuffer = await response.arrayBuffer();
+          return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
+        }
+        async getLayerInfo(options) {
+          const url = this.getUrl({ request: "GetLayerInfo", ...options });
+          const response = await this.fetch(url, this.loadOptions);
+          const arrayBuffer = await response.arrayBuffer();
+          return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
+        }
+        async getLegendImage(options) {
+          const url = this.getUrl({ request: "GetLegendImage", ...options });
+          const response = await this.fetch(url, this.loadOptions);
+          const arrayBuffer = await response.arrayBuffer();
+          return await ImageLoader.parse(arrayBuffer, this.loadOptions);
+        }
+        getUrl(options) {
+          let url = `${this.url}?REQUEST=${options.request}`;
+          if (options.layers?.length) {
+            url += `&LAYERS=[${options.layers.join(",")}]`;
+          }
+          return url;
+        }
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
-    WMSCapabilitiesLoader: () => WMSCapabilitiesLoader
+    WMSCapabilitiesLoader: () => WMSCapabilitiesLoader,
+    WMSFeatureInfoLoader: () => WMSFeatureInfoLoader,
+    WMSLayerDescriptionLoader: () => WMSLayerDescriptionLoader,
+    _WMSDataSource: () => WMSDataSource
   });
-  var init_src2 = __esm({
+  var init_src4 = __esm({
     "src/index.ts"() {
       init_wms_capabilities_loader();
+      init_wms_feature_info_loader();
+      init_wms_layer_description_loader();
+      init_wms_data_source();
     }
   });
 
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
+      var moduleExports = (init_src4(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }