@poe-platform/safe-fs 0.1.817 → 0.1.819

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

@@ -0,0 +1,69 @@
+import type { XmlSourceSpan } from "./source.js";
+import type { XmlNamespaceScope } from "./frames.js";
+export interface XmlAttributeRecord {
+    name: string;
+    prefix: string;
+    localName: string;
+    value: string;
+    next: number;
+    nameSource?: XmlSourceSpan;
+    localNameSource?: XmlSourceSpan;
+    prefixSource?: XmlSourceSpan;
+    source?: {
+        start: number;
+        end: number;
+    };
+}
+export interface XmlAttributeState {
+    reference: number;
+    first: number;
+    length: number;
+    size: number;
+}
+export type XmlAttributeRequest = {
+    attributeOperation: 'has' | 'expanded';
+    state: XmlAttributeState;
+    name: string;
+    nameSource?: XmlSourceSpan;
+    found?: boolean;
+    namespace?: {
+        scope: XmlNamespaceScope;
+        prefix: string;
+        prefixSource?: XmlSourceSpan;
+    };
+} | {
+    attributeOperation: 'append';
+    state: XmlAttributeState;
+    attribute: Omit<XmlAttributeRecord, 'next'>;
+    result?: XmlAttributeState;
+} | {
+    attributeOperation: 'read';
+    state: XmlAttributeState;
+    reference: number;
+    values: boolean;
+    result?: XmlAttributeRecord;
+};
+/** Buffered APIs use local collections; external parsing retains only a store
+ * handle and one current attribute. Hosts preserve order and last-value recovery. */
+export declare class XmlAttributes {
+    private readonly external;
+    private state;
+    private readonly names;
+    private readonly records;
+    private readonly expandedNames;
+    constructor(external: boolean);
+    get length(): number;
+    get size(): number;
+    get first(): number;
+    has(name: string, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
+    append(name: string, prefix: string, localName: string, value: string, source?: {
+        start: number;
+        end: number;
+    }, nameSource?: XmlSourceSpan, localNameSource?: XmlSourceSpan, prefixSource?: XmlSourceSpan): Generator<XmlAttributeRequest, void, void>;
+    read(reference: number, values: boolean): Generator<XmlAttributeRequest, XmlAttributeRecord, void>;
+    expanded(name: string, namespace?: {
+        scope: XmlNamespaceScope;
+        prefix: string;
+        prefixSource?: XmlSourceSpan;
+    }, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
+}

package/dist/xml-ast/attributes.js

@@ -0,0 +1,62 @@
+/** Buffered APIs use local collections; external parsing retains only a store
+ * handle and one current attribute. Hosts preserve order and last-value recovery. */
+export class XmlAttributes {
+    external;
+    state = { reference: 0, first: 0, length: 0, size: 0 };
+    names = new Map();
+    records = [];
+    expandedNames = new Set();
+    constructor(external) {
+        this.external = external;
+    }
+    get length() { return this.state.length; }
+    get size() { return this.state.size; }
+    get first() { return this.state.first; }
+    *has(name, nameSource) {
+        if (!this.length)
+            return false;
+        if (!this.external)
+            return this.names.has(name);
+        const request = { attributeOperation: 'has', state: this.state, name, ...(nameSource ? { nameSource } : {}) };
+        yield request;
+        if (request.found === undefined)
+            throw new TypeError('Incomplete XML attribute lookup');
+        return request.found;
+    }
+    *append(name, prefix, localName, value, source, nameSource, localNameSource, prefixSource) {
+        if (!this.external) {
+            this.names.set(name, value);
+            this.records.push({ name, prefix, localName });
+            this.state = { reference: 0, first: 1, length: this.records.length, size: this.names.size };
+            return;
+        }
+        const request = { attributeOperation: 'append', state: this.state, attribute: { name, prefix, localName, value, ...(source ? { source } : {}), ...(nameSource ? { nameSource } : {}), ...(localNameSource ? { localNameSource } : {}), ...(prefixSource ? { prefixSource } : {}) } };
+        yield request;
+        if (!request.result)
+            throw new TypeError('Incomplete XML attribute append');
+        this.state = request.result;
+    }
+    *read(reference, values) {
+        if (!this.external) {
+            const attribute = this.records[reference - 1];
+            return { ...attribute, value: values ? this.names.get(attribute.name) : '', next: reference < this.length ? reference + 1 : 0 };
+        }
+        const request = { attributeOperation: 'read', state: this.state, reference, values };
+        yield request;
+        if (!request.result)
+            throw new TypeError('Incomplete XML attribute read');
+        return request.result;
+    }
+    *expanded(name, namespace, nameSource) {
+        if (!this.external) {
+            const found = this.expandedNames.has(name);
+            this.expandedNames.add(name);
+            return found;
+        }
+        const request = { attributeOperation: 'expanded', state: this.state, name, ...(namespace ? { namespace } : {}), ...(nameSource ? { nameSource } : {}) };
+        yield request;
+        if (request.found === undefined)
+            throw new TypeError('Incomplete XML expanded attribute lookup');
+        return request.found;
+    }
+}

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

@@ -1,9 +1,11 @@
-import type { XmlContent, XmlElement } from './index.js';
+import type { XmlSourceStep, XmlSourceSpan } from './source.js';
+import type { XmlContent, XmlElement, XmlName } from './index.js';
 export interface XmlParserFrame {
     element: XmlElement;
     content: XmlContent[] | undefined;
     name: string;
     namespaces: Map<string, string>;
+    namespaceScope?: XmlNamespaceScope;
 }
 export type XmlFrameRequest = {
     readonly frameOperation: 'push';
@@ -26,3 +28,40 @@ export declare class XmlFrames {
     push(frame: XmlParserFrame): Generator<XmlFrameRequest, void, void>;
     pop(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
 }
+/** A host-owned immutable namespace scope; count includes the built-in xml prefix. */
+export interface XmlNamespaceScope {
+    readonly reference: number;
+    readonly size: number;
+}
+export type XmlNamespaceRequest = {
+    readonly namespaceOperation: 'reference';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    reference?: number;
+    complete?: true;
+} | {
+    readonly namespaceOperation: 'has';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    found?: boolean;
+} | {
+    readonly namespaceOperation: 'get';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    value?: string;
+    complete?: true;
+} | {
+    readonly namespaceOperation: 'set';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    readonly value: string | Generator<XmlSourceStep | string, void, void>;
+    result?: XmlNamespaceScope;
+};
+export declare function namespaceValue(scope: Map<string, string> | XmlNamespaceScope, prefix: string, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, string | undefined, void>;
+export declare function namespaceMetadata(scope: Map<string, string> | XmlNamespaceScope, prefix: string, deferred?: boolean, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, Pick<XmlName, 'namespace' | 'namespaceReference'>, void>;
+export declare function hasNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, boolean, void>;
+export declare function bindNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, value: string | Generator<XmlSourceStep | string, void, void>, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, Map<string, string> | XmlNamespaceScope, void>;

package/dist/xml-ast/frames.js

@@ -43,3 +43,45 @@ export class XmlFrames {
         return frame;
     }
 }
+export function* namespaceValue(scope, prefix, prefixSource) {
+    if (scope instanceof Map)
+        return scope.get(prefix);
+    const request = { namespaceOperation: 'get', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (!request.complete)
+        throw new TypeError('Incomplete XML namespace read');
+    return request.value;
+}
+export function* namespaceMetadata(scope, prefix, deferred = false, prefixSource) {
+    if (!deferred || scope instanceof Map)
+        return { namespace: (yield* namespaceValue(scope, prefix, prefixSource)) ?? '' };
+    if (prefix === 'xml')
+        return { namespace: 'http://www.w3.org/XML/1998/namespace' };
+    const request = { namespaceOperation: 'reference', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (!request.complete)
+        throw new TypeError('Incomplete XML namespace reference lookup');
+    return { namespace: '', ...(request.reference === undefined ? {} : { namespaceReference: request.reference }) };
+}
+export function* hasNamespace(scope, prefix, prefixSource) {
+    if (scope instanceof Map)
+        return scope.has(prefix);
+    const request = { namespaceOperation: 'has', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (request.found === undefined)
+        throw new TypeError('Incomplete XML namespace membership lookup');
+    return request.found;
+}
+export function* bindNamespace(scope, prefix, value, prefixSource) {
+    if (scope instanceof Map) {
+        if (typeof value !== 'string')
+            throw new TypeError('Streamed XML namespace values require external scopes');
+        scope.set(prefix, value);
+        return scope;
+    }
+    const request = { namespaceOperation: 'set', scope, prefix, value, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (!request.result)
+        throw new TypeError('Incomplete XML namespace update');
+    return request.result;
+}

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

@@ -1,13 +1,23 @@
-import { type XmlFrameRequest } from "./frames.js";
-export type { XmlParserFrame, XmlFrameRequest } from "./frames.js";
+import { type XmlAttributeRequest } from "./attributes.js";
+export type { XmlAttributeRequest, XmlAttributeRecord, XmlAttributeState } from "./attributes.js";
+import { type XmlNamespaceRequest, type XmlFrameRequest } from "./frames.js";
+export type { XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./frames.js";
 export { normalizeXmlChunks } from "./characters.js";
-import { type XmlSourceStep } from "./source.js";
-export type { XmlSourceRead, XmlSourceStep } from "./source.js";
+import { type XmlSourceSpan, type XmlSourceStep } from "./source.js";
+export type { XmlSourceRead, XmlSourceSpan, XmlSourceStep } from "./source.js";
 import type { XmlStreamEvent } from "./stream.js";
 export { XmlLimitError } from "./errors.js";
 export interface XmlName {
     readonly name: string;
+    readonly nameSource?: XmlSourceSpan;
+    readonly nameReference?: number;
+    readonly localNameSource?: XmlSourceSpan;
+    readonly localNameReference?: number;
+    readonly prefix?: string;
+    readonly prefixSource?: XmlSourceSpan;
+    readonly prefixReference?: number;
     readonly namespace: string;
+    readonly namespaceReference?: number;
     readonly localName: string;
 }
 export interface XmlAttribute extends XmlName {
@@ -19,6 +29,8 @@ export type XmlContent = XmlElement | {
 } | {
     readonly kind: "processing-instruction";
     readonly target: string;
+    readonly targetSource?: XmlSourceSpan;
+    readonly targetReference?: number;
     readonly text: string;
 };
 export interface XmlElement extends XmlName {
@@ -61,11 +73,27 @@ export interface XmlSourceLimits extends XmlStepLimits {
     readonly fragmentContent?: boolean;
     /** Store active parser frames through host-serviced requests. Requires retainTree: false. */
     readonly storeFrames?: boolean;
+    /** Resolve namespace scopes through host-serviced requests. Requires retainTree: false. */
+    readonly storeNamespaces?: boolean;
+    /** Carry host namespace token references in event metadata. Requires stored namespaces. */
+    readonly deferNamespaces?: boolean;
+    /** Emit long processing-instruction targets as source spans. Requires fragmentContent. */
+    readonly deferContentNames?: boolean;
+    /** Defer long element names and, with external namespaces, their prefixes. */
+    readonly deferElementNames?: boolean;
+    /** Defer attribute names and namespace declaration prefixes to source spans. */
+    readonly deferAttributeNames?: boolean;
+    /** Store attribute collections through host requests and emit resolved attributes individually. */
+    readonly storeAttributes?: boolean;
+    readonly fragmentAttributes?: boolean;
+    readonly onAttribute?: (attribute: XmlAttribute, element: XmlElement, continuation?: boolean) => void;
 }
-export type XmlParseStep = XmlSourceStep | XmlFrameRequest;
+export type XmlParseStep = XmlSourceStep | XmlFrameRequest | XmlNamespaceRequest | XmlAttributeRequest;
 /** Parse a validated, BOM-free, line-normalized UTF-16 source via bounded read requests. */
 export declare function parseXmlSourceSteps(length: number | undefined, limits?: XmlStepLimits & {
     readonly storeFrames?: false;
+    readonly storeNamespaces?: false;
+    readonly storeAttributes?: false;
 }): Generator<XmlSourceStep, XmlElement, void>;
 export declare function parseXmlSourceSteps(length: number | undefined, limits: XmlSourceLimits): Generator<XmlParseStep, XmlElement, void>;
 export declare function parseXmlSteps(input: string, limits?: XmlStepLimits): Generator<number, XmlElement, void>;