@poe-platform/safe-fs 0.1.813 → 0.1.815

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

@@ -54,7 +54,9 @@ export interface XmlStepLimits extends XmlLimits {
     readonly events?: (event: XmlStreamEvent) => void;
 }
 export interface XmlSourceLimits extends XmlStepLimits {
-    /** Emit text and CDATA in bounded fragments, marking continuations of the same logical
+    /** Keep normalized declaration fields instead of the complete source spelling. */
+    readonly compactDeclaration?: boolean;
+    /** Emit content bodies in bounded fragments, marking continuations of the same logical
      * node. Requires retainTree: false; consumers must preserve fragment identity. */
     readonly fragmentContent?: boolean;
     /** Store active parser frames through host-serviced requests. Requires retainTree: false. */

package/dist/xml-ast/index.js

@@ -176,11 +176,10 @@ function* entities(text, recover) {
     }
     return result;
 }
-function* validDeclaration(content, expectedEncoding) {
-    let offset = 0;
+function* readDeclaration(source, offset, end, expectedEncoding) {
     const whitespace = function* () {
         const start = offset;
-        while (offset < content.length && " \t\n\r".includes(content[offset])) {
+        while (offset < end && " \t\n\r".includes(yield* source.slice(offset, offset + 1))) {
             offset++;
             if ((offset - start) % 512 === 0)
                 yield 512;
@@ -189,53 +188,58 @@ function* validDeclaration(content, expectedEncoding) {
             yield (offset - start) % 512;
         return offset - start;
     };
-    const field = function* (name) {
-        if (content.slice(offset, offset + name.length) !== name)
+    const field = function* (name, maxLength) {
+        if ((yield* source.slice(offset, Math.min(end, offset + name.length))) !== name)
             return undefined;
         offset += name.length;
         yield name.length;
         yield* whitespace();
-        if (content[offset++] !== "=")
+        if (offset >= end || (yield* source.charCodeAt(offset++)) !== 61)
             return undefined;
         yield* whitespace();
-        const quote = content[offset++];
+        if (offset >= end)
+            return undefined;
+        const quote = yield* source.slice(offset++, offset);
         if (quote !== "'" && quote !== '"')
             return undefined;
         const start = offset;
-        while (offset < content.length && content[offset] !== quote) {
+        while (offset < end && (yield* source.slice(offset, offset + 1)) !== quote) {
             offset++;
             if ((offset - start) % 512 === 0)
                 yield 512;
         }
         if ((offset - start) % 512)
             yield (offset - start) % 512;
-        if (offset >= content.length)
+        if (offset >= end || offset - start > maxLength)
             return undefined;
-        return content.slice(start, offset++);
+        return yield* source.slice(start, offset++);
     };
-    if (!(yield* whitespace()) || (yield* field("version")) !== "1.0")
-        return false;
+    if (!(yield* whitespace()) || (yield* field("version", 3)) !== "1.0")
+        return undefined;
+    let result = '<?xml version="1.0"';
     let spacing = yield* whitespace();
-    if (content.slice(offset, offset + 8) === "encoding") {
+    if ((yield* source.slice(offset, Math.min(end, offset + 8))) === "encoding") {
         if (!spacing)
-            return false;
-        const encoding = yield* field("encoding");
-        if (encoding === undefined || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase()))
-            return false;
+            return undefined;
+        const encoding = yield* field("encoding", 8);
+        if (encoding === undefined || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase()))
+            return undefined;
         if (expectedEncoding !== undefined && encoding.toLowerCase() !== expectedEncoding.toLowerCase()
             && !(encoding.toLowerCase() === "utf-16" && (expectedEncoding === "UTF-16LE" || expectedEncoding === "UTF-16BE")))
-            return false;
+            return undefined;
+        result += ` encoding="${encoding}"`;
         spacing = yield* whitespace();
     }
-    if (content.slice(offset, offset + 10) === "standalone") {
+    if ((yield* source.slice(offset, Math.min(end, offset + 10))) === "standalone") {
         if (!spacing)
-            return false;
-        const standalone = yield* field("standalone");
-        if (standalone === undefined || standalone.length > 3 || !["yes", "no"].includes(standalone))
-            return false;
+            return undefined;
+        const standalone = yield* field("standalone", 3);
+        if (standalone === undefined || !["yes", "no"].includes(standalone))
+            return undefined;
+        result += ` standalone="${standalone}"`;
         yield* whitespace();
     }
-    return offset === content.length;
+    return offset === end ? result + "?>" : undefined;
 }
 function validateLimits(limits) {
     for (const limit of [limits.maxDepth, limits.maxNodes, limits.maxAttributes, limits.maxContentNodes, limits.maxAttributesPerElement, limits.maxNamespaces]) {
@@ -326,6 +330,33 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
         return [name, prefix, localName];
     };
+    const rawContent = function* (kind, start, end, parent, target = "") {
+        if (end - start > maxTextLength - textLength)
+            throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+        textLength += end - start;
+        admitContent();
+        let cursor = start, continuation = false;
+        do {
+            let finish = limits.fragmentContent ? Math.min(end, cursor + 512) : end;
+            if (finish < end) {
+                const last = yield* source.charCodeAt(finish - 1);
+                if (last >= 0xd800 && last <= 0xdbff)
+                    finish--;
+            }
+            const text = yield* source.slice(cursor, finish);
+            const content = kind === "processing-instruction" ? { kind, target, text } : { kind, text };
+            if (kind === "cdata" && retainTree)
+                parent.element.text += text;
+            if (retain)
+                (parent?.content ?? (root ? epilog : prolog)).push(content);
+            limits.events?.({ type: "content", content, parent: parent?.element,
+                ...(continuation ? { continuation: true } : {}) });
+            if (limits.fragmentContent)
+                yield Math.max(1, text.length);
+            continuation = true;
+            cursor = finish;
+        } while (cursor < end);
+    };
     while (yield* source.has(offset)) {
         pendingWork += 1;
         if (pendingWork >= 512) {
@@ -431,17 +462,10 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         else if ((yield* source.startsWith("<!--", offset))) {
             const end = yield* find(source, "-->", offset + 4);
-            const text = end < 0 ? "" : yield* source.slice(offset + 4, end);
-            if (end < 0 || (yield* find(text, "--", 0)) >= 0 || text.endsWith("-")) {
+            if (end < 0 || (yield* source.indexOf("--", offset + 4, end)) >= 0
+                || (end > offset + 4 && (yield* source.charCodeAt(end - 1)) === 45))
                 invalid("malformed comment");
-            }
-            const parent = (yield* stack.peek());
-            admitText(text);
-            admitContent();
-            if (retain) {
-                (parent?.content ?? (root ? epilog : prolog)).push({ kind: "comment", text });
-            }
-            limits.events?.({ type: "content", content: { kind: "comment", text }, parent: parent?.element });
+            yield* rawContent("comment", offset + 4, end, yield* stack.peek());
             offset = end + 3;
         }
         else if ((yield* source.startsWith("<![CDATA[", offset))) {
@@ -450,32 +474,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             const end = yield* find(source, "]]>", offset + 9);
             if (end < 0)
                 invalid("unterminated CDATA");
-            if (end - offset - 9 > maxTextLength - textLength)
-                throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
-            const parent = (yield* stack.peek());
-            admitContent();
-            let cursor = offset + 9, continuation = false;
-            do {
-                let finish = limits.fragmentContent ? Math.min(end, cursor + 512) : end;
-                if (finish < end) {
-                    const last = yield* source.charCodeAt(finish - 1);
-                    if (last >= 0xd800 && last <= 0xdbff)
-                        finish--;
-                }
-                const text = yield* source.slice(cursor, finish);
-                admitText(text);
-                if (retainTree)
-                    parent.element.text += text;
-                if (retain)
-                    parent.content.push({ kind: "cdata", text });
-                limits.events?.({ type: "content", content: { kind: "cdata", text }, parent: parent.element,
-                    ...(continuation ? { continuation: true } : {}) });
-                // Let external consumers persist each fragment before producing another.
-                if (limits.fragmentContent)
-                    yield Math.max(1, text.length);
-                continuation = true;
-                cursor = finish;
-            } while (cursor < end);
+            yield* rawContent("cdata", offset + 9, end, yield* stack.peek());
             offset = end + 3;
         }
         else if ((yield* source.startsWith("<?", offset))) {
@@ -489,34 +488,32 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             const end = yield* find(source, "?>", offset);
             if (end < 0)
                 invalid("unterminated processing instruction");
-            const content = (yield* source.slice(offset, end));
             if (target.length === 3 && target.toLowerCase() === "xml") {
-                if (start !== 0 || target !== "xml"
-                    || !(yield* validDeclaration(content, limits.expectedEncoding))) {
+                if (start !== 0 || target !== "xml")
+                    invalid("unsupported XML declaration");
+                const parsed = yield* readDeclaration(source, offset, end, limits.expectedEncoding);
+                if (parsed === undefined)
                     invalid("unsupported XML declaration");
-                }
                 if (retainContent)
-                    declaration = (yield* source.slice(start, end + 2));
+                    declaration = limits.compactDeclaration ? parsed : yield* source.slice(start, end + 2);
             }
-            else if (content && !" \t\n\r".includes(content[0]))
-                invalid("invalid processing instruction");
-            if (!(target.length === 3 && target.toLowerCase() === "xml")) {
-                const parent = (yield* stack.peek());
-                let wsStart = 0;
-                while (wsStart < content.length && " \t\n\r".includes(content[wsStart]))
-                    wsStart++;
-                pendingWork += wsStart;
+            else {
+                if (offset < end && !" \t\n\r".includes(yield* source.slice(offset, offset + 1)))
+                    invalid("invalid processing instruction");
+                let body = offset;
+                while (body < end && " \t\n\r".includes(yield* source.slice(body, body + 1))) {
+                    body++;
+                    pendingWork++;
+                    if (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                }
                 while (pendingWork >= 512) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                const text = content.slice(wsStart);
-                admitText(text);
-                admitContent();
-                if (retain) {
-                    (parent?.content ?? (root ? epilog : prolog)).push({ kind: "processing-instruction", target, text });
-                }
-                limits.events?.({ type: "content", content: { kind: "processing-instruction", target, text }, parent: parent?.element });
+                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target);
             }
             offset = end + 2;
         }

package/package.json

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