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

package/core/wms-capabilities.js

@@ -1,559 +1,262 @@
 /**
- * WMS 1.3.0 Capabilities parser. Hand-rolled, narrow-scope text-walker
- * over a `WMS_Capabilities` document. Returns a typed shape (layers,
- * styles, bbox-per-CRS, dimensions, advertised formats) that the SDK
- * can route through the canonical `Source` surface without leaking XML
- * nodes into its public API.
+ * Bounded WMS capabilities projection.
  *
- * The parser is closed-schema (WMS 1.3 + the ISO 19128 service-metadata
- * subset honua-server emits) and tolerates missing optional nodes
- * gracefully. Vendor-extension elements outside the named set are
- * ignored. A `HonuaWmsCapabilitiesParseError` (extends `HonuaError`) is
- * thrown when a required root or top-level node is missing.
+ * The parser accepts the metadata subset needed by discovery and the WMS
+ * runtime, rejects malformed/active XML, and returns plain immutable-friendly
+ * records. Unknown vendor extensions are ignored; required structural drift is
+ * surfaced through {@link HonuaWmsCapabilitiesParseError}.
  *
  * @module
  */
-import { decodeXmlText as decodeXmlEntities } from "./xml-text.js";
-/**
- * Thrown when WMS Capabilities XML is missing required root structure or
- * is otherwise malformed in a way that prevents extracting the typed
- * shape above. Recoverable per-node gaps (missing `<Title>`,
- * `<Abstract>`, etc.) are tolerated and return defaults.
- */
-export class HonuaWmsCapabilitiesParseError extends Error {
-    constructor(message) {
-        super(message);
+import { parseCapabilitiesXml, xmlAttribute, xmlChild, xmlChildren, xmlText, } from "./capabilities-xml.js";
+import { HonuaSdkError } from "./error-envelope.js";
+export class HonuaWmsCapabilitiesParseError extends HonuaSdkError {
+    constructor(message, options = {}) {
+        super("core.wms-capabilities-parse", message, options);
         this.name = "HonuaWmsCapabilitiesParseError";
     }
 }
-/**
- * Parse a `WMS_Capabilities` text body into the typed `WmsCapabilities`
- * shape. The input is the raw XML string returned by `requestText`; the
- * parser walks it once with a small named-element matcher and tolerates
- * vendor extensions (unknown elements are skipped).
- */
 export function parseWmsCapabilities(xml) {
-    if (typeof xml !== "string" || xml.length === 0) {
-        throw new HonuaWmsCapabilitiesParseError("WMS Capabilities body is empty");
-    }
-    const root = findElement(xml, 0, "WMS_Capabilities") ?? findElement(xml, 0, "WMT_MS_Capabilities");
-    if (!root) {
-        throw new HonuaWmsCapabilitiesParseError("missing <WMS_Capabilities> root element (received WMS Capabilities XML?)");
-    }
-    const version = readAttribute(root.openTag, "version") ?? "1.3.0";
-    const service = parseServiceMetadata(root.inner);
-    const capabilityNode = findElement(root.inner, 0, "Capability");
-    const requestNode = capabilityNode ? findElement(capabilityNode.inner, 0, "Request") : undefined;
-    const formats = parseFormats(requestNode?.inner ?? "");
-    const requestSupport = {
-        getFeatureInfo: requestNode ? findElement(requestNode.inner, 0, "GetFeatureInfo") !== undefined : false,
-        getLegendGraphic: requestNode ? findElement(requestNode.inner, 0, "GetLegendGraphic") !== undefined : false,
-    };
-    const layers = [];
-    if (capabilityNode) {
-        for (const layer of iterChildLayers(capabilityNode.inner, [])) {
-            layers.push(layer);
+    try {
+        const root = parseCapabilitiesXml(xml, "WMS");
+        if (root.localName !== "WMS_Capabilities" && root.localName !== "WMT_MS_Capabilities") {
+            throw new Error("missing <WMS_Capabilities> root element (received WMS Capabilities XML?)");
         }
+        const version = xmlAttribute(root, "version") ?? "";
+        const warnings = [];
+        const serviceNode = xmlChild(root, "Service");
+        const service = compactObject({
+            title: xmlText(xmlChild(serviceNode, "Title")),
+            abstract: xmlText(xmlChild(serviceNode, "Abstract")),
+        });
+        const capability = xmlChild(root, "Capability");
+        const requestNode = xmlChild(capability, "Request");
+        const operations = parseOperations(requestNode);
+        const operation = (name) => operations.find((candidate) => candidate.name === name);
+        const formats = Object.freeze({
+            map: operation("GetMap")?.formats ?? Object.freeze([]),
+            featureInfo: operation("GetFeatureInfo")?.formats ?? Object.freeze([]),
+            legend: operation("GetLegendGraphic")?.formats ?? Object.freeze([]),
+        });
+        const request = Object.freeze({
+            getMap: operation("GetMap") !== undefined,
+            getFeatureInfo: operation("GetFeatureInfo") !== undefined,
+            getLegendGraphic: operation("GetLegendGraphic") !== undefined,
+            operations,
+        });
+        const layers = Object.freeze(xmlChildren(capability, "Layer").map((layer) => parseLayer(layer, emptyInheritance(), 0, warnings)));
+        return Object.freeze({ version, service, layers, formats, request, warnings: Object.freeze(unique(warnings)) });
     }
-    return {
-        version,
-        service,
-        layers,
-        formats,
-        request: requestSupport,
-    };
-}
-function parseServiceMetadata(capabilityXml) {
-    const node = findElement(capabilityXml, 0, "Service");
-    if (!node)
-        return {};
-    const out = {};
-    const title = readTextElement(node.inner, "Title");
-    if (title !== undefined)
-        out.title = title;
-    const abstract = readTextElement(node.inner, "Abstract");
-    if (abstract !== undefined)
-        out.abstract = abstract;
-    return out;
-}
-function parseFormats(requestInnerXml) {
-    const map = collectFormats(requestInnerXml, "GetMap");
-    const featureInfo = collectFormats(requestInnerXml, "GetFeatureInfo");
-    const legend = collectFormats(requestInnerXml, "GetLegendGraphic");
-    return { map, featureInfo, legend };
-}
-function collectFormats(requestInnerXml, requestName) {
-    const node = findElement(requestInnerXml, 0, requestName);
-    if (!node)
-        return [];
-    const formats = [];
-    let cursor = 0;
-    while (cursor < node.inner.length) {
-        const fmt = findElement(node.inner, cursor, "Format");
-        if (!fmt)
-            break;
-        const text = decodeXmlText(fmt.inner.trim());
-        if (text.length > 0)
-            formats.push(text);
-        cursor = fmt.endIndex;
+    catch (cause) {
+        if (cause instanceof HonuaWmsCapabilitiesParseError)
+            throw cause;
+        const message = cause instanceof Error ? cause.message : "WMS Capabilities XML is malformed";
+        throw new HonuaWmsCapabilitiesParseError(message, { cause });
     }
-    return formats;
 }
-/**
- * Walk every `<Layer>` element directly inside `parentInner`, applying
- * inherited CRS / dimension / style fields from ancestors per WMS 1.3
- * §7.2.4.6 inheritance rules. Iterative (no recursion through closures)
- * to keep the parse hot path small.
- */
-function* iterChildLayers(parentInner, ancestors) {
-    let cursor = 0;
-    while (cursor < parentInner.length) {
-        const layer = findElement(parentInner, cursor, "Layer");
-        if (!layer)
-            break;
-        const queryableAttr = readAttribute(layer.openTag, "queryable");
-        const inherited = mergeAncestors(ancestors);
-        // Strip nested <Layer>...</Layer> subtrees from the layer's own inner so
-        // descendant Name / Title / CRS / BoundingBox / Style / Dimension nodes
-        // do not leak upward into the parent (and from there into siblings via
-        // `mergeAncestors`). WMS 1.3 §7.2.4.6 inheritance is ancestor → descendant
-        // only; without this guard, an unnamed group layer takes its first child's
-        // name and bleeds the child's style across siblings.
-        const ownInner = stripNestedLayers(layer.inner);
-        const name = readTextElement(ownInner, "Name") ?? "";
-        const title = readTextElement(ownInner, "Title");
-        const abstract = readTextElement(ownInner, "Abstract");
-        const localCrs = collectChildText(ownInner, "CRS");
-        const localBbox = collectBoundingBoxes(ownInner);
-        const localStyles = collectStyles(ownInner);
-        const localDimensions = collectDimensions(ownInner);
-        const mergedCrs = uniqueOrder([...inherited.crs, ...localCrs]);
-        const mergedBbox = mergeBoundingBoxes(inherited.bbox, localBbox);
-        const mergedStyles = mergeStyles(inherited.styles, localStyles);
-        const mergedDimensions = mergeDimensions(inherited.dimensions, localDimensions);
-        const queryable = queryableAttr === "1" || /^true$/i.test(queryableAttr ?? "")
-            ? true
-            : queryableAttr === "0"
-                ? false
-                : inherited.queryable;
-        const node = {
-            name,
-            ...(title !== undefined ? { title } : {}),
-            ...(abstract !== undefined ? { abstract } : {}),
-            crs: mergedCrs,
-            bbox: mergedBbox,
-            styles: mergedStyles,
-            dimensions: mergedDimensions,
-            queryable,
-            children: [],
-        };
-        const ancestorsForChildren = [...ancestors, node];
-        const children = [];
-        for (const child of iterChildLayers(layer.inner, ancestorsForChildren)) {
-            children.push(child);
+function parseOperations(request) {
+    const names = ["GetCapabilities", "GetMap", "GetFeatureInfo", "GetLegendGraphic"];
+    return Object.freeze(names.flatMap((name) => {
+        const nodes = xmlChildren(request, name);
+        if (nodes.length > 1)
+            throw new Error(`WMS Request repeats ${name} operation metadata.`);
+        const node = nodes[0];
+        if (!node)
+            return [];
+        const formats = unique(xmlChildren(node, "Format").flatMap((entry) => xmlText(entry) ?? []));
+        const methods = [];
+        const getUrls = [];
+        const postUrls = [];
+        for (const dcp of xmlChildren(node, "DCPType")) {
+            const http = xmlChild(dcp, "HTTP");
+            for (const method of http?.children ?? []) {
+                if (method.localName !== "Get" && method.localName !== "Post")
+                    continue;
+                const online = xmlChild(method, "OnlineResource") ?? method;
+                const href = xmlAttribute(online, "href");
+                const normalizedMethod = method.localName === "Get" ? "GET" : "POST";
+                if (!methods.includes(normalizedMethod))
+                    methods.push(normalizedMethod);
+                if (href)
+                    (normalizedMethod === "GET" ? getUrls : postUrls).push(href);
+            }
         }
-        yield { ...node, children };
-        cursor = layer.endIndex;
-    }
+        return [
+            Object.freeze({
+                name,
+                formats: Object.freeze(formats),
+                methods: Object.freeze(methods),
+                getUrls: Object.freeze(unique(getUrls)),
+                postUrls: Object.freeze(unique(postUrls)),
+            }),
+        ];
+    }));
 }
-function mergeAncestors(ancestors) {
-    if (ancestors.length === 0) {
-        return { crs: [], bbox: [], styles: [], dimensions: [], queryable: false };
-    }
-    let crs = [];
-    let bbox = [];
-    let styles = [];
-    let dimensions = [];
-    let queryable = false;
-    for (const ancestor of ancestors) {
-        crs = uniqueOrder([...crs, ...ancestor.crs]);
-        bbox = mergeBoundingBoxes(bbox, ancestor.bbox);
-        styles = mergeStyles(styles, ancestor.styles);
-        dimensions = mergeDimensions(dimensions, ancestor.dimensions);
-        queryable = queryable || ancestor.queryable;
-    }
-    return { crs, bbox, styles, dimensions, queryable };
+function emptyInheritance() {
+    return Object.freeze({
+        crs: Object.freeze([]),
+        bbox: Object.freeze([]),
+        styles: Object.freeze([]),
+        dimensions: Object.freeze([]),
+        queryable: false,
+    });
 }
-function uniqueOrder(values) {
-    const seen = new Set();
-    const out = [];
-    for (const v of values) {
-        if (seen.has(v))
-            continue;
-        seen.add(v);
-        out.push(v);
+function parseLayer(node, inherited, depth, warnings) {
+    // The shared XML reader already enforces 32 document levels. This separate
+    // semantic limit keeps a capabilities document from constructing a deeper
+    // recursive public layer object through wrapper elements.
+    if (depth >= 24)
+        throw new Error("WMS Capabilities exceeds the 24-level layer hierarchy limit");
+    const localCrs = xmlChildren(node, "CRS")
+        .concat(xmlChildren(node, "SRS"))
+        .flatMap((candidate) => xmlText(candidate)?.split(/\s+/).filter(Boolean) ?? []);
+    const crs = Object.freeze(unique([...inherited.crs, ...localCrs]));
+    const bbox = Object.freeze(mergeByKey(inherited.bbox, parseBoundingBoxes(node, warnings), (entry) => entry.crs));
+    const styles = Object.freeze(mergeByKey(inherited.styles, parseStyles(node, warnings), (entry) => entry.name));
+    const dimensions = Object.freeze(mergeByKey(inherited.dimensions, parseDimensions(node, warnings), (entry) => entry.name));
+    const queryableValue = xmlAttribute(node, "queryable")?.toLowerCase();
+    if (queryableValue !== undefined && !["0", "1", "false", "true"].includes(queryableValue)) {
+        warnings.push("WMS layer queryable metadata was malformed and inherited conservatively.");
     }
-    return out;
+    const queryable = queryableValue === "1" || queryableValue === "true"
+        ? true
+        : queryableValue === "0" || queryableValue === "false"
+            ? false
+            : inherited.queryable;
+    const next = { crs, bbox, styles, dimensions, queryable };
+    const children = Object.freeze(xmlChildren(node, "Layer").map((child) => parseLayer(child, next, depth + 1, warnings)));
+    return Object.freeze({
+        name: xmlText(xmlChild(node, "Name")) ?? "",
+        ...optional("title", xmlText(xmlChild(node, "Title"))),
+        ...optional("abstract", xmlText(xmlChild(node, "Abstract"))),
+        crs,
+        bbox,
+        styles,
+        dimensions,
+        queryable,
+        children,
+    });
 }
-function mergeBoundingBoxes(parent, local) {
-    if (local.length === 0)
-        return parent;
+function parseBoundingBoxes(node, warnings) {
     const out = [];
-    const seen = new Set();
-    for (const bb of local) {
-        seen.add(bb.crs);
-        out.push(bb);
-    }
-    for (const bb of parent) {
-        if (!seen.has(bb.crs))
-            out.push(bb);
-    }
-    return out;
-}
-function mergeStyles(parent, local) {
-    if (parent.length === 0)
-        return local;
-    const seen = new Set(local.map((s) => s.name));
-    const out = [...local];
-    for (const s of parent) {
-        if (!seen.has(s.name))
-            out.push(s);
-    }
-    return out;
-}
-function mergeDimensions(parent, local) {
-    if (parent.length === 0)
-        return local;
-    const seen = new Set(local.map((d) => d.name));
-    const out = [...local];
-    for (const d of parent) {
-        if (!seen.has(d.name))
-            out.push(d);
-    }
-    return out;
-}
-function collectBoundingBoxes(inner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < inner.length) {
-        const node = findElement(inner, cursor, "BoundingBox");
-        if (!node)
-            break;
-        const crs = readAttribute(node.openTag, "CRS") ?? readAttribute(node.openTag, "SRS");
-        const minx = parseFloatAttr(node.openTag, "minx");
-        const miny = parseFloatAttr(node.openTag, "miny");
-        const maxx = parseFloatAttr(node.openTag, "maxx");
-        const maxy = parseFloatAttr(node.openTag, "maxy");
-        if (crs && Number.isFinite(minx) && Number.isFinite(miny) && Number.isFinite(maxx) && Number.isFinite(maxy)) {
-            out.push({ crs, minx, miny, maxx, maxy });
+    for (const bbox of xmlChildren(node, "BoundingBox")) {
+        const crs = xmlAttribute(bbox, "CRS") ?? xmlAttribute(bbox, "SRS");
+        const minx = finiteNumber(xmlAttribute(bbox, "minx"));
+        const miny = finiteNumber(xmlAttribute(bbox, "miny"));
+        const maxx = finiteNumber(xmlAttribute(bbox, "maxx"));
+        const maxy = finiteNumber(xmlAttribute(bbox, "maxy"));
+        if (crs &&
+            minx !== undefined &&
+            miny !== undefined &&
+            maxx !== undefined &&
+            maxy !== undefined &&
+            minx <= maxx &&
+            miny <= maxy) {
+            out.push(Object.freeze({ crs, minx, miny, maxx, maxy }));
         }
-        cursor = node.endIndex;
-    }
-    // EX_GeographicBoundingBox is the WMS 1.3 alternative geographic bbox node
-    // (always WGS84). honua-server emits both; we pull it as a CRS:84 entry
-    // when the layer has not advertised one already.
-    const geo = findElement(inner, 0, "EX_GeographicBoundingBox");
-    if (geo) {
-        const w = parseFloatText(readTextElement(geo.inner, "westBoundLongitude"));
-        const e = parseFloatText(readTextElement(geo.inner, "eastBoundLongitude"));
-        const s = parseFloatText(readTextElement(geo.inner, "southBoundLatitude"));
-        const n = parseFloatText(readTextElement(geo.inner, "northBoundLatitude"));
-        if (Number.isFinite(w) &&
-            Number.isFinite(e) &&
-            Number.isFinite(s) &&
-            Number.isFinite(n) &&
-            !out.some((bb) => bb.crs === "CRS:84")) {
-            out.push({ crs: "CRS:84", minx: w, miny: s, maxx: e, maxy: n });
+        else {
+            warnings.push("WMS BoundingBox metadata was malformed and ignored.");
         }
     }
-    return out;
-}
-function collectStyles(inner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < inner.length) {
-        const node = findElement(inner, cursor, "Style");
-        if (!node)
-            break;
-        const name = readTextElement(node.inner, "Name") ?? "";
-        const title = readTextElement(node.inner, "Title");
-        const legend = findElement(node.inner, 0, "LegendURL");
-        const onlineResource = legend ? findElement(legend.inner, 0, "OnlineResource") : undefined;
-        const legendUrl = onlineResource ? readAttribute(onlineResource.openTag, "xlink:href") : undefined;
-        if (name.length > 0) {
-            const entry = { name };
-            if (title !== undefined)
-                entry.title = title;
-            if (legendUrl !== undefined)
-                entry.legendUrl = legendUrl;
-            out.push(entry);
+    const geographic = xmlChild(node, "EX_GeographicBoundingBox");
+    if (geographic && !out.some((entry) => entry.crs === "CRS:84")) {
+        const minx = finiteNumber(xmlText(xmlChild(geographic, "westBoundLongitude")));
+        const miny = finiteNumber(xmlText(xmlChild(geographic, "southBoundLatitude")));
+        const maxx = finiteNumber(xmlText(xmlChild(geographic, "eastBoundLongitude")));
+        const maxy = finiteNumber(xmlText(xmlChild(geographic, "northBoundLatitude")));
+        if (minx !== undefined &&
+            miny !== undefined &&
+            maxx !== undefined &&
+            maxy !== undefined &&
+            minx <= maxx &&
+            miny <= maxy &&
+            minx >= -180 &&
+            maxx <= 180 &&
+            miny >= -90 &&
+            maxy <= 90) {
+            out.push(Object.freeze({ crs: "CRS:84", minx, miny, maxx, maxy }));
         }
-        cursor = node.endIndex;
-    }
-    return out;
-}
-function collectDimensions(inner) {
-    const out = [];
-    let cursor = 0;
-    while (cursor < inner.length) {
-        const node = findElement(inner, cursor, "Dimension");
-        if (!node)
-            break;
-        const name = readAttribute(node.openTag, "name");
-        if (typeof name === "string" && name.length > 0) {
-            const units = readAttribute(node.openTag, "units");
-            const def = readAttribute(node.openTag, "default");
-            const text = decodeXmlText(node.inner.trim());
-            const values = text.length > 0
-                ? text
-                    .split(",")
-                    .map((v) => v.trim())
-                    .filter((v) => v.length > 0)
-                : [];
-            const dim = { name, values };
-            if (units !== undefined)
-                dim.units = units;
-            if (def !== undefined)
-                dim.default = def;
-            out.push(dim);
+        else {
+            warnings.push("WMS EX_GeographicBoundingBox metadata was malformed and ignored.");
         }
-        cursor = node.endIndex;
     }
     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;
-}
-/**
- * Return `inner` with every nested `<Layer>...</Layer>` (and self-closed
- * `<Layer .../>`) subtree elided. Used by `iterChildLayers` to read the
- * layer's *own* metadata without walking into descendant layers.
- */
-function stripNestedLayers(inner) {
-    if (inner.indexOf("<Layer") < 0)
-        return inner;
-    let cursor = 0;
-    let out = "";
-    while (cursor < inner.length) {
-        const node = findElement(inner, cursor, "Layer");
-        if (!node) {
-            out += inner.slice(cursor);
-            break;
+function parseStyles(node, warnings) {
+    return xmlChildren(node, "Style").flatMap((style) => {
+        const name = xmlText(xmlChild(style, "Name"));
+        if (!name) {
+            warnings.push("WMS Style metadata without a name was ignored.");
+            return [];
         }
-        out += inner.slice(cursor, node.startIndex);
-        cursor = node.endIndex;
-    }
-    return out;
+        const legend = xmlChild(style, "LegendURL");
+        const resource = xmlChild(legend, "OnlineResource");
+        return [
+            Object.freeze({
+                name,
+                ...optional("title", xmlText(xmlChild(style, "Title"))),
+                ...optional("legendUrl", resource ? xmlAttribute(resource, "href") : undefined),
+                ...optional("legendFormat", xmlText(xmlChild(legend, "Format"))),
+            }),
+        ];
+    });
 }
-/**
- * Find the next `<tag …>…</tag>` (or `<tag …/>`) starting at `from`. The
- * search ignores element nesting other than the requested tag and walks
- * a balanced depth counter for the same tag so nested same-name elements
- * (`<Layer>` inside `<Layer>`) terminate against the correct close. Skips
- * XML comments (`<!-- … -->`) and CDATA sections (`<![CDATA[ … ]]>`).
- */
-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: "", startIndex: i, endIndex: close + 1 };
-        }
-        if (isClosing) {
-            // unmatched closing tag at this level — caller advanced past the
-            // opener. Skip past and keep searching.
-            i = close + 1;
-            continue;
-        }
-        // Walk forward looking for the matching close tag, accounting for
-        // nested same-name openings.
-        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),
-                            startIndex: i,
-                            endIndex: angleClose + 1,
-                        };
-                    }
-                }
-                else {
-                    const innerSelfClose = xml.charCodeAt(angleClose - 1) === 47;
-                    if (!innerSelfClose)
-                        depth += 1;
-                }
-            }
-            cursor = angleClose + 1;
+function parseDimensions(node, warnings) {
+    const candidates = [...xmlChildren(node, "Dimension"), ...xmlChildren(node, "Extent")];
+    return candidates.flatMap((dimension) => {
+        const name = xmlAttribute(dimension, "name");
+        if (!name) {
+            warnings.push("WMS Dimension metadata without a name was ignored.");
+            return [];
         }
-        return undefined;
-    }
-    return undefined;
+        const raw = xmlText(dimension);
+        const values = raw
+            ? raw
+                .split(",")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : [];
+        return [
+            Object.freeze({
+                name,
+                ...optional("units", xmlAttribute(dimension, "units")),
+                ...optional("default", xmlAttribute(dimension, "default")),
+                values: Object.freeze(unique(values)),
+            }),
+        ];
+    });
 }
-function isTagBoundary(code) {
-    // Whitespace, '/', or '>' terminate a tag name.
-    return code === 32 || code === 9 || code === 10 || code === 13 || code === 47 || code === 62;
-}
-function readAttribute(openTag, name) {
-    // Match `name="value"` or `name='value'`. Tolerates leading whitespace
-    // and case-sensitive name match (WMS attribute names are case-sensitive).
-    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 finiteNumber(value) {
+    if (value === undefined || value.trim() === "")
         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)
-        return undefined;
-    return decodeXmlText(after.slice(cursor + 1, end));
-}
-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;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
 }
-function readTextElement(xml, tag) {
-    const node = findElement(xml, 0, tag);
-    if (!node)
-        return undefined;
-    const decoded = decodeXmlText(node.inner.trim());
-    return decoded;
+function unique(values) {
+    return [...new Set(values)];
 }
-function parseFloatAttr(openTag, name) {
-    const value = readAttribute(openTag, name);
-    if (value === undefined)
-        return Number.NaN;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : Number.NaN;
+function mergeByKey(parent, local, key) {
+    const localKeys = new Set(local.map(key));
+    return [...local, ...parent.filter((entry) => !localKeys.has(key(entry)))];
 }
-function parseFloatText(value) {
-    if (value === undefined)
-        return Number.NaN;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : Number.NaN;
+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)));
 }
-/**
- * Walk a parsed `WmsCapabilities` tree and yield every named layer
- * (skipping container layers without a `name`). Useful for descriptor
- * resolution: callers want to bind a `LAYER` name without re-walking
- * the parent hierarchy.
- */
 export function* iterateWmsLayers(capabilities) {
     const stack = [...capabilities.layers];
     while (stack.length > 0) {
         const next = stack.shift();
-        if (!next)
-            break;
         if (next.name.length > 0)
             yield next;
-        for (const child of next.children) {
-            stack.push(child);
-        }
+        stack.unshift(...next.children);
     }
 }
-/**
- * Find the first named layer with a matching name, or `undefined` if the
- * capabilities document does not advertise it. Walks both root layers and
- * children. Intended for the `HonuaWms.layer(name)` resolver path.
- */
 export function findWmsLayer(capabilities, name) {
-    for (const layer of iterateWmsLayers(capabilities)) {
+    for (const layer of iterateWmsLayers(capabilities))
         if (layer.name === name)
             return layer;
-    }
     return undefined;
 }