@poe-platform/safe-fs 0.1.734 → 0.1.735

package/dist/safe-fs/platform/node.d.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { FsOptions } from "../contracts/filesystem.js";
 import { type ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number;
@@ -15,7 +14,7 @@ export declare const platform: Readonly<{
     maxCollectionBytes: number;
     errno(code: string): PlatformErrno;
     callbackAuthorities: true;
-    randomUUID: typeof randomUUID;
+    randomUUID: () => string;
 }>;
 export declare const comparisonContext: Readonly<{
     active(_options: FsOptions): boolean;

package/dist/safe-fs/platform/node.js

@@ -25,7 +25,7 @@ export const platform = Object.freeze({
         return errno;
     },
     callbackAuthorities: true,
-    randomUUID
+    randomUUID: randomUUID
 });
 export const comparisonContext = Object.freeze({
     active(_options) {

package/dist/safe-fs/xml.js

@@ -6,21 +6,16 @@ export class XmlLimitError extends SyntaxError {
     }
 }
 function* find(source, needle, start) {
-    let work = 0;
-    for (let offset = start; offset < source.length; offset++) {
-        if (source.startsWith(needle, offset)) {
-            if (work)
-                yield work;
-            return offset;
-        }
-        if (++work === 512) {
-            yield work;
-            work = 0;
-        }
+    const found = source.indexOf(needle, start);
+    const end = found < 0 ? source.length : found;
+    let remaining = end - start;
+    while (remaining >= 512) {
+        yield 512;
+        remaining -= 512;
     }
-    if (work)
-        yield work;
-    return -1;
+    if (remaining > 0)
+        yield remaining;
+    return found;
 }
 const xmlNamespace = "http://www.w3.org/XML/1998/namespace";
 const xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
@@ -47,6 +42,30 @@ function namePart(point) {
         || (point >= 48 && point <= 57) || (point >= 0x300 && point <= 0x36f)
         || (point >= 0x203f && point <= 0x2040);
 }
+function qualifiedNameSync(name) {
+    let prefix = "";
+    let start = 0;
+    let first = true;
+    for (let offset = 0; offset < name.length;) {
+        const point = name.codePointAt(offset);
+        if (point === 58) {
+            if (start !== 0 || first)
+                invalid("invalid qualified name");
+            prefix = name.slice(0, offset);
+            start = offset + 1;
+            first = true;
+        }
+        else {
+            if (!(first ? nameStart(point) : namePart(point)))
+                invalid("invalid qualified name");
+            first = false;
+        }
+        offset += point > 0xffff ? 2 : 1;
+    }
+    if (first)
+        invalid("invalid qualified name");
+    return [prefix, name.slice(start)];
+}
 function* qualifiedName(name) {
     let prefix = "";
     let start = 0;
@@ -258,67 +277,81 @@ export function* parseXmlSteps(input, limits = {}) {
         if (++contentNodes > maxContentNodes)
             throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
     };
-    const whitespace = function* () {
-        let work = 0;
-        while (offset < source.length && " \t\n\r".includes(source[offset])) {
+    let pendingWork = 0;
+    const skipWhitespace = () => {
+        const start = offset;
+        while (offset < source.length) {
+            const c = source.charCodeAt(offset);
+            if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
+                break;
             offset++;
-            if (++work === 512) {
-                yield work;
-                work = 0;
-            }
         }
-        if (work)
-            yield work;
+        return offset - start;
     };
-    const readName = function* () {
+    const scanName = () => {
         const start = offset;
-        while (offset < source.length && !" \t\r\n/=>?".includes(source[offset])) {
+        while (offset < source.length) {
+            const c = source.charCodeAt(offset);
+            if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
+                break;
             offset++;
-            if ((offset - start) % 512 === 0)
-                yield 512;
         }
-        if ((offset - start) % 512)
-            yield (offset - start) % 512;
         const name = source.slice(start, offset);
-        yield* qualifiedName(name);
-        return name;
+        const [prefix, localName] = qualifiedNameSync(name);
+        return [name, prefix, localName, (offset - start) * 2];
     };
-    const appendText = function* (text, kind = "text") {
-        admitText(text);
-        const parent = stack.at(-1);
-        if (parent) {
-            parent.element.text += text;
-            if (text.length || kind === "cdata") {
-                admitContent();
-                if (retainContent)
-                    parent.content.push({ kind, text });
+    while (offset < source.length) {
+        pendingWork += 1;
+        if (pendingWork >= 512) {
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
         }
-        else {
-            for (let index = 0; index < text.length; index++) {
-                if (!" \t\r\n".includes(text[index]))
-                    invalid("text outside the root");
-                if ((index + 1) % 512 === 0)
-                    yield 512;
-            }
-            if (text.length % 512)
-                yield text.length % 512;
-            if (text.length) {
-                admitContent();
-                if (retainContent)
-                    (root ? epilog : prolog).push({ kind, text });
+        if (source.charCodeAt(offset) !== 60) {
+            const next = source.indexOf("<", offset);
+            const endPos = next < 0 ? source.length : next;
+            const text = source.slice(offset, endPos);
+            pendingWork += (endPos - offset) + text.length;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
-        }
-    };
-    while (offset < source.length) {
-        yield 1;
-        if (source[offset] !== "<") {
-            const next = yield* find(source, "<", offset);
-            const text = source.slice(offset, next < 0 ? source.length : next);
-            if ((yield* find(text, "]]>", 0)) >= 0)
+            if (text.indexOf("]]>") >= 0)
                 invalid("CDATA terminator in text");
-            yield* appendText(stack.length ? yield* entities(text) : text);
-            offset += text.length;
+            const resolved = stack.length ? (text.indexOf("&") < 0 ? (pendingWork += text.length, text) : yield* entities(text)) : text;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
+            admitText(resolved);
+            const parent = stack.at(-1);
+            if (parent) {
+                parent.element.text += resolved;
+                if (resolved.length) {
+                    admitContent();
+                    if (retainContent)
+                        parent.content.push({ kind: "text", text: resolved });
+                }
+            }
+            else {
+                for (let index = 0; index < resolved.length; index++) {
+                    const c = resolved.charCodeAt(index);
+                    if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
+                        invalid("text outside the root");
+                }
+                pendingWork += resolved.length;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                if (resolved.length) {
+                    admitContent();
+                    if (retainContent)
+                        (root ? epilog : prolog).push({ kind: "text", text: resolved });
+                }
+            }
+            offset = endPos;
         }
         else if (source.startsWith("<!--", offset)) {
             const end = yield* find(source, "-->", offset + 4);
@@ -340,13 +373,24 @@ export function* parseXmlSteps(input, limits = {}) {
             const end = yield* find(source, "]]>", offset + 9);
             if (end < 0)
                 invalid("unterminated CDATA");
-            yield* appendText(source.slice(offset + 9, end), "cdata");
+            const cdataText = source.slice(offset + 9, end);
+            admitText(cdataText);
+            const parent = stack.at(-1);
+            parent.element.text += cdataText;
+            admitContent();
+            if (retainContent)
+                parent.content.push({ kind: "cdata", text: cdataText });
             offset = end + 3;
         }
         else if (source.startsWith("<?", offset)) {
             const start = offset;
             offset += 2;
-            const target = yield* readName();
+            const [target, , , wName] = scanName();
+            pendingWork += wName;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             const end = yield* find(source, "?>", offset);
             if (end < 0)
                 invalid("unterminated processing instruction");
@@ -363,15 +407,15 @@ export function* parseXmlSteps(input, limits = {}) {
                 invalid("invalid processing instruction");
             if (!(target.length === 3 && target.toLowerCase() === "xml")) {
                 const parent = stack.at(-1);
-                let start = 0;
-                while (start < content.length && " \t\n\r".includes(content[start])) {
-                    start++;
-                    if (start % 512 === 0)
-                        yield 512;
+                let wsStart = 0;
+                while (wsStart < content.length && " \t\n\r".includes(content[wsStart]))
+                    wsStart++;
+                pendingWork += wsStart;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
                 }
-                if (start % 512)
-                    yield start % 512;
-                const text = content.slice(start);
+                const text = content.slice(wsStart);
                 admitText(text);
                 admitContent();
                 if (retainContent) {
@@ -383,92 +427,129 @@ export function* parseXmlSteps(input, limits = {}) {
         else if (source.startsWith("<!", offset)) {
             invalid("DTD and entity declarations are forbidden");
         }
-        else if (source.startsWith("</", offset)) {
+        else if (source.charCodeAt(offset + 1) === 47) {
             offset += 2;
-            const name = yield* readName();
-            yield* whitespace();
+            const [name, , , wName] = scanName();
+            pendingWork += wName + skipWhitespace();
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             if (source[offset++] !== ">" || stack.pop()?.name !== name)
                 invalid("mismatched closing tag");
         }
         else {
             offset++;
-            const name = yield* readName();
+            const [name, prefix, localName, wName] = scanName();
+            pendingWork += wName;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             const attributes = new Map();
+            const attrMeta = [];
             let namespaces = stack.at(-1)?.namespaces ?? new Map([["xml", xmlNamespace]]);
             let ownsNamespaces = stack.length === 0;
             while (true) {
-                const beforeSpace = offset;
-                yield* whitespace();
-                if (source[offset] === "/" || source[offset] === ">")
+                const ws = skipWhitespace();
+                pendingWork += ws;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                const ch = source.charCodeAt(offset);
+                if (ch === 47 || ch === 62)
                     break;
-                if (offset === beforeSpace)
+                if (ws === 0)
                     invalid("attributes require whitespace");
-                const attribute = yield* readName();
+                const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
+                pendingWork += wAttr;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
                 if (attributes.has(attribute))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
                     throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
                 if (attributes.size >= maxAttributesPerElement)
                     throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-                yield* whitespace();
+                pendingWork += skipWhitespace();
                 if (source[offset++] !== "=")
                     invalid("missing attribute equals");
-                yield* whitespace();
+                pendingWork += skipWhitespace();
                 const quote = source[offset++];
                 if (quote !== '"' && quote !== "'")
                     invalid("unquoted attribute");
-                const end = yield* find(source, quote, offset);
+                const end = source.indexOf(quote, offset);
+                const scanLen = (end < 0 ? source.length : end) - offset;
+                pendingWork += scanLen;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
                 if (end < 0)
                     invalid("unterminated attribute");
                 const raw = source.slice(offset, end);
-                if ((yield* find(raw, "<", 0)) >= 0)
+                pendingWork += raw.length * 2;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                if (raw.indexOf("<") >= 0)
                     invalid("less-than in attribute");
-                let normalized = "";
-                for (let index = 0; index < raw.length; index++) {
-                    const character = raw[index];
-                    normalized += character === "\t" || character === "\n" || character === "\r" ? " " : character;
-                    if ((index + 1) % 512 === 0)
-                        yield 512;
+                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);
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
                 }
-                if (raw.length % 512)
-                    yield raw.length % 512;
-                const value = yield* entities(normalized);
                 admitText(value);
                 attributes.set(attribute, value);
+                attrMeta.push([attribute, attrPrefix, attrLocal]);
                 offset = end + 1;
                 if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
-                    const prefix = attribute === "xmlns" ? "" : attribute.slice(6);
-                    if (prefix === "xmlns" || value === xmlnsNamespace
-                        || (prefix === "xml") !== (value === xmlNamespace)
-                        || (prefix !== "" && value === ""))
+                    const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
+                    if (nsPrefix === "xmlns" || value === xmlnsNamespace
+                        || (nsPrefix === "xml") !== (value === xmlNamespace)
+                        || (nsPrefix !== "" && value === ""))
                         invalid("invalid namespace binding");
                     if (!ownsNamespaces) {
                         const copy = new Map();
                         for (const [key, uri] of namespaces) {
                             copy.set(key, uri);
-                            yield 1;
+                            pendingWork += 1;
                         }
                         namespaces = copy;
                         ownsNamespaces = true;
                     }
-                    namespaces.set(prefix, value);
+                    namespaces.set(nsPrefix, value);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
             }
-            const expanded = new Set();
-            for (const attribute of attributes.keys()) {
-                if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
-                    continue;
-                const [prefix, localName] = yield* qualifiedName(attribute);
-                if (prefix && !namespaces.has(prefix))
-                    invalid("unbound attribute prefix");
-                const key = JSON.stringify([prefix ? namespaces.get(prefix) : "", localName]);
-                if (expanded.has(key))
-                    invalid("duplicate expanded attribute");
-                expanded.add(key);
+            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:"))
+                        continue;
+                    pendingWork += attribute.length;
+                    if (attrPrefix && !namespaces.has(attrPrefix))
+                        invalid("unbound attribute prefix");
+                    if (expanded) {
+                        const key = `${attrPrefix ? namespaces.get(attrPrefix) : ""}\0${attrLocal}`;
+                        if (expanded.has(key))
+                            invalid("duplicate expanded attribute");
+                        expanded.add(key);
+                    }
+                }
+            }
+            pendingWork += name.length;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
-            const [prefix, localName] = yield* qualifiedName(name);
             if (prefix === "xmlns" || (prefix && !namespaces.has(prefix)))
                 invalid("unbound element prefix");
             if (++nodes > maxNodes)
@@ -479,12 +560,19 @@ export function* parseXmlSteps(input, limits = {}) {
             limits.onElement?.({ name, namespace, localName }, stack.at(-1)?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
-            for (const [attribute, value] of retainContent ? attributes : []) {
-                const [prefix, localName] = yield* qualifiedName(attribute);
-                admitContent();
-                retainedAttributes.push({ name: attribute, localName,
-                    namespace: attribute === "xmlns" || prefix === "xmlns" ? xmlnsNamespace : prefix ? namespaces.get(prefix) : "", value });
-                yield 1;
+            if (retainContent) {
+                for (let i = 0; i < attrMeta.length; i++) {
+                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
+                    const value = attributes.get(attribute);
+                    admitContent();
+                    retainedAttributes.push({ name: attribute, localName: attrLocal,
+                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? namespaces.get(attrPrefix) : "", value });
+                    pendingWork += attribute.length + 1;
+                }
+            }
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
             const content = retainContent ? [] : 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 }) } : {}) };
@@ -506,6 +594,10 @@ export function* parseXmlSteps(input, limits = {}) {
                 stack.push({ element, content, name, namespaces });
         }
     }
+    if (pendingWork > 0) {
+        yield pendingWork;
+        pendingWork = 0;
+    }
     if (stack.length || !root)
         invalid("incomplete document");
     return root;

package/package.json

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