@poe-platform/safe-fs 0.1.817 → 0.1.819

package/dist/xml-ast/index.js

@@ -1,4 +1,5 @@
-import { XmlFrames } from "./frames.js";
+import { XmlAttributes } from "./attributes.js";
+import { XmlFrames, bindNamespace, namespaceValue, namespaceMetadata, hasNamespace } from "./frames.js";
 import { validCharacter } from "./characters.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { XmlSource } from "./source.js";
@@ -67,6 +68,41 @@ function qualifiedNameSync(name, cache) {
     }
     return parts;
 }
+/** Validate a name span without retaining its spelling. */
+function* validateNameSpan(source, start, end) {
+    let first = true, colon = -1, work = 0;
+    for (let offset = start; offset < end;) {
+        let point = yield* source.charCodeAt(offset);
+        if (point >= 0xd800 && point <= 0xdbff && offset + 1 < end) {
+            const low = yield* source.charCodeAt(offset + 1);
+            if (low >= 0xdc00 && low <= 0xdfff)
+                point = 0x10000 + (point - 0xd800) * 1024 + low - 0xdc00;
+        }
+        if (point === 58) {
+            if (colon >= 0 || first)
+                invalid("invalid qualified name");
+            colon = offset;
+            first = true;
+        }
+        else {
+            if (!(first ? nameStart(point) : namePart(point)))
+                invalid("invalid qualified name");
+            first = false;
+        }
+        const size = point > 0xffff ? 2 : 1;
+        offset += size;
+        work += size;
+        if (work >= 512) {
+            yield 512;
+            work -= 512;
+        }
+    }
+    if (first)
+        invalid("invalid qualified name");
+    if (work)
+        yield work;
+    return colon;
+}
 function* entity(source, start, end, recover) {
     // Inspect only a bounded prefix, even for arbitrarily long numeric references.
     const prefix = typeof source === "string" ? source.slice(start, Math.min(end, start + 4))
@@ -101,7 +137,7 @@ function* entity(source, start, end, recover) {
     return String.fromCodePoint(point);
 }
 /** Decoded text fragments; source read/work requests remain host-serviced. */
-function* textParts(source, start, end, decode, recover) {
+function* textParts(source, start, end, decode, recover, attribute = false) {
     let cursor = start;
     while (cursor < end) {
         let finish = Math.min(end, cursor + 512);
@@ -110,7 +146,13 @@ function* textParts(source, start, end, decode, recover) {
             if (last >= 0xd800 && last <= 0xdbff)
                 finish--;
         }
-        const raw = yield* source.slice(cursor, finish);
+        let raw = yield* source.slice(cursor, finish);
+        if (attribute) {
+            let normalized = "";
+            for (const character of raw)
+                normalized += "\t\n\r".includes(character) ? " " : character;
+            raw = normalized;
+        }
         const found = decode ? raw.indexOf("&") : -1;
         if (found < 0) {
             yield raw;
@@ -139,9 +181,9 @@ function* textParts(source, start, end, decode, recover) {
         cursor = semicolon + 1;
     }
 }
-function* textFragments(source, start, end, decode, recover) {
+function* textFragments(source, start, end, decode, recover, attribute = false) {
     let pending = "";
-    for (const part of textParts(source, start, end, decode, recover)) {
+    for (const part of textParts(source, start, end, decode, recover, attribute)) {
         if (typeof part !== "string") {
             yield part;
             continue;
@@ -253,8 +295,22 @@ function validateLimits(limits) {
 }
 export function* parseXmlSourceSteps(length, limits = {}) {
     validateLimits(limits);
+    if (limits.deferAttributeNames && (!limits.storeAttributes || !limits.storeNamespaces))
+        throw new TypeError("Deferred attribute names require stored attributes and namespaces");
+    if (limits.deferElementNames && limits.retainTree !== false)
+        throw new TypeError("Deferred element names require retainTree: false");
+    if (limits.deferContentNames && !limits.fragmentContent)
+        throw new TypeError("Deferred XML content names require fragmentContent: true");
+    if (limits.fragmentAttributes && !limits.storeAttributes)
+        throw new TypeError("XML attribute fragments require storeAttributes: true");
     if (limits.storeFrames && limits.retainTree !== false)
         throw new TypeError("Stored XML frames require retainTree: false");
+    if (limits.storeAttributes && limits.retainTree !== false)
+        throw new TypeError("Stored XML attributes require retainTree: false");
+    if (limits.deferNamespaces && !limits.storeNamespaces)
+        throw new TypeError("Deferred XML namespaces require stored namespaces");
+    if (limits.storeNamespaces && limits.retainTree !== false)
+        throw new TypeError("Stored XML namespaces require retainTree: false");
     if (limits.fragmentContent && limits.retainTree !== false)
         throw new TypeError("XML content fragments require retainTree: false");
     const source = new XmlSource(length);
@@ -277,6 +333,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
         textLength += text.length;
     };
+    const initialNamespaces = limits.storeNamespaces ? yield* bindNamespace({ reference: 0, size: 0 }, "xml", xmlNamespace) : new Map([["xml", xmlNamespace]]);
     const stack = new XmlFrames(limits.storeFrames === true);
     let root;
     const prolog = [];
@@ -308,7 +365,24 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         return offset - start;
     };
-    const scanName = function* () {
+    const sameName = function* (left, right, span) {
+        if (!left.nameSource && !span)
+            return left.name === right;
+        const leftLength = left.nameSource ? left.nameSource.end - left.nameSource.start : left.name.length;
+        const rightLength = span ? span.end - span.start : right.length;
+        if (leftLength !== rightLength)
+            return false;
+        for (let index = 0; index < leftLength; index += 512) {
+            const end = Math.min(leftLength, index + 512);
+            const a = left.nameSource ? yield* source.slice(left.nameSource.start + index, left.nameSource.start + end) : left.name.slice(index, end);
+            const b = span ? yield* source.slice(span.start + index, span.start + end) : right.slice(index, end);
+            yield end - index;
+            if (a !== b)
+                return false;
+        }
+        return true;
+    };
+    const scanName = function* (defer) {
         const start = offset;
         while (yield* source.has(offset)) {
             const c = (yield* source.charCodeAt(offset));
@@ -321,6 +395,21 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
         }
+        if (defer && offset - start > 512) {
+            const colon = yield* validateNameSpan(source, start, offset);
+            if (defer === "content")
+                return ["", "", "", { start, end: offset }];
+            if (colon - start > 512 && !limits.storeNamespaces) {
+                const name = yield* source.slice(start, offset);
+                return [name, name.slice(0, colon - start), name.slice(colon - start + 1)];
+            }
+            const localStart = colon < 0 ? start : colon + 1;
+            const prefixSource = colon - start > 512 ? { start, end: colon } : undefined;
+            const prefix = colon < 0 || prefixSource ? "" : yield* source.slice(start, colon);
+            const localNameSource = offset - localStart > 512 ? { start: localStart, end: offset } : undefined;
+            const local = localNameSource ? "" : yield* source.slice(localStart, offset);
+            return ["", prefix, local, { start, end: offset }, localNameSource, prefixSource];
+        }
         const name = (yield* source.slice(start, offset));
         pendingWork += offset - start;
         while (pendingWork >= 512) {
@@ -330,7 +419,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
         return [name, prefix, localName];
     };
-    const rawContent = function* (kind, start, end, parent, target = "") {
+    const rawContent = function* (kind, start, end, parent, target = "", targetSource) {
         if (end - start > maxTextLength - textLength)
             throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
         textLength += end - start;
@@ -344,7 +433,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     finish--;
             }
             const text = yield* source.slice(cursor, finish);
-            const content = kind === "processing-instruction" ? { kind, target, text } : { kind, text };
+            const content = kind === "processing-instruction" ? { kind, target, text, ...(targetSource ? { targetSource } : {}) } : { kind, text };
             if (kind === "cdata" && retainTree)
                 parent.element.text += text;
             if (retain)
@@ -480,7 +569,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         else if ((yield* source.startsWith("<?", offset))) {
             const start = offset;
             offset += 2;
-            const [target] = yield* scanName();
+            const [target, , , targetSource] = yield* scanName(limits.deferContentNames ? "content" : undefined);
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
@@ -513,7 +602,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target);
+                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target, targetSource);
             }
             offset = end + 2;
         }
@@ -522,14 +611,14 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         else if ((yield* source.charCodeAt(offset + 1)) === 47) {
             offset += 2;
-            const [name] = yield* scanName();
+            const [name, , , nameSource] = yield* scanName(limits.deferElementNames ? "element" : undefined);
             yield* skipWhitespace();
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
             }
             const closed = (yield* source.slice(offset++, offset)) === ">" ? (yield* stack.pop()) : undefined;
-            if (closed?.name !== name) {
+            if (!closed || !(yield* sameName(closed.element, name, nameSource))) {
                 if (!limits.recover)
                     invalid("mismatched closing tag");
                 limits.recover("mismatched closing tag");
@@ -540,9 +629,9 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         else {
             offset++;
             const repeated = previousEmpty && (yield* source.startsWith(previousEmpty.suffix, offset)) ? previousEmpty : undefined;
-            const [name, prefix, localName] = repeated
+            const [name, prefix, localName, nameSource, localNameSource, prefixSource] = repeated
                 ? [repeated.name, repeated.prefix, repeated.localName]
-                : (yield* scanName());
+                : (yield* scanName(limits.deferElementNames ? "element" : undefined));
             if (repeated)
                 offset += name.length;
             // Preserve scan/validation work while reusing the admitted spelling.
@@ -552,9 +641,9 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            let attributes;
-            const attrMeta = [];
-            let namespaces = (yield* stack.peek())?.namespaces ?? new Map([["xml", xmlNamespace]]);
+            const attributes = new XmlAttributes(limits.storeAttributes === true);
+            const namespaceParent = yield* stack.peek();
+            let namespaces = namespaceParent?.namespaceScope ?? namespaceParent?.namespaces ?? (initialNamespaces instanceof Map ? new Map(initialNamespaces) : initialNamespaces);
             let ownsNamespaces = stack.length === 0;
             while (!repeated) {
                 const ws = (yield* skipWhitespace());
@@ -567,16 +656,16 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     break;
                 if (ws === 0)
                     invalid("attributes require whitespace");
-                const [attribute, attrPrefix, attrLocal] = yield* scanName();
+                const [attribute, attrPrefix, attrLocal, nameSource, localNameSource, attrPrefixSource] = yield* scanName(limits.deferAttributeNames ? "attribute" : undefined);
                 while (pendingWork >= 512) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                if (attributes?.has(attribute))
+                if ((yield* attributes.has(attribute, nameSource)))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
                     throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
-                if ((attributes?.size ?? 0) >= maxAttributesPerElement)
+                if (attributes.size >= maxAttributesPerElement)
                     throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
                 yield* skipWhitespace();
                 if ((yield* source.slice(offset++, offset)) !== "=")
@@ -594,31 +683,59 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 }
                 if (end < 0)
                     invalid("unterminated attribute");
-                const raw = (yield* source.slice(offset, end));
-                pendingWork += raw.length * 2;
-                while (pendingWork >= 512) {
-                    yield 512;
-                    pendingWork -= 512;
+                const fragmented = limits.fragmentAttributes && (limits.storeNamespaces || attribute !== "xmlns" && attrPrefix !== "xmlns");
+                const valueStart = offset;
+                let value = "", size = 0, matchesXml = true, matchesXmlns = true;
+                if (fragmented) {
+                    if ((yield* source.indexOf("<", offset, end)) >= 0)
+                        invalid("less-than in attribute");
+                    for (const part of textFragments(source, offset, end, true, limits.recover, true)) {
+                        if (typeof part !== "string")
+                            yield part;
+                        else {
+                            matchesXml = matchesXml && part === xmlNamespace.slice(size, size + part.length);
+                            matchesXmlns = matchesXmlns && part === xmlnsNamespace.slice(size, size + part.length);
+                            size += part.length;
+                        }
+                    }
+                    matchesXml = matchesXml && size === xmlNamespace.length;
+                    matchesXmlns = matchesXmlns && size === xmlnsNamespace.length;
+                    if (size > maxTextLength - textLength)
+                        throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+                    textLength += size;
                 }
-                if (raw.indexOf("<") >= 0)
-                    invalid("less-than in attribute");
-                const normalized = /[\t\n\r]/.test(raw) ? raw.replace(/[\t\n\r]/g, " ") : raw;
-                const value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized, limits.recover);
-                while (pendingWork >= 512) {
-                    yield 512;
-                    pendingWork -= 512;
+                else {
+                    const raw = (yield* source.slice(offset, end));
+                    pendingWork += raw.length * 2;
+                    while (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                    if (raw.indexOf("<") >= 0)
+                        invalid("less-than in attribute");
+                    let normalized = raw;
+                    if (raw.includes("\t") || raw.includes("\n") || raw.includes("\r")) {
+                        normalized = "";
+                        for (const character of raw)
+                            normalized += "\t\n\r".includes(character) ? " " : character;
+                    }
+                    value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized, limits.recover);
+                    while (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                    admitText(value);
                 }
-                admitText(value);
-                (attributes ??= new Map()).set(attribute, value);
-                attrMeta.push([attribute, attrPrefix, attrLocal]);
+                yield* attributes.append(attribute, attrPrefix, attrLocal, value, limits.fragmentAttributes ? { start: offset, end } : undefined, nameSource, localNameSource, attrPrefixSource);
                 offset = end + 1;
-                if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
-                    const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
-                    if (nsPrefix === "xmlns" || value === xmlnsNamespace
-                        || (nsPrefix === "xml") !== (value === xmlNamespace)
-                        || (nsPrefix !== "" && value === ""))
+                if (attribute === "xmlns" || attrPrefix === "xmlns") {
+                    const nsPrefix = attribute === "xmlns" ? "" : attrLocal;
+                    const nsPrefixSource = attrPrefix === "xmlns" ? localNameSource : undefined;
+                    if (nsPrefix === "xmlns" || (fragmented ? matchesXmlns : value === xmlnsNamespace)
+                        || (nsPrefix === "xml") !== (fragmented ? matchesXml : value === xmlNamespace)
+                        || ((nsPrefix !== "" || nsPrefixSource) && (fragmented ? size === 0 : value === "")))
                         invalid("invalid namespace binding");
-                    if (!ownsNamespaces) {
+                    if (!ownsNamespaces && namespaces instanceof Map) {
                         const copy = new Map();
                         for (const [key, uri] of namespaces) {
                             copy.set(key, uri);
@@ -627,25 +744,27 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         namespaces = copy;
                         ownsNamespaces = true;
                     }
-                    namespaces.set(nsPrefix, value);
+                    namespaces = yield* bindNamespace(namespaces, nsPrefix, fragmented
+                        ? textFragments(source, valueStart, end, true, limits.recover ? () => { } : undefined, true) : value, nsPrefixSource);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
             }
-            if (attrMeta.length > 0) {
-                const expanded = attrMeta.length > 1 ? new Set() : undefined;
-                for (let i = 0; i < attrMeta.length; i++) {
-                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
-                    if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
+            if (attributes.length > 0) {
+                for (let cursor = attributes.first; cursor;) {
+                    const record = yield* attributes.read(cursor, false);
+                    cursor = record.next;
+                    const { name: attribute, prefix: attrPrefix, localName: attrLocal } = record;
+                    if (attribute === "xmlns" || attrPrefix === "xmlns")
                         continue;
                     pendingWork += attribute.length;
-                    if (attrPrefix && !namespaces.has(attrPrefix))
+                    if ((attrPrefix || record.prefixSource) && !(yield* hasNamespace(namespaces, attrPrefix, record.prefixSource)))
                         invalid("unbound attribute prefix");
-                    if (expanded) {
-                        const key = `${attrPrefix ? namespaces.get(attrPrefix) : ""}\0${attrLocal}`;
-                        if (expanded.has(key))
+                    if (attributes.length > 1) {
+                        const backed = limits.storeAttributes && !(namespaces instanceof Map) ? namespaces : undefined;
+                        const key = backed ? attrLocal : `${attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : ""}\0${attrLocal}`;
+                        if (yield* attributes.expanded(key, backed ? { scope: backed, prefix: attrPrefix, ...(record.prefixSource ? { prefixSource: record.prefixSource } : {}) } : undefined, record.localNameSource))
                             invalid("duplicate expanded attribute");
-                        expanded.add(key);
                     }
                 }
             }
@@ -654,23 +773,26 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            if (prefix === "xmlns" || (prefix && !namespaces.has(prefix)))
+            if (prefix === "xmlns" || ((prefix || prefixSource) && !(yield* hasNamespace(namespaces, prefix, prefixSource))))
                 invalid("unbound element prefix");
             if (++nodes > maxNodes)
                 throw new XmlLimitError("maxNodes", "XML resource limit exceeded");
             if (stack.length + 1 > maxDepth)
                 throw new XmlLimitError("maxDepth", "XML resource limit exceeded");
-            const namespace = namespaces.get(prefix) ?? "";
-            limits.onElement?.({ name, namespace, localName }, (yield* stack.peek())?.element, stack.length + 1);
+            const namespace = yield* namespaceMetadata(namespaces, prefix, limits.deferNamespaces, prefixSource);
+            const elementName = { name, localName, ...(nameSource ? { nameSource, prefix } : {}), ...(localNameSource ? { localNameSource } : {}), ...(prefixSource ? { prefixSource } : {}) };
+            limits.onElement?.({ ...elementName, ...namespace }, (yield* stack.peek())?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
-            if (retainContent && attributes) {
-                for (let i = 0; i < attrMeta.length; i++) {
-                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
-                    const value = attributes.get(attribute);
+            if (retainContent) {
+                for (let cursor = attributes.first; cursor;) {
+                    const record = yield* attributes.read(cursor, !limits.storeAttributes);
+                    cursor = record.next;
+                    const { name: attribute, prefix: attrPrefix, localName: attrLocal, value } = record;
                     admitContent();
-                    retainedAttributes.push({ name: attribute, localName: attrLocal,
-                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? namespaces.get(attrPrefix) : "", value });
+                    if (!limits.storeAttributes)
+                        retainedAttributes.push({ name: attribute, localName: attrLocal,
+                            namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : "", value });
                     pendingWork += attribute.length + 1;
                 }
             }
@@ -679,7 +801,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
             const content = retain ? [] : undefined;
-            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
+            const element = { kind: "element", ...elementName, ...namespace, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent && namespaces instanceof Map ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
             const parent = (yield* stack.peek());
             if (parent) {
                 if (retainTree) {
@@ -701,11 +823,37 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
             // Only cache compact, attribute-free spellings. Namespace resolution and
             // every admission counter still run for each distinct physical element.
-            if (empty && !attributes && name.length <= 512 && (yield* source.slice(offset - name.length - 3, offset)) === `<${name}/>`)
+            if (empty && !nameSource && !attributes.length && name.length <= 512 && (yield* source.slice(offset - name.length - 3, offset)) === `<${name}/>`)
                 previousEmpty = { suffix: name + "/>", name, prefix, localName };
             limits.events?.({ type: "open", element, parent: parent?.element });
+            if (limits.storeAttributes && limits.onAttribute && retainContent) {
+                yield 1;
+                for (let cursor = attributes.first; cursor;) {
+                    const attribute = yield* attributes.read(cursor, true);
+                    cursor = attribute.next;
+                    const namespace = attribute.name === "xmlns" || attribute.prefix === "xmlns" ? { namespace: xmlnsNamespace }
+                        : attribute.prefix || attribute.prefixSource ? yield* namespaceMetadata(namespaces, attribute.prefix, limits.deferNamespaces, attribute.prefixSource) : { namespace: "" };
+                    const nameMetadata = { name: attribute.name, localName: attribute.localName, ...(attribute.nameSource ? { nameSource: attribute.nameSource, prefix: attribute.prefix } : {}), ...(attribute.localNameSource ? { localNameSource: attribute.localNameSource } : {}), ...(attribute.prefixSource ? { prefixSource: attribute.prefixSource } : {}) };
+                    let continuation = false;
+                    if (attribute.source) {
+                        for (const part of textFragments(source, attribute.source.start, attribute.source.end, true, limits.recover ? () => { } : undefined, true)) {
+                            if (typeof part !== "string") {
+                                yield part;
+                                continue;
+                            }
+                            limits.onAttribute({ ...nameMetadata, ...namespace, value: part }, element, continuation);
+                            continuation = true;
+                            yield 1;
+                        }
+                    }
+                    if (!continuation) {
+                        limits.onAttribute({ ...nameMetadata, ...namespace, value: attribute.value }, element);
+                        yield 1;
+                    }
+                }
+            }
             if (!empty)
-                yield* stack.push({ element, content, name, namespaces });
+                yield* stack.push({ element, content, name, namespaces: namespaces instanceof Map ? namespaces : new Map(), ...(namespaces instanceof Map ? {} : { namespaceScope: namespaces }) });
             else
                 limits.events?.({ type: "close", element, parent: parent?.element });
         }

package/dist/xml-ast/source.d.ts

@@ -1,3 +1,7 @@
+export interface XmlSourceSpan {
+    readonly start: number;
+    readonly end: number;
+}
 /** Fill value before advancing. Streaming reads may be short; mark complete at EOF. */
 export interface XmlSourceRead {
     readonly offset: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.817",
+  "version": "0.1.819",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",