@loaders.gl/wms 3.4.0-alpha.2 → 3.4.0-alpha.4

package/dist/dist.min.js

@@ -430,7 +430,10 @@
         ignoreDeclaration: false,
         ignorePiTags: false,
         transformTagName: false,
-        transformAttributeName: false
+        transformAttributeName: false,
+        updateTag: function(tagName, jPath, attrs) {
+          return tagName;
+        }
       };
       var buildOptions = function(options) {
         return Object.assign({}, defaultOptions, options);
@@ -708,6 +711,7 @@
           this.replaceEntitiesValue = replaceEntitiesValue;
           this.readStopNodeData = readStopNodeData;
           this.saveTextToParentTag = saveTextToParentTag;
+          this.addChild = addChild;
         }
       };
       function addExternalEntities(externalEntities) {
@@ -760,7 +764,7 @@
         return tagname;
       }
       var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
-      function buildAttributesMap(attrStr, jPath) {
+      function buildAttributesMap(attrStr, jPath, tagName) {
         if (!this.options.ignoreAttributes && typeof attrStr === "string") {
           const matches2 = util.getAllMatches(attrStr, attrsRegx);
           const len = matches2.length;
@@ -828,7 +832,18 @@
               if (currentNode) {
                 textData = this.saveTextToParentTag(textData, currentNode, jPath);
               }
-              jPath = jPath.substr(0, jPath.lastIndexOf("."));
+              const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+              if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+                throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
+              }
+              let propIndex = 0;
+              if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
+                propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
+                this.tagsNodeStack.pop();
+              } else {
+                propIndex = jPath.lastIndexOf(".");
+              }
+              jPath = jPath.substring(0, propIndex);
               currentNode = this.tagsNodeStack.pop();
               textData = "";
               i = closeIndex;
@@ -842,9 +857,9 @@
                 const childNode = new xmlNode(tagData.tagName);
                 childNode.add(this.options.textNodeName, "");
                 if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath);
+                  childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
                 }
-                currentNode.addChild(childNode);
+                this.addChild(currentNode, childNode, jPath);
               }
               i = tagData.closeIndex + 1;
             } else if (xmlData.substr(i + 1, 3) === "!--") {
@@ -886,12 +901,13 @@
                   textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
                 }
               }
-              if (tagName !== xmlObj.tagname) {
-                jPath += jPath ? "." + tagName : tagName;
-              }
               const lastTag = currentNode;
               if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
                 currentNode = this.tagsNodeStack.pop();
+                jPath = jPath.substring(0, jPath.lastIndexOf("."));
+              }
+              if (tagName !== xmlObj.tagname) {
+                jPath += jPath ? "." + tagName : tagName;
               }
               if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
                 let tagContent = "";
@@ -908,14 +924,14 @@
                 }
                 const childNode = new xmlNode(tagName);
                 if (tagName !== tagExp && attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                 }
                 if (tagContent) {
                   tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
                 }
                 jPath = jPath.substr(0, jPath.lastIndexOf("."));
                 childNode.add(this.options.textNodeName, tagContent);
-                currentNode.addChild(childNode);
+                this.addChild(currentNode, childNode, jPath);
               } else {
                 if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                   if (tagName[tagName.length - 1] === "/") {
@@ -929,17 +945,17 @@
                   }
                   const childNode = new xmlNode(tagName);
                   if (tagName !== tagExp && attrExpPresent) {
-                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                   }
+                  this.addChild(currentNode, childNode, jPath);
                   jPath = jPath.substr(0, jPath.lastIndexOf("."));
-                  currentNode.addChild(childNode);
                 } else {
                   const childNode = new xmlNode(tagName);
                   this.tagsNodeStack.push(currentNode);
                   if (tagName !== tagExp && attrExpPresent) {
-                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                    childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                   }
-                  currentNode.addChild(childNode);
+                  this.addChild(currentNode, childNode, jPath);
                   currentNode = childNode;
                 }
                 textData = "";
@@ -952,6 +968,16 @@
         }
         return xmlObj.child;
       };
