@honua/react 0.0.20-alpha.0 → 0.1.1-beta.0

package/core/wmts-capabilities.js

@@ -1,402 +1,255 @@
-/**
- * WMTS 1.0.0 Capabilities parser. Hand-rolled, narrow-scope walker over
- * the `Capabilities` document advertised by honua-server (single
- * advertised TileMatrixSet today: `WebMercatorQuad`). Yields a typed
- * `WmtsCapabilities` shape so the SDK can route through the canonical
- * `Source` surface without leaking XML.
- *
- * @module
- */
-import { decodeXmlText as decodeXmlEntities } from "./xml-text.js";
-export class HonuaWmtsCapabilitiesParseError extends Error {
-    constructor(message) {
-        super(message);
+/** Bounded WMTS 1.0 capabilities projection. @module */
+import { parseCapabilitiesXml, xmlAttribute, xmlChild, xmlChildren, xmlText, } from "./capabilities-xml.js";
+import { HonuaSdkError } from "./error-envelope.js";
+const incompleteTileMatrixSets = new WeakSet();
+export class HonuaWmtsCapabilitiesParseError extends HonuaSdkError {
+    constructor(message, options = {}) {
+        super("core.wmts-capabilities-parse", message, options);
         this.name = "HonuaWmtsCapabilitiesParseError";
     }
 }
-/**
- * Parse a `Capabilities` text body for WMTS 1.0 into the typed
- * `WmtsCapabilities` shape.
- */
 export function parseWmtsCapabilities(xml) {
-    if (typeof xml !== "string" || xml.length === 0) {
-        throw new HonuaWmtsCapabilitiesParseError("WMTS Capabilities body is empty");
+    try {
+        const root = parseCapabilitiesXml(xml, "WMTS");
+        if (root.localName !== "Capabilities")
+            throw new Error("missing <Capabilities> root element");
+        const warnings = [];
+        const serviceNode = xmlChild(root, "ServiceIdentification");
+        const contents = xmlChild(root, "Contents");
+        const service = compactObject({
+            title: xmlText(xmlChild(serviceNode, "Title")),
+            abstract: xmlText(xmlChild(serviceNode, "Abstract")),
+        });
+        const layers = Object.freeze(xmlChildren(contents, "Layer").flatMap((layer) => parseLayer(layer, warnings)));
+        const tileMatrixSets = Object.freeze(xmlChildren(contents, "TileMatrixSet").flatMap((matrixSet) => parseTileMatrixSet(matrixSet, warnings)));
+        const operations = Object.freeze(parseOperations(xmlChild(root, "OperationsMetadata")));
+        return Object.freeze({
+            version: xmlAttribute(root, "version") ?? "",
+            service,
+            layers,
+            tileMatrixSets,
+            operations,
+            warnings: Object.freeze(unique(warnings)),
+        });
     }
-    const root = findElement(xml, 0, "Capabilities");
-    if (!root) {
-        throw new HonuaWmtsCapabilitiesParseError("missing <Capabilities> root element");
+    catch (cause) {
+        if (cause instanceof HonuaWmtsCapabilitiesParseError)
+            throw cause;
+        const message = cause instanceof Error ? cause.message : "WMTS Capabilities XML is malformed";
+        throw new HonuaWmtsCapabilitiesParseError(message, { cause });
     }
-    const version = readAttribute(root.openTag, "version") ?? "1.0.0";
-    const service = parseServiceMetadata(root.inner);
-    const contents = findElement(root.inner, 0, "Contents");
-    const layers = contents ? collectLayers(contents.inner) : [];
-    const tileMatrixSets = contents ? collectTileMatrixSets(contents.inner) : [];
-    return { version, service, layers, tileMatrixSets };
 }
-function parseServiceMetadata(xml) {
-    const node = findElement(xml, 0, "ows:ServiceIdentification") ?? findElement(xml, 0, "ServiceIdentification");
-    if (!node)
-        return {};
-    const out = {};
-    const title = readTextElement(node.inner, "ows:Title") ?? readTextElement(node.inner, "Title");
-    if (title !== undefined)
-        out.title = title;
-    const abstract = readTextElement(node.inner, "ows:Abstract") ?? readTextElement(node.inner, "Abstract");
-    if (abstract !== undefined)
-        out.abstract = abstract;
-    return out;
-}
-function collectLayers(contentsInner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < contentsInner.length) {
-        const node = findElement(contentsInner, cursor, "Layer");
-        if (!node)
-            break;
-        const identifier = readTextElement(node.inner, "Identifier") ?? readTextElement(node.inner, "ows:Identifier") ?? "";
-        if (identifier.length > 0) {
-            const title = readTextElement(node.inner, "Title") ?? readTextElement(node.inner, "ows:Title");
-            const abstract = readTextElement(node.inner, "Abstract") ?? readTextElement(node.inner, "ows:Abstract");
-            const formats = collectChildText(node.inner, "Format");
-            const styles = collectStyles(node.inner);
-            const tileMatrixSetIds = collectTileMatrixSetLinks(node.inner);
-            const resources = collectResources(node.inner, "tile");
-            const featureInfoResources = collectResources(node.inner, "FeatureInfo");
-            const bbox = readWgs84BoundingBox(node.inner);
-            const layer = {
-                identifier,
-                formats,
-                styles,
-                tileMatrixSetIds,
-                resourceTemplates: resources,
-                featureInfoTemplates: featureInfoResources,
-            };
-            if (title !== undefined)
-                layer.title = title;
-            if (abstract !== undefined)
-                layer.abstract = abstract;
-            if (bbox !== undefined)
-                layer.bbox = bbox;
-            out.push(layer);
+function parseOperations(node) {
+    const seen = new Set();
+    return xmlChildren(node, "Operation").flatMap((operation) => {
+        const name = xmlAttribute(operation, "name");
+        if (!name)
+            return [];
+        if (seen.has(name))
+            throw new Error(`WMTS repeats ${name} operation metadata.`);
+        seen.add(name);
+        const methods = [];
+        const getUrls = [];
+        const postUrls = [];
+        for (const dcp of xmlChildren(operation, "DCP")) {
+            const http = xmlChild(dcp, "HTTP");
+            for (const method of http?.children ?? []) {
+                if (method.localName !== "Get" && method.localName !== "Post")
+                    continue;
+                const normalized = method.localName === "Get" ? "GET" : "POST";
+                if (!methods.includes(normalized))
+                    methods.push(normalized);
+                const href = xmlAttribute(method, "href");
+                if (href)
+                    (normalized === "GET" ? getUrls : postUrls).push(href);
+            }
         }
-        cursor = node.endIndex;
+        return [
+            Object.freeze({
+                name,
+                methods: Object.freeze(methods),
+                getUrls: Object.freeze(unique(getUrls)),
+                postUrls: Object.freeze(unique(postUrls)),
+            }),
+        ];
+    });
+}
+function parseLayer(node, warnings) {
+    const identifier = xmlText(xmlChild(node, "Identifier"));
+    if (!identifier) {
+        warnings.push("WMTS Layer metadata without an identifier was ignored.");
+        return [];
     }
-    return out;
-}
-function collectStyles(layerInner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < layerInner.length) {
-        const node = findElement(layerInner, cursor, "Style");
-        if (!node)
-            break;
-        const identifier = readTextElement(node.inner, "Identifier") ?? readTextElement(node.inner, "ows:Identifier") ?? "";
-        if (identifier.length > 0) {
-            const title = readTextElement(node.inner, "Title") ?? readTextElement(node.inner, "ows:Title");
-            const isDefault = readAttribute(node.openTag, "isDefault") === "true";
-            const legend = findElement(node.inner, 0, "LegendURL");
-            const legendUrl = legend ? readAttribute(legend.openTag, "xlink:href") : undefined;
-            const style = { identifier, isDefault };
-            if (title !== undefined)
-                style.title = title;
-            if (legendUrl !== undefined)
-                style.legendUrl = legendUrl;
-            out.push(style);
-        }
-        cursor = node.endIndex;
+    const bbox = parseWgs84BoundingBox(xmlChild(node, "WGS84BoundingBox"), warnings);
+    return [
+        Object.freeze({
+            identifier,
+            ...optional("title", xmlText(xmlChild(node, "Title"))),
+            ...optional("abstract", xmlText(xmlChild(node, "Abstract"))),
+            formats: Object.freeze(unique(xmlChildren(node, "Format").flatMap((entry) => xmlText(entry) ?? []))),
+            infoFormats: Object.freeze(unique(xmlChildren(node, "InfoFormat").flatMap((entry) => xmlText(entry) ?? []))),
+            styles: Object.freeze(xmlChildren(node, "Style").flatMap((style) => parseStyle(style, warnings))),
+            dimensions: Object.freeze(xmlChildren(node, "Dimension").flatMap((dimension) => parseDimension(dimension, warnings))),
+            tileMatrixSetIds: Object.freeze(unique(xmlChildren(node, "TileMatrixSetLink").flatMap((link) => xmlText(xmlChild(link, "TileMatrixSet")) ?? []))),
+            resourceTemplates: Object.freeze(parseResources(node, "tile", warnings)),
+            featureInfoTemplates: Object.freeze(parseResources(node, "FeatureInfo", warnings)),
+            ...(bbox ? { bbox } : {}),
+        }),
+    ];
+}
+function parseStyle(node, warnings) {
+    const identifier = xmlText(xmlChild(node, "Identifier"));
+    if (!identifier) {
+        warnings.push("WMTS Style metadata without an identifier was ignored.");
+        return [];
     }
-    return out;
-}
-function collectTileMatrixSetLinks(layerInner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < layerInner.length) {
-        const node = findElement(layerInner, cursor, "TileMatrixSetLink");
-        if (!node)
-            break;
-        const tms = readTextElement(node.inner, "TileMatrixSet") ?? readTextElement(node.inner, "ows:TileMatrixSet");
-        if (tms !== undefined && tms.length > 0)
-            out.push(tms);
-        cursor = node.endIndex;
+    const legend = xmlChild(node, "LegendURL");
+    const isDefault = xmlAttribute(node, "isDefault")?.toLowerCase();
+    if (isDefault !== undefined && !["0", "1", "false", "true"].includes(isDefault)) {
+        warnings.push("WMTS Style isDefault metadata was malformed and treated as false.");
     }
-    return out;
-}
-function collectResources(layerInner, resourceType) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < layerInner.length) {
-        const node = findElement(layerInner, cursor, "ResourceURL");
-        if (!node)
-            break;
-        const type = readAttribute(node.openTag, "resourceType");
-        if (type === resourceType) {
-            const format = readAttribute(node.openTag, "format") ?? "";
-            const template = readAttribute(node.openTag, "template") ?? "";
-            if (template.length > 0) {
-                out.push({ format, template });
-            }
-        }
-        cursor = node.endIndex;
+    return [
+        Object.freeze({
+            identifier,
+            ...optional("title", xmlText(xmlChild(node, "Title"))),
+            isDefault: isDefault === "true" || isDefault === "1",
+            ...optional("legendUrl", legend ? xmlAttribute(legend, "href") : undefined),
+            ...optional("legendFormat", legend ? xmlAttribute(legend, "format") : undefined),
+        }),
+    ];
+}
+function parseDimension(node, warnings) {
+    const identifier = xmlText(xmlChild(node, "Identifier"));
+    if (!identifier) {
+        warnings.push("WMTS Dimension metadata without an identifier was ignored.");
+        return [];
+    }
+    const current = xmlText(xmlChild(node, "Current"))?.toLowerCase();
+    if (current !== undefined && !["0", "1", "false", "true"].includes(current)) {
+        warnings.push("WMTS Dimension Current metadata was malformed and treated as false.");
     }
-    return out;
+    return [
+        Object.freeze({
+            identifier,
+            ...optional("default", xmlText(xmlChild(node, "Default"))),
+            current: current === "true" || current === "1",
+            values: Object.freeze(unique(xmlChildren(node, "Value").flatMap((entry) => xmlText(entry) ?? []))),
+        }),
+    ];
+}
+function parseResources(node, resourceType, warnings) {
+    return xmlChildren(node, "ResourceURL").flatMap((resource) => {
+        if (xmlAttribute(resource, "resourceType")?.toLowerCase() !== resourceType.toLowerCase())
+            return [];
+        const template = xmlAttribute(resource, "template");
+        const format = xmlAttribute(resource, "format");
+        if (!template || !format) {
+            warnings.push(`WMTS ${resourceType} ResourceURL metadata without a format or template was ignored.`);
+            return [];
+        }
+        return [Object.freeze({ format, template })];
+    });
 }
-function readWgs84BoundingBox(layerInner) {
-    const node = findElement(layerInner, 0, "WGS84BoundingBox") ?? findElement(layerInner, 0, "ows:WGS84BoundingBox");
+function parseWgs84BoundingBox(node, warnings) {
     if (!node)
         return undefined;
-    const lower = readTextElement(node.inner, "LowerCorner") ?? readTextElement(node.inner, "ows:LowerCorner") ?? "";
-    const upper = readTextElement(node.inner, "UpperCorner") ?? readTextElement(node.inner, "ows:UpperCorner") ?? "";
-    const lowerParts = lower.trim().split(/\s+/).map(Number);
-    const upperParts = upper.trim().split(/\s+/).map(Number);
-    if (lowerParts.length !== 2 ||
-        upperParts.length !== 2 ||
-        !Number.isFinite(lowerParts[0]) ||
-        !Number.isFinite(lowerParts[1]) ||
-        !Number.isFinite(upperParts[0]) ||
-        !Number.isFinite(upperParts[1])) {
+    const lower = coordinatePair(xmlText(xmlChild(node, "LowerCorner")));
+    const upper = coordinatePair(xmlText(xmlChild(node, "UpperCorner")));
+    if (!lower ||
+        !upper ||
+        lower[0] > upper[0] ||
+        lower[1] > upper[1] ||
+        lower[0] < -180 ||
+        upper[0] > 180 ||
+        lower[1] < -90 ||
+        upper[1] > 90) {
+        warnings.push("WMTS WGS84BoundingBox metadata was malformed and ignored.");
         return undefined;
     }
-    return {
-        west: lowerParts[0],
-        south: lowerParts[1],
-        east: upperParts[0],
-        north: upperParts[1],
-    };
-}
-function collectTileMatrixSets(contentsInner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < contentsInner.length) {
-        const node = findElement(contentsInner, cursor, "TileMatrixSet");
-        if (!node)
-            break;
-        const identifier = readTextElement(node.inner, "Identifier") ?? readTextElement(node.inner, "ows:Identifier");
-        // Skip the per-layer `TileMatrixSet` reference inside `TileMatrixSetLink`
-        // (those carry only an identifier and no nested `TileMatrix` children).
-        const matrices = collectTileMatrices(node.inner);
-        if (identifier !== undefined && identifier.length > 0 && matrices.length > 0) {
-            const supportedCrs = readTextElement(node.inner, "SupportedCRS") ?? readTextElement(node.inner, "ows:SupportedCRS");
-            const wellKnown = readTextElement(node.inner, "WellKnownScaleSet") ?? readTextElement(node.inner, "ows:WellKnownScaleSet");
-            const tms = {
-                identifier,
-                matrices,
-            };
-            if (supportedCrs !== undefined)
-                tms.supportedCrs = supportedCrs;
-            if (wellKnown !== undefined)
-                tms.wellKnownScaleSet = wellKnown;
-            out.push(tms);
-        }
-        cursor = node.endIndex;
+    return Object.freeze({ west: lower[0], south: lower[1], east: upper[0], north: upper[1] });
+}
+function parseTileMatrixSet(node, warnings) {
+    const identifier = xmlText(xmlChild(node, "Identifier"));
+    const matrixNodes = xmlChildren(node, "TileMatrix");
+    const matrices = Object.freeze(matrixNodes.flatMap((matrix) => parseTileMatrix(matrix, warnings)));
+    if (!identifier || matrices.length === 0) {
+        warnings.push("WMTS TileMatrixSet metadata without an identifier or valid matrices was ignored.");
+        return [];
     }
-    return out;
-}
-function collectTileMatrices(tmsInner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < tmsInner.length) {
-        const node = findElement(tmsInner, cursor, "TileMatrix");
-        if (!node)
-            break;
-        const identifier = readTextElement(node.inner, "Identifier") ?? readTextElement(node.inner, "ows:Identifier") ?? "";
-        const scale = Number.parseFloat(readTextElement(node.inner, "ScaleDenominator") ?? "");
-        const topLeft = (readTextElement(node.inner, "TopLeftCorner") ?? "").trim().split(/\s+/).map(Number);
-        const tileWidth = Number.parseFloat(readTextElement(node.inner, "TileWidth") ?? "");
-        const tileHeight = Number.parseFloat(readTextElement(node.inner, "TileHeight") ?? "");
-        const matrixWidth = Number.parseFloat(readTextElement(node.inner, "MatrixWidth") ?? "");
-        const matrixHeight = Number.parseFloat(readTextElement(node.inner, "MatrixHeight") ?? "");
-        if (identifier.length > 0 &&
-            Number.isFinite(scale) &&
-            Number.isFinite(tileWidth) &&
-            Number.isFinite(tileHeight) &&
-            Number.isFinite(matrixWidth) &&
-            Number.isFinite(matrixHeight) &&
-            topLeft.length === 2 &&
-            Number.isFinite(topLeft[0]) &&
-            Number.isFinite(topLeft[1])) {
-            out.push({
-                identifier,
-                scaleDenominator: scale,
-                tileWidth,
-                tileHeight,
-                matrixWidth,
-                matrixHeight,
-                topLeftCorner: [topLeft[0], topLeft[1]],
-            });
-        }
-        cursor = node.endIndex;
+    const matrixSet = Object.freeze({
+        identifier,
+        ...optional("supportedCrs", xmlText(xmlChild(node, "SupportedCRS"))),
+        ...optional("wellKnownScaleSet", xmlText(xmlChild(node, "WellKnownScaleSet"))),
+        matrices,
+    });
+    if (matrices.length !== matrixNodes.length)
+        incompleteTileMatrixSets.add(matrixSet);
+    return [matrixSet];
+}
+/** @internal Whether every matrix advertised by this parsed set was structurally valid. */
+export function isWmtsCapabilityTileMatrixSetComplete(matrixSet) {
+    return !incompleteTileMatrixSets.has(matrixSet);
+}
+function parseTileMatrix(node, warnings) {
+    const identifier = xmlText(xmlChild(node, "Identifier"));
+    const scaleDenominator = positiveNumber(xmlText(xmlChild(node, "ScaleDenominator")));
+    const tileWidth = positiveSafeInteger(xmlText(xmlChild(node, "TileWidth")));
+    const tileHeight = positiveSafeInteger(xmlText(xmlChild(node, "TileHeight")));
+    const matrixWidth = positiveSafeInteger(xmlText(xmlChild(node, "MatrixWidth")));
+    const matrixHeight = positiveSafeInteger(xmlText(xmlChild(node, "MatrixHeight")));
+    const topLeftCorner = coordinatePair(xmlText(xmlChild(node, "TopLeftCorner")));
+    if (!identifier ||
+        scaleDenominator === undefined ||
+        tileWidth === undefined ||
+        tileHeight === undefined ||
+        matrixWidth === undefined ||
+        matrixHeight === undefined ||
+        !topLeftCorner) {
+        warnings.push("WMTS TileMatrix metadata with invalid numeric fields was ignored.");
+        return [];
     }
-    return out;
-}
-function collectChildText(inner, tag) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < inner.length) {
-        const node = findElement(inner, cursor, tag);
-        if (!node)
-            break;
-        const text = decodeXmlText(node.inner.trim());
-        if (text.length > 0)
-            out.push(text);
-        cursor = node.endIndex;
-    }
-    return out;
-}
-function findElement(xml, from, tag) {
-    let i = from;
-    while (i < xml.length) {
-        if (xml[i] !== "<") {
-            i += 1;
-            continue;
-        }
-        const next = xml[i + 1];
-        if (next === "!" && xml.startsWith("<!--", i)) {
-            const end = xml.indexOf("-->", i + 4);
-            if (end < 0)
-                return undefined;
-            i = end + 3;
-            continue;
-        }
-        if (next === "!" && xml.startsWith("<![CDATA[", i)) {
-            const end = xml.indexOf("]]>", i + 9);
-            if (end < 0)
-                return undefined;
-            i = end + 3;
-            continue;
-        }
-        if (next === "?" || next === "!") {
-            const end = xml.indexOf(">", i);
-            if (end < 0)
-                return undefined;
-            i = end + 1;
-            continue;
-        }
-        const isClosing = next === "/";
-        const nameStart = isClosing ? i + 2 : i + 1;
-        const matchesTag = xml.startsWith(tag, nameStart) && isTagBoundary(xml.charCodeAt(nameStart + tag.length));
-        if (!matchesTag) {
-            const close = xml.indexOf(">", i);
-            if (close < 0)
-                return undefined;
-            i = close + 1;
-            continue;
-        }
-        const close = xml.indexOf(">", i);
-        if (close < 0)
-            return undefined;
-        const openTag = xml.slice(i, close + 1);
-        const selfClosing = !isClosing && xml.charCodeAt(close - 1) === 47;
-        if (selfClosing)
-            return { openTag, inner: "", endIndex: close + 1 };
-        if (isClosing) {
-            i = close + 1;
-            continue;
-        }
-        let depth = 1;
-        let cursor = close + 1;
-        while (cursor < xml.length && depth > 0) {
-            const angle = xml.indexOf("<", cursor);
-            if (angle < 0)
-                break;
-            const next2 = xml[angle + 1];
-            if (next2 === "!" && xml.startsWith("<!--", angle)) {
-                const end = xml.indexOf("-->", angle + 4);
-                if (end < 0)
-                    return undefined;
-                cursor = end + 3;
-                continue;
-            }
-            if (next2 === "!" && xml.startsWith("<![CDATA[", angle)) {
-                const end = xml.indexOf("]]>", angle + 9);
-                if (end < 0)
-                    return undefined;
-                cursor = end + 3;
-                continue;
-            }
-            const isCloser = next2 === "/";
-            const inspectStart = isCloser ? angle + 2 : angle + 1;
-            const matchesSame = xml.startsWith(tag, inspectStart) && isTagBoundary(xml.charCodeAt(inspectStart + tag.length));
-            const angleClose = xml.indexOf(">", angle);
-            if (angleClose < 0)
-                return undefined;
-            if (matchesSame) {
-                if (isCloser) {
-                    depth -= 1;
-                    if (depth === 0) {
-                        return {
-                            openTag,
-                            inner: xml.slice(close + 1, angle),
-                            endIndex: angleClose + 1,
-                        };
-                    }
-                }
-                else {
-                    const innerSelfClose = xml.charCodeAt(angleClose - 1) === 47;
-                    if (!innerSelfClose)
-                        depth += 1;
-                }
-            }
-            cursor = angleClose + 1;
-        }
+    return [
+        Object.freeze({
+            identifier,
+            scaleDenominator,
+            tileWidth,
+            tileHeight,
+            matrixWidth,
+            matrixHeight,
+            topLeftCorner: Object.freeze(topLeftCorner),
+        }),
+    ];
+}
+function coordinatePair(value) {
+    if (!value)
         return undefined;
-    }
-    return undefined;
-}
-function isTagBoundary(code) {
-    return code === 32 || code === 9 || code === 10 || code === 13 || code === 47 || code === 62;
+    const values = value.trim().split(/\s+/).map(Number);
+    return values.length === 2 && values.every(Number.isFinite) ? [values[0], values[1]] : undefined;
 }
-function readAttribute(openTag, name) {
-    const idx = findAttributeIndex(openTag, name);
-    if (idx < 0)
-        return undefined;
-    const after = openTag.slice(idx + name.length);
-    const eq = after.indexOf("=");
-    if (eq < 0)
+function positiveNumber(value) {
+    if (!value)
         return undefined;
-    let cursor = eq + 1;
-    while (cursor < after.length && /\s/.test(after[cursor]))
-        cursor += 1;
-    const quote = after[cursor];
-    if (quote !== '"' && quote !== "'")
-        return undefined;
-    const end = after.indexOf(quote, cursor + 1);
-    if (end < 0)
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function positiveSafeInteger(value) {
+    if (!value)
         return undefined;
-    return decodeXmlText(after.slice(cursor + 1, end));
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
-function findAttributeIndex(openTag, name) {
-    let i = 0;
-    while (i < openTag.length) {
-        const found = openTag.indexOf(name, i);
-        if (found < 0)
-            return -1;
-        const before = openTag.charCodeAt(found - 1);
-        const isBoundaryStart = found === 0 || before === 32 || before === 9 || before === 10 || before === 13;
-        const after = openTag.charCodeAt(found + name.length);
-        const isBoundaryEnd = after === 61 || after === 32 || after === 9 || after === 10 || after === 13;
-        if (isBoundaryStart && isBoundaryEnd) {
-            return found;
-        }
-        i = found + 1;
-    }
-    return -1;
+function unique(values) {
+    return [...new Set(values)];
 }
-function readTextElement(xml, tag) {
-    const node = findElement(xml, 0, tag);
-    if (!node)
-        return undefined;
-    return decodeXmlText(node.inner.trim());
+function optional(key, value) {
+    return value === undefined ? {} : { [key]: value };
 }
-function decodeXmlText(text) {
-    if (text.indexOf("&") < 0 && text.indexOf("<![CDATA[") < 0)
-        return text;
-    return decodeXmlEntities(text);
+function compactObject(value) {
+    return Object.freeze(Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)));
 }
-/** Find a layer by identifier in a parsed `WmtsCapabilities`. */
 export function findWmtsLayer(capabilities, identifier) {
-    return capabilities.layers.find((l) => l.identifier === identifier);
+    return capabilities.layers.find((layer) => layer.identifier === identifier);
 }
-/** Find a tile-matrix-set by identifier. */
 export function findWmtsTileMatrixSet(capabilities, identifier) {
-    return capabilities.tileMatrixSets.find((t) => t.identifier === identifier);
+    return capabilities.tileMatrixSets.find((tileMatrixSet) => tileMatrixSet.identifier === identifier);
 }