+      function addChild(currentNode, childNode, jPath) {
+        const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+        if (result === false) {
+        } else if (typeof result === "string") {
+          childNode.tagname = result;
+          currentNode.addChild(childNode);
+        } else {
+          currentNode.addChild(childNode);
+        }
+      }
       var replaceEntitiesValue = function(val2) {
         if (this.options.processEntities) {
           for (let entityName2 in this.docTypeEntities) {
@@ -1200,9 +1226,14 @@
         }
       }
       function isLeafTag(obj, options) {
+        const { textNodeName } = options;
         const propCount = Object.keys(obj).length;
-        if (propCount === 0 || propCount === 1 && obj[options.textNodeName])
+        if (propCount === 0) {
+          return true;
+        }
+        if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
           return true;
+        }
         return false;
       }
       exports.prettify = prettify;
@@ -1421,7 +1452,8 @@
           { regex: new RegExp('"', "g"), val: "&quot;" }
         ],
         processEntities: true,
-        stopNodes: []
+        stopNodes: [],
+        oneListGroup: false
       };
       function Builder(options) {
         this.options = Object.assign({}, defaultOptions, options);
@@ -1484,6 +1516,7 @@
             }
           } else if (Array.isArray(jObj[key])) {
             const arrLen = jObj[key].length;
+            let listTagVal = "";
             for (let j = 0; j < arrLen; j++) {
               const item = jObj[key][j];
               if (typeof item === "undefined") {
@@ -1493,11 +1526,19 @@
                 else
                   val2 += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
               } else if (typeof item === "object") {
-                val2 += this.processTextOrObjNode(item, key, level);
+                if (this.options.oneListGroup) {
+                  listTagVal += this.j2x(item, level + 1).val;
+                } else {
+                  listTagVal += this.processTextOrObjNode(item, key, level);
+                }
               } else {
-                val2 += this.buildTextValNode(item, key, "", level);
+                listTagVal += this.buildTextValNode(item, key, "", level);
               }
             }
+            if (this.options.oneListGroup) {
+              listTagVal = this.buildObjectNode(listTagVal, key, "", level);
+            }
+            val2 += listTagVal;
           } else {
             if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
               const Ks = Object.keys(jObj[key]);
@@ -2042,59 +2083,229 @@
     }
   });
 
+  // src/lib/parsers/xml/parse-xml-helpers.ts
+  function getXMLArray(xmlValue) {
+    if (Array.isArray(xmlValue)) {
+      return xmlValue;
+    }
+    if (xmlValue) {
+      return [xmlValue];
+    }
+    return [];
+  }
+  function getXMLStringArray(xmlValue) {
+    const xmlArray = getXMLArray(xmlValue);
+    if (xmlArray.length > 0 && xmlArray.every((_) => typeof _ === "string")) {
+      return xmlArray;
+    }
+    return [];
+  }
+  function getXMLFloat(xmlValue, defaultValue = void 0) {
+    switch (typeof xmlValue) {
+      case "number":
+        return xmlValue;
+      case "string":
+        return parseFloat(xmlValue);
+      default:
+        return void 0;
+    }
+  }
+  function getXMLInteger(xmlValue, defaultValue = void 0) {
+    switch (typeof xmlValue) {
+      case "number":
+        return xmlValue;
+      case "string":
+        return parseInt(xmlValue, 10);
+      default:
+        return void 0;
+    }
+  }
+  function getXMLBoolean(xmlValue) {
+    switch (xmlValue) {
+      case "true":
+        return true;
+      case "false":
+        return false;
+      case "1":
+        return true;
+      case "0":
+        return false;
+      default:
+        return false;
+    }
+  }
+  var init_parse_xml_helpers = __esm({
+    "src/lib/parsers/xml/parse-xml-helpers.ts"() {
+    }
+  });
+
   // src/lib/parsers/wms/parse-wms-capabilities.ts
-  function parseWMSCapabilities(text, options) {
-    const parsedXML = XMLLoader.parseTextSync(text, options);
+  function parseWMSCapabilities(xmlText, options) {
+    const parsedXML = XMLLoader.parseTextSync(xmlText, options);
     const xmlCapabilities = parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
-    return extractCapabilities(xmlCapabilities);
+    const capabilities = extractCapabilities(xmlCapabilities);
+    if (options?.inheritedLayerProps) {
+      for (const layer of capabilities.layers) {
+        addInheritedLayerProps(layer, null);
+      }
+    }
+    if (options?.includeRawData || options?.raw) {
+      capabilities.raw = xmlCapabilities;
+    }
+    if (options?.includeXMLText) {
+      capabilities.xml = xmlText;
+    }
+    return capabilities;
   }
   function extractCapabilities(xml) {
     const capabilities = {
-      name: xml.Service?.Name || "unnamed",
-      title: xml.Service?.Title,
-      keywords: [],
-      requests: {},
-      layer: extractLayer(xml.Capability?.Layer),
-      raw: xml
+      version: String(xml.version || ""),
+      name: String(xml.Service?.Name || "unnamed"),
+      title: xml.Service?.Title ? String(xml.Service?.Title) : void 0,
+      abstract: xml.Service?.Abstract ? String(xml.Service?.Abstract) : void 0,
+      keywords: getXMLStringArray(xml.Service?.KeywordList?.Keyword),
+      fees: xml.Service?.Fees ? JSON.stringify(xml.Service?.Fees) : void 0,
+      accessConstraints: xml.Service?.AccessConstraints ? JSON.stringify(xml.Service?.AccessConstraints) : void 0,
+      layerLimit: getXMLInteger(xml.Service?.LayerLimit),
+      maxWidth: getXMLInteger(xml.Service?.maxWidth),
+      maxHeight: getXMLInteger(xml.Service?.maxHeight),
+      layers: [],
+      requests: extractRequests(xml.Capability?.Request),
+      exceptions: extractExceptions(xml.Exception)
     };
-    for (const keyword of xml.Service?.KeywordList?.Keyword || []) {
-      capabilities.keywords.push(keyword);
+    const xmlLayers = getXMLArray(xml.Capability?.Layer);
+    for (const xmlSubLayer of xmlLayers) {
+      capabilities.layers.push(extractLayer(xmlSubLayer));
     }
-    for (const [name, xmlRequest] of Object.entries(xml.Capability?.Request || {})) {
-      capabilities.requests[name] = extractRequest(name, xmlRequest);
+    for (const [key, value] of Object.entries(capabilities)) {
+      if (value === void 0) {
+        delete capabilities[key];
+      }
     }
     return capabilities;
   }
-  function extractRequest(name, xmlRequest) {
-    const format = xmlRequest?.Format;
-    const mimeTypes = Array.isArray(format) ? format : [format];
-    return { name, mimeTypes };
+  function extractRequests(xmlRequests) {
+    const requests = {};
+    for (const [name, xmlRequest] of Object.entries(xmlRequests || {})) {
+      const mimeTypes = getXMLStringArray(xmlRequest?.Format);
+      requests[name] = { mimeTypes };
+    }
+    return requests;
+  }
+  function extractExceptions(xmlException) {
+    const xmlExceptionFormats = getXMLArray(xmlException?.Format);
+    if (xmlExceptionFormats.length > 0) {
+      return {
+        mimeTypes: getXMLStringArray(xmlException)
+      };
+    }
+    return void 0;
   }
   function extractLayer(xmlLayer) {
     const layer = {
-      name: xmlLayer?.Name,
-      title: xmlLayer?.Title,
-      srs: xmlLayer?.SRS || [],
-      layers: []
+      title: String(xmlLayer?.Title || ""),
+      name: String(xmlLayer?.Name),
+      abstract: String(xmlLayer?.Abstract),
+      keywords: getXMLStringArray(xmlLayer.KeywordList?.Keyword)
     };
+    const crs = xmlLayer?.CRS || xmlLayer?.SRS;
+    if (crs && Array.isArray(crs) && crs.every((_) => typeof _ === "string")) {
+      layer.crs = crs;
+    }
+    let geographicBoundingBox = xmlLayer?.EX_GeographicBoundingBox && extractEXBoundingBox(xmlLayer?.EX_GeographicBoundingBox);
+    if (geographicBoundingBox) {
+      layer.geographicBoundingBox = geographicBoundingBox;
+    }
+    geographicBoundingBox = xmlLayer?.LatLonBoundingBox && extractLatLonBoundingBox(xmlLayer?.LatLonBoundingBox);
+    if (geographicBoundingBox) {
+      layer.geographicBoundingBox = geographicBoundingBox;
+    }
+    const boundingBoxes = xmlLayer?.BoundingBox && extractWMSBoundingBoxes(xmlLayer?.BoundingBox);
+    if (boundingBoxes && boundingBoxes.length > 0) {
+      layer.boundingBoxes = boundingBoxes;
+    }
+    if (xmlLayer?.opaque) {
+      layer.opaque = getXMLBoolean(xmlLayer?.opaque);
+    }
+    if (xmlLayer?.cascaded) {
+      layer.cascaded = getXMLBoolean(xmlLayer?.cascaded);
+    }
+    if (xmlLayer?.queryable) {
+      layer.queryable = getXMLBoolean(xmlLayer?.queryable);
+    }
     const xmlLayers = getXMLArray(xmlLayer?.Layer);
+    const layers = [];
     for (const xmlSubLayer of xmlLayers) {
-      layer.layers?.push(extractLayer(xmlSubLayer));
+      layers.push(extractLayer(xmlSubLayer));
+    }
+    if (layers.length > 0) {
+      layer.layers = layers;
+    }
+    for (const [key, value] of Object.entries(layer)) {
+      if (value === void 0) {
+        delete layer[key];
+      }
     }
     return layer;
   }
-  function getXMLArray(xmlValue) {
-    if (Array.isArray(xmlValue)) {
-      return xmlValue;
+  function extractEXBoundingBox(xmlBoundingBox) {
+    const {
+      westBoundLongitude: w,
+      northBoundLatitude: n,
+      eastBoundLongitude: e,
+      southBoundLatitude: s
+    } = xmlBoundingBox;
+    return [
+      [w, s],
+      [e, n]
+    ];
+  }
+  function extractLatLonBoundingBox(xmlBoundingBox) {
+    const { minx, miny, maxx, maxy } = xmlBoundingBox;
+    return [
+      [minx, miny],
+      [maxx, maxy]
+    ];
+  }
+  function extractWMSBoundingBoxes(xmlBoundingBoxes) {
+    const xmlBoxes = getXMLArray(xmlBoundingBoxes);
+    return xmlBoxes.map((xmlBox) => extractWMSBoundingBox(xmlBox));
+  }
+  function extractWMSBoundingBox(xmlBoundingBox) {
+    const { CRS, SRS, minx, miny, maxx, maxy, resx, resy } = xmlBoundingBox;
+    const boundingBox = {
+      crs: CRS || SRS,
+      boundingBox: [
+        [getXMLFloat(minx), getXMLFloat(miny)],
+        [getXMLFloat(maxx), getXMLFloat(maxy)]
+      ]
+    };
+    if (resx) {
+      boundingBox.xResolution = resx;
     }
-    if (xmlValue) {
-      return [xmlValue];
+    if (resy) {
+      boundingBox.yResolution = resy;
+    }
+    return boundingBox;
+  }
+  function addInheritedLayerProps(layer, parent) {
+    if (parent && parent.geographicBoundingBox && !layer.geographicBoundingBox) {
+      layer.geographicBoundingBox = [...parent.geographicBoundingBox];
+    }
+    if (parent && parent.crs && !layer.crs) {
+      layer.crs = [...parent.crs];
+    }
+    if (parent && parent.boundingBoxes && !layer.boundingBoxes) {
+      layer.boundingBoxes = [...parent.boundingBoxes];
+    }
+    for (const subLayer of layer.layers || []) {
+      addInheritedLayerProps(subLayer, layer);
     }
-    return [];
   }
   var init_parse_wms_capabilities = __esm({
     "src/lib/parsers/wms/parse-wms-capabilities.ts"() {
       init_src2();
+      init_parse_xml_helpers();
     }
   });
 
@@ -2119,8 +2330,8 @@
         options: {
           wms: {}
         },
-        parse: async (arrayBuffer, options) => parseWMSCapabilities(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: (text, options) => parseWMSCapabilities(text, options)
+        parse: async (arrayBuffer, options) => parseWMSCapabilities(new TextDecoder().decode(arrayBuffer), options?.wms),
+        parseTextSync: (text, options) => parseWMSCapabilities(text, options?.wms)
       };
     }
   });
@@ -2191,49 +2402,6 @@
     }
   });
 
-  // src/wip/lib/wmts/parse-wmts-capabilities.ts
-  function parseWMTSCapabilities(text, options) {
-    const parsedXML = XMLLoader.parseTextSync(text, { ...options, xml: {
-      ...options?.xml,
-      removeNSPrefix: true,
-      uncapitalizeKeys: true
-    } });
-    const xmlCapabilities = parsedXML.Capabilities || parsedXML;
-    return xmlCapabilities;
-  }
-  var init_parse_wmts_capabilities = __esm({
-    "src/wip/lib/wmts/parse-wmts-capabilities.ts"() {
-      init_src2();
-    }
-  });
-
-  // src/wip/wmts-capabilities-loader.ts
-  function testXMLFile7(text) {
-    return text.startsWith("<?xml");
-  }
-  var VERSION7, WMTSCapabilitiesLoader;
-  var init_wmts_capabilities_loader = __esm({
-    "src/wip/wmts-capabilities-loader.ts"() {
-      init_parse_wmts_capabilities();
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      WMTSCapabilitiesLoader = {
-        id: "wmts-capabilities",
-        name: "WMTS Capabilities",
-        module: "wms",
-        version: VERSION7,
-        worker: false,
-        extensions: ["xml"],
-        mimeTypes: ["application/vnd.ogc.wmts_xml", "application/xml", "text/xml"],
-        testText: testXMLFile7,
-        options: {
-          wms: {}
-        },
-        parse: async (arrayBuffer, options) => parseWMTSCapabilities(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: (text, options) => parseWMTSCapabilities(text, options)
-      };
-    }
-  });
-
   // src/wip/lib/wfs/parse-wfs-capabilities.ts
   function parseWFSCapabilities(text, options) {
     const parsedXML = XMLLoader.parseTextSync(text, { ...options, xml: {
@@ -2251,23 +2419,23 @@
   });
 
   // src/wip/wfs-capabilities-loader.ts
-  function testXMLFile8(text) {
+  function testXMLFile7(text) {
     return text.startsWith("<?xml");
   }
-  var VERSION8, WFSCapabilitiesLoader;
+  var VERSION7, WFSCapabilitiesLoader;
   var init_wfs_capabilities_loader = __esm({
     "src/wip/wfs-capabilities-loader.ts"() {
       init_parse_wfs_capabilities();
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       WFSCapabilitiesLoader = {
         id: "wfs-capabilities",
         name: "WFS Capabilities",
         module: "wms",
-        version: VERSION8,
+        version: VERSION7,
         worker: false,
         extensions: ["xml"],
         mimeTypes: ["application/vnd.ogc.wfs_xml", "application/xml", "text/xml"],
-        testText: testXMLFile8,
+        testText: testXMLFile7,
         options: {
           wms: {}
         },
@@ -3045,23 +3213,23 @@
   });
 
   // src/gml-loader.ts
-  function testXMLFile9(text) {
+  function testXMLFile8(text) {
     return text.startsWith("<?xml");
   }
-  var VERSION9, GMLLoader;
+  var VERSION8, GMLLoader;
   var init_gml_loader = __esm({
     "src/gml-loader.ts"() {
       init_parse_gml();
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       GMLLoader = {
         name: "GML",
         id: "gml",
         module: "wms",
-        version: VERSION9,
+        version: VERSION8,
         worker: false,
         extensions: ["xml"],
         mimeTypes: ["application/vnd.ogc.gml", "application/xml", "text/xml"],
-        testText: testXMLFile9,
+        testText: testXMLFile8,
         options: {
           gml: {}
         },
@@ -3088,9 +3256,25 @@
     "src/lib/sources/data-source.ts"() {
       DataSource = class {
         constructor(props) {
+          this._needsRefresh = true;
+          this.props = { ...props };
           this.loadOptions = { ...props.loadOptions };
           this.fetch = getFetchFunction(this.loadOptions);
         }
+        setProps(props) {
+          this.props = Object.assign(this.props, props);
+          this.setNeedsRefresh();
+        }
+        setNeedsRefresh() {
+          this._needsRefresh = true;
+        }
+        getNeedsRefresh(clear = true) {
+          const needsRefresh = this._needsRefresh;
+          if (clear) {
+            this._needsRefresh = false;
+          }
+          return needsRefresh;
+        }
       };
     }
   });
@@ -3106,10 +3290,10 @@
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION10;
+  var VERSION9;
   var init_version = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -3558,7 +3742,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION10,
+        version: VERSION9,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -3584,7 +3768,6 @@
       ImageService = class extends ImageSource {
         constructor(props) {
           super(props);
-          this.props = props;
         }
         async getMetadata() {
           throw new Error("ImageSource.getMetadata not implemented");
@@ -3636,16 +3819,21 @@
             WMSFeatureInfoLoader,
             WMSLayerDescriptionLoader
           ];
-          this.props = {
-            loadOptions: void 0,
+          this.url = props.url;
+          this.substituteCRS84 = props.substituteCRS84 ?? false;
+          this.flipCRS = ["EPSG:4326"];
+          this.wmsParameters = {
             layers: void 0,
+            query_layers: void 0,
             styles: void 0,
-            version: "1.1.1",
-            srs: "EPSG:4326",
+            version: "1.3.0",
+            crs: "EPSG:4326",
             format: "image/png",
             info_format: "text/plain",
-            ...props
+            transparent: void 0,
+            ...props.wmsParameters
           };
+          this.vendorParameters = props.vendorParameters || {};
         }
         async getMetadata() {
           const capabilities = await this.getCapabilities();
@@ -3662,128 +3850,180 @@
           const response = await this.fetch(url);
           const arrayBuffer = await response.arrayBuffer();
           this._checkResponse(response, arrayBuffer);
-          const capabilities = await WMSCapabilitiesLoader.parse(arrayBuffer, this.props.loadOptions);
+          const capabilities = await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
           this.capabilities = capabilities;
           return capabilities;
         }
-        async getMap(options, vendorParameters) {
-          const url = this.getMapURL(options, vendorParameters);
+        async getMap(wmsParameters, vendorParameters) {
+          const url = this.getMapURL(wmsParameters, vendorParameters);
           const response = await this.fetch(url);
           const arrayBuffer = await response.arrayBuffer();
           this._checkResponse(response, arrayBuffer);
           try {
-            return await ImageLoader.parse(arrayBuffer, this.props.loadOptions);
+            return await ImageLoader.parse(arrayBuffer, this.loadOptions);
           } catch {
             throw this._parseError(arrayBuffer);
           }
         }
-        async getFeatureInfo(options, vendorParameters) {
-          const url = this.getFeatureInfoURL(options, vendorParameters);
+        async getFeatureInfo(wmsParameters, vendorParameters) {
+          const url = this.getFeatureInfoURL(wmsParameters, vendorParameters);
           const response = await this.fetch(url);
           const arrayBuffer = await response.arrayBuffer();
           this._checkResponse(response, arrayBuffer);
-          return await WMSFeatureInfoLoader.parse(arrayBuffer, this.props.loadOptions);
+          return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getFeatureInfoText(options, vendorParameters) {
-          const url = this.getFeatureInfoURL(options, vendorParameters);
+        async getFeatureInfoText(wmsParameters, vendorParameters) {
+          const url = this.getFeatureInfoURL(wmsParameters, 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);
+        async describeLayer(wmsParameters, vendorParameters) {
+          const url = this.describeLayerURL(wmsParameters, vendorParameters);
           const response = await this.fetch(url);
           const arrayBuffer = await response.arrayBuffer();
           this._checkResponse(response, arrayBuffer);
-          return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.props.loadOptions);
+          return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getLegendGraphic(options, vendorParameters) {
-          const url = this.getLegendGraphicURL(options, vendorParameters);
+        async getLegendGraphic(wmsParameters, vendorParameters) {
+          const url = this.getLegendGraphicURL(wmsParameters, vendorParameters);
           const response = await this.fetch(url);
           const arrayBuffer = await response.arrayBuffer();
           this._checkResponse(response, arrayBuffer);
           try {
-            return await ImageLoader.parse(arrayBuffer, this.props.loadOptions);
+            return await ImageLoader.parse(arrayBuffer, this.loadOptions);
           } catch {
             throw this._parseError(arrayBuffer);
           }
         }
         getCapabilitiesURL(wmsParameters, vendorParameters) {
           const options = {
-            service: "WMS",
-            version: this.props.version,
-            request: "GetCapabilities",
-            ...wmsParameters,
-            ...vendorParameters
+            version: this.wmsParameters.version,
+            ...wmsParameters
           };
-          return this._getWMSUrl(options, vendorParameters);
+          return this._getWMSUrl("GetCapabilities", options, vendorParameters);
         }
         getMapURL(wmsParameters, vendorParameters) {
+          wmsParameters = this._getWMS130Parameters(wmsParameters);
           const options = {
-            service: "WMS",
-            version: this.props.version,
-            request: "GetMap",
-            styles: this.props.styles,
-            srs: this.props.srs,
-            format: this.props.format,
-            ...wmsParameters,
-            ...vendorParameters
+            version: this.wmsParameters.version,
+            format: this.wmsParameters.format,
+            transparent: this.wmsParameters.transparent,
+            layers: this.wmsParameters.layers,
+            styles: this.wmsParameters.styles,
+            crs: this.wmsParameters.crs,
+            ...wmsParameters
           };
-          return this._getWMSUrl(options, vendorParameters);
+          return this._getWMSUrl("GetMap", options, vendorParameters);
         }
         getFeatureInfoURL(wmsParameters, vendorParameters) {
           const options = {
-            service: "WMS",
-            version: this.props.version,
-            request: "GetFeatureInfo",
-            srs: this.props.srs,
-            format: this.props.format,
-            info_format: this.props.info_format,
-            styles: this.props.styles,
-            ...wmsParameters,
-            ...vendorParameters
+            version: this.wmsParameters.version,
+            info_format: this.wmsParameters.info_format,
+            layers: this.wmsParameters.layers,
+            query_layers: this.wmsParameters.query_layers,
+            styles: this.wmsParameters.styles,
+            crs: this.wmsParameters.crs,
+            ...wmsParameters
           };
-          return this._getWMSUrl(options, vendorParameters);
+          return this._getWMSUrl("GetFeatureInfo", options, vendorParameters);
         }
         describeLayerURL(wmsParameters, vendorParameters) {
           const options = {
-            service: "WMS",
-            version: this.props.version,
-            request: "DescribeLayer",
-            ...wmsParameters,
-            ...vendorParameters
+            version: this.wmsParameters.version,
+            ...wmsParameters
           };
-          return this._getWMSUrl(options, vendorParameters);
+          return this._getWMSUrl("DescribeLayer", options, vendorParameters);
         }
         getLegendGraphicURL(wmsParameters, vendorParameters) {
           const options = {
+            version: this.wmsParameters.version,
+            ...wmsParameters
+          };
+          return this._getWMSUrl("GetLegendGraphic", options, vendorParameters);
+        }
+        _parseWMSUrl(url) {
+          const [baseUrl, search] = url.split("?");
+          const searchParams = search.split("&");
+          const parameters = {};
+          for (const parameter of searchParams) {
+            const [key, value] = parameter.split("=");
+            parameters[key] = value;
+          }
+          return { url: baseUrl, parameters };
+        }
+        _getWMSUrl(request, wmsParameters, vendorParameters) {
+          let url = this.url;
+          let first = true;
+          const allParameters = {
             service: "WMS",
-            version: this.props.version,
-            request: "GetLegendGraphic",
+            version: wmsParameters.version,
+            request,
             ...wmsParameters,
+            ...this.vendorParameters,
             ...vendorParameters
           };
-          return this._getWMSUrl(options, vendorParameters);
-        }
-        _getWMSUrl(options, vendorParameters) {
-          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) : ""}`;
+          for (const [key, value] of Object.entries(allParameters)) {
+            if (key !== "transparent" || value) {
+              url += first ? "?" : "&";
+              first = false;
+              url += this._getURLParameter(key, value, wmsParameters);
             }
           }
           return encodeURI(url);
         }
+        _getWMS130Parameters(wmsParameters) {
+          const newParameters = { ...wmsParameters };
+          if (newParameters.srs) {
+            newParameters.crs = newParameters.crs || newParameters.srs;
+            delete newParameters.srs;
+          }
+          return newParameters;
+        }
+        _getURLParameter(key, value, wmsParameters) {
+          switch (key) {
+            case "crs":
+              if (wmsParameters.version !== "1.3.0") {
+                key = "srs";
+              } else if (this.substituteCRS84 && value === "EPSG:4326") {
+                value = "CRS:84";
+              }
+              break;
+            case "srs":
+              if (wmsParameters.version === "1.3.0") {
+                key = "crs";
+              }
+              break;
+            case "bbox":
+              const bbox = this._flipBoundingBox(value, wmsParameters);
+              if (bbox) {
+                value = bbox;
+              }
+              break;
+            default:
+          }
+          key = key.toUpperCase();
+          return Array.isArray(value) ? `${key}=${value.join(",")}` : `${key}=${value ? String(value) : ""}`;
+        }
+        _flipBoundingBox(bboxValue, wmsParameters) {
+          if (!Array.isArray(bboxValue) || bboxValue.length !== 4) {
+            return null;
+          }
+          const flipCoordinates = wmsParameters.version === "1.3.0" && this.flipCRS.includes(wmsParameters.crs || "") && !(this.substituteCRS84 && wmsParameters.crs === "EPSG:4326");
+          const bbox = bboxValue;
+          return flipCoordinates ? [bbox[1], bbox[0], bbox[3], bbox[2]] : bbox;
+        }
+        async _fetchArrayBuffer(url) {
+          const response = await this.fetch(url);
+          const arrayBuffer = await response.arrayBuffer();
+          this._checkResponse(response, arrayBuffer);
+          return arrayBuffer;
+        }
         _checkResponse(response, arrayBuffer) {
           const contentType = response.headers["content-type"];
           if (!response.ok || WMSErrorLoader.mimeTypes.includes(contentType)) {
-            const loadOptions = mergeLoaderOptions(this.props.loadOptions, {
+            const loadOptions = mergeLoaderOptions(this.loadOptions, {
               wms: { throwOnError: true }
             });
             const error = WMSErrorLoader.parseSync(arrayBuffer, loadOptions);
@@ -3791,7 +4031,7 @@
           }
         }
         _parseError(arrayBuffer) {
-          const error = WMSErrorLoader.parseSync(arrayBuffer, this.props.loadOptions);
+          const error = WMSErrorLoader.parseSync(arrayBuffer, this.loadOptions);
           return new Error(error);
         }
       };
@@ -3808,7 +4048,6 @@
       ArcGISImageServer = class extends ImageSource {
         constructor(props) {
           super(props);
-          this.props = props;
         }
         async getMetadata() {
           return await this.metadata();
@@ -3903,7 +4142,6 @@
           super(props);
           this.capabilities = null;
           this.loaders = [WMSErrorLoader, CSWCapabilitiesLoader];
-          this.props = props;
         }
         async getMetadata() {
           const capabilities = await this.getCapabilities();
@@ -4090,7 +4328,6 @@
     _WFSCapabilitiesLoader: () => WFSCapabilitiesLoader,
     _WMSFeatureInfoLoader: () => WMSFeatureInfoLoader,
     _WMSLayerDescriptionLoader: () => WMSLayerDescriptionLoader,
-    _WMTSCapabilitiesLoader: () => WMTSCapabilitiesLoader,
     _getArcGISServices: () => getArcGISServices,
     createImageSource: () => createImageSource
   });
@@ -4103,7 +4340,6 @@
       init_wms_capabilities_loader();
       init_wms_feature_info_loader();
       init_wms_layer_description_loader();
-      init_wmts_capabilities_loader();
       init_wfs_capabilities_loader();
       init_gml_loader();
       init_image_source();