@poe-platform/safe-bash 0.1.817 → 0.1.819

package/dist/safe-bash/command-chunks/chunk-WOECEZAC.js

@@ -0,0 +1,921 @@
+// packages/safe-bash-xml-engine/src/stored-map.ts
+var StoredStringMap = class _StoredStringMap {
+  constructor(storage, budget, reference = 0) {
+    this.storage = storage;
+    this.budget = budget;
+    this.reference = reference;
+  }
+  storage;
+  budget;
+  reference;
+  async read(reference) {
+    const bytes = await this.storage.read(reference, 40);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return {
+      key: view.getFloat64(0, true),
+      value: view.getFloat64(8, true),
+      left: view.getFloat64(16, true),
+      right: view.getFloat64(24, true),
+      height: view.getFloat64(32, true)
+    };
+  }
+  async write(entry) {
+    const bytes = new Uint8Array(40), view = new DataView(bytes.buffer);
+    view.setFloat64(0, entry.key, true);
+    view.setFloat64(8, entry.value, true);
+    view.setFloat64(16, entry.left, true);
+    view.setFloat64(24, entry.right, true);
+    view.setFloat64(32, entry.height, true);
+    return this.storage.append(bytes);
+  }
+  async storeString(parts) {
+    const header = new Uint8Array(8), reference = await this.storage.append(header);
+    let size = 0;
+    for await (const value of parts) for (let offset = 0; offset < value.length; offset += 4096) {
+      const length = Math.min(4096, value.length - offset), bytes = new Uint8Array(length * 2);
+      const view = new DataView(bytes.buffer);
+      const checkpoint = this.budget.tick(length);
+      if (checkpoint) await checkpoint;
+      for (let index = 0; index < length; index++) view.setUint16(index * 2, value.charCodeAt(offset + index), true);
+      await this.storage.append(bytes);
+      size += length;
+    }
+    new DataView(header.buffer).setFloat64(0, size, true);
+    await this.storage.write(reference, header);
+    return reference;
+  }
+  async compare(value, reference) {
+    const header = await this.storage.read(reference, 8);
+    const length = new DataView(header.buffer, header.byteOffset, 8).getFloat64(0, true);
+    const valueHeader = typeof value === "number" ? await this.storage.read(value, 8) : void 0;
+    const valueLength = valueHeader ? new DataView(valueHeader.buffer, valueHeader.byteOffset, 8).getFloat64(0, true) : value.length;
+    const common = Math.min(length, valueLength);
+    for (let offset = 0; offset < common; offset += 4096) {
+      const count = Math.min(4096, common - offset);
+      const checkpoint = this.budget.tick(count);
+      if (checkpoint) await checkpoint;
+      const bytes = await this.storage.read(reference + 8 + offset * 2, count * 2);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      const other = typeof value === "number" ? await this.storage.read(value + 8 + offset * 2, count * 2) : void 0;
+      const otherView = other ? new DataView(other.buffer, other.byteOffset, other.byteLength) : void 0;
+      for (let index = 0; index < count; index++) {
+        const difference = (otherView ? otherView.getUint16(index * 2, true) : value.charCodeAt(offset + index)) - view.getUint16(index * 2, true);
+        if (difference) return difference;
+      }
+    }
+    return valueLength - length;
+  }
+  async *valueParts(reference) {
+    const header = await this.storage.read(reference, 8);
+    const length = new DataView(header.buffer, header.byteOffset, 8).getFloat64(0, true);
+    for (let offset = 0; offset < length; ) {
+      let count = Math.min(4096, length - offset);
+      const checkpoint = this.budget.tick(count);
+      if (checkpoint) await checkpoint;
+      const bytes = await this.storage.read(reference + 8 + offset * 2, count * 2);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      const last = view.getUint16((count - 1) * 2, true);
+      if (offset + count < length && last >= 55296 && last <= 56319) count--;
+      const units = new Uint16Array(count);
+      for (let index = 0; index < count; index++) units[index] = view.getUint16(index * 2, true);
+      yield String.fromCharCode(...units);
+      offset += count;
+    }
+  }
+  async string(reference) {
+    const parts = [];
+    for await (const part of this.valueParts(reference)) parts.push(part);
+    return parts.join("");
+  }
+  /** Compare handles from this storage, or a short literal, without buffered values. */
+  async equals(reference, other) {
+    if (typeof other === "string") return await this.compare(other, reference) === 0;
+    if (reference === other) return true;
+    const leftHeader = await this.storage.read(reference, 8), rightHeader = await this.storage.read(other, 8);
+    const length = new DataView(leftHeader.buffer, leftHeader.byteOffset, 8).getFloat64(0, true);
+    if (length !== new DataView(rightHeader.buffer, rightHeader.byteOffset, 8).getFloat64(0, true)) return false;
+    for (let offset = 0; offset < length * 2; offset += 8192) {
+      const size = Math.min(8192, length * 2 - offset);
+      const checkpoint = this.budget.tick(size);
+      if (checkpoint) await checkpoint;
+      const left = await this.storage.read(reference + 8 + offset, size), right = await this.storage.read(other + 8 + offset, size);
+      for (let index = 0; index < size; index++) if (left[index] !== right[index]) return false;
+    }
+    return true;
+  }
+  /** Locate a value without loading it; callers testing membership need only its reference. */
+  async lookup(key) {
+    let reference = this.reference;
+    while (reference) {
+      const checkpoint = this.budget.tick(1);
+      if (checkpoint) await checkpoint;
+      const entry = await this.read(reference), order = await this.compare(key, entry.key);
+      if (!order) return entry.value;
+      reference = order < 0 ? entry.left : entry.right;
+    }
+    return void 0;
+  }
+  async get(key) {
+    const reference = await this.lookup(key);
+    return reference === void 0 ? void 0 : this.string(reference);
+  }
+  async height(reference) {
+    return reference ? (await this.read(reference)).height : 0;
+  }
+  async updated(entry) {
+    return this.write({ ...entry, height: 1 + Math.max(await this.height(entry.left), await this.height(entry.right)) });
+  }
+  async rotate(entry, left) {
+    const pivot = await this.read(left ? entry.right : entry.left);
+    const child = await this.updated(left ? { ...entry, right: pivot.left } : { ...entry, left: pivot.right });
+    return this.updated(left ? { ...pivot, left: child } : { ...pivot, right: child });
+  }
+  async balance(entry) {
+    const difference = await this.height(entry.left) - await this.height(entry.right);
+    if (difference > 1) {
+      const child = await this.read(entry.left);
+      if (await this.height(child.left) < await this.height(child.right)) entry = { ...entry, left: await this.rotate(child, true) };
+      return this.rotate(entry, false);
+    }
+    if (difference < -1) {
+      const child = await this.read(entry.right);
+      if (await this.height(child.right) < await this.height(child.left)) entry = { ...entry, right: await this.rotate(child, false) };
+      return this.rotate(entry, true);
+    }
+    return this.updated(entry);
+  }
+  async set(key, value) {
+    const storedKey = typeof key === "string" || typeof key === "number" ? key : await this.storeString(key);
+    const suppliedReference = typeof value === "string" ? void 0 : "reference" in value ? value.reference : await this.storeString(value);
+    const insert = async (reference) => {
+      if (!reference) return this.write({ key: typeof storedKey === "number" ? storedKey : await this.storeString([storedKey]), value: suppliedReference ?? await this.storeString([value]), left: 0, right: 0, height: 1 });
+      const entry = await this.read(reference);
+      const checkpoint = this.budget.tick(1);
+      if (checkpoint) await checkpoint;
+      const order = await this.compare(storedKey, entry.key);
+      if (!order) return await this.equals(entry.value, suppliedReference ?? value) ? reference : this.write({ ...entry, value: suppliedReference ?? await this.storeString([value]) });
+      const side = order < 0 ? "left" : "right";
+      const child = await insert(entry[side]);
+      return child === entry[side] ? reference : this.balance({ ...entry, [side]: child });
+    };
+    return new _StoredStringMap(this.storage, this.budget, await insert(this.reference));
+  }
+  /** Traverse both token handles without materializing namespace prefixes. */
+  async *tokenReferences() {
+    const visit = async function* (scope, reference) {
+      if (!reference) return;
+      const entry = await scope.read(reference);
+      yield* visit(scope, entry.left);
+      yield [entry.key, entry.value];
+      yield* visit(scope, entry.right);
+    };
+    yield* visit(this, this.reference);
+  }
+  async *references() {
+    for await (const [key, value] of this.tokenReferences()) yield [await this.string(key), value];
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const [key, reference] of this.references()) yield [key, await this.string(reference)];
+  }
+};
+
+// packages/safe-bash-xml-engine/src/parser-attributes.ts
+var StoredParserAttributes = class {
+  constructor(storage, budget, sourceParts) {
+    this.storage = storage;
+    this.budget = budget;
+    this.sourceParts = sourceParts;
+  }
+  storage;
+  budget;
+  sourceParts;
+  async number(reference, offset = 0) {
+    if (!reference) return 0;
+    const bytes = await this.storage.read(reference + offset, 8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  async set(reference, offset, value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.storage.write(reference + offset, bytes);
+  }
+  async append(attribute) {
+    const source = JSON.stringify(attribute), encoder = new TextEncoder();
+    const reference = await this.storage.append(new Uint8Array(16));
+    let size = 0;
+    for (let offset = 0; offset < source.length; ) {
+      let end = Math.min(source.length, offset + 4096);
+      const last = source.charCodeAt(end - 1);
+      if (end < source.length && last >= 55296 && last <= 56319) end--;
+      const bytes = encoder.encode(source.slice(offset, end));
+      const checkpoint = this.budget.tick(bytes.length);
+      if (checkpoint) await checkpoint;
+      await this.storage.append(bytes);
+      size += bytes.length;
+      offset = end;
+    }
+    await this.set(reference, 8, size);
+    return reference;
+  }
+  async execute(request) {
+    const store = request.state.reference;
+    if (request.attributeOperation === "has" || request.attributeOperation === "expanded") {
+      const offset = request.attributeOperation === "has" ? 16 : 24;
+      const values = new StoredStringMap(this.storage, this.budget, await this.number(store, offset));
+      const sourceParts = this.sourceParts;
+      if (request.attributeOperation === "expanded" && request.namespace) {
+        const { scope, prefix, prefixSource } = request.namespace;
+        const namespaces = new StoredStringMap(this.storage, this.budget, scope.reference);
+        const key = prefixSource ? await namespaces.storeString(sourceParts(prefixSource)) : prefix;
+        const uri = prefix || prefixSource ? await namespaces.lookup(key) : void 0;
+        const parts = (async function* () {
+          if (uri !== void 0) yield* namespaces.valueParts(uri);
+          yield "\0";
+          if (request.nameSource) yield* sourceParts(request.nameSource);
+          else yield request.name;
+        })();
+        const next = await values.set(parts, "1");
+        request.found = next.reference === values.reference;
+        if (!request.found) await this.set(store, offset, next.reference);
+      } else {
+        const key = request.nameSource ? await values.storeString(sourceParts(request.nameSource)) : request.name;
+        request.found = await values.lookup(key) !== void 0;
+        if (request.attributeOperation === "expanded" && !request.found) {
+          const next = await values.set(key, "1");
+          await this.set(store, offset, next.reference);
+        }
+      }
+      return;
+    }
+    if (request.attributeOperation === "append") {
+      const reference = store || await this.storage.append(new Uint8Array(32));
+      const values = new StoredStringMap(this.storage, this.budget, await this.number(reference, 16));
+      const nameKey = request.attribute.nameSource ? await values.storeString(this.sourceParts(request.attribute.nameSource)) : request.attribute.name;
+      const existing = await values.lookup(nameKey);
+      const updated = await values.set(nameKey, request.attribute.source ? "" : request.attribute.value);
+      const { value: ignoredValue, ...metadata } = request.attribute;
+      const attribute = await this.append({ ...metadata, ...typeof nameKey === "number" ? { nameKey } : {} });
+      const last = await this.number(reference, 8);
+      if (last) await this.set(last, 0, attribute);
+      else await this.set(reference, 0, attribute);
+      await this.set(reference, 8, attribute);
+      await this.set(reference, 16, updated.reference);
+      request.result = {
+        reference,
+        first: request.state.first || attribute,
+        length: request.state.length + 1,
+        size: request.state.size + (existing === void 0 ? 1 : 0)
+      };
+      return;
+    }
+    if (request.attributeOperation === "read") {
+      const size = await this.number(request.reference, 8), decoder = new TextDecoder(), parts = [];
+      for (let offset = 0; offset < size; offset += 16384) {
+        const length = Math.min(16384, size - offset);
+        const checkpoint = this.budget.tick(length);
+        if (checkpoint) await checkpoint;
+        parts.push(decoder.decode(await this.storage.read(request.reference + 16 + offset, length), { stream: true }));
+      }
+      parts.push(decoder.decode());
+      const metadata = JSON.parse(parts.join(""));
+      const values = new StoredStringMap(this.storage, this.budget, await this.number(store, 16));
+      const value = request.values && !metadata.source ? await values.get(metadata.nameKey ?? metadata.name) : "";
+      if (value === void 0) throw new TypeError("Missing stored XML attribute value");
+      const { nameKey: ignoredKey, ...attribute } = metadata;
+      request.result = { ...attribute, value, next: await this.number(request.reference) };
+    }
+  }
+};
+
+// packages/safe-bash-xml-engine/src/frames.ts
+var StoredXmlFrames = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  head = 0;
+  async execute(request) {
+    if (request.frameOperation === "push") {
+      const frame = request.frame;
+      const { namespaces: namespaces2, ...element } = frame.element;
+      const record2 = {
+        name: frame.name,
+        element,
+        namespaces: [...frame.namespaces],
+        retainNamespaces: namespaces2 === frame.namespaces,
+        ...frame.namespaceScope ? { namespaceScope: frame.namespaceScope } : {}
+      };
+      const source2 = JSON.stringify(record2);
+      const reference = this.storage.allocate(16 + source2.length * 2);
+      const header2 = new Uint8Array(16), view2 = new DataView(header2.buffer);
+      view2.setFloat64(0, this.head, true);
+      view2.setFloat64(8, source2.length, true);
+      await this.storage.write(reference, header2);
+      for (let index = 0; index < source2.length; index += 4096) {
+        const length2 = Math.min(4096, source2.length - index);
+        const bytes = new Uint8Array(length2 * 2), data = new DataView(bytes.buffer);
+        for (let offset = 0; offset < length2; offset++) data.setUint16(offset * 2, source2.charCodeAt(index + offset), true);
+        await this.storage.write(reference + 16 + index * 2, bytes);
+      }
+      this.head = reference;
+      return;
+    }
+    if (!this.head) throw new TypeError("Empty XML frame store");
+    const header = await this.storage.read(this.head, 16), view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+    if (request.frameOperation === "pop") {
+      this.head = view.getFloat64(0, true);
+      return;
+    }
+    const length = view.getFloat64(8, true);
+    let source = "";
+    for (let index = 0; index < length; index += 4096) {
+      const count = Math.min(4096, length - index);
+      const bytes = await this.storage.read(this.head + 16 + index * 2, count * 2);
+      const data = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), units = new Uint16Array(count);
+      for (let offset = 0; offset < count; offset++) units[offset] = data.getUint16(offset * 2, true);
+      source += String.fromCharCode(...units);
+    }
+    const record = JSON.parse(source);
+    const namespaces = new Map(record.namespaces);
+    request.frame = {
+      name: record.name,
+      namespaces,
+      content: void 0,
+      ...record.namespaceScope ? { namespaceScope: record.namespaceScope } : {},
+      element: { ...record.element, namespaces: record.retainNamespaces ? namespaces : /* @__PURE__ */ new Map() }
+    };
+  }
+};
+
+// packages/safe-bash-xml-engine/src/recovery.ts
+import { normalizeXmlChunks, parseXmlSourceSteps } from "@poe-platform/safe-fs/core";
+import { PagedStorage, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+async function parseStoredXml(source, context, budget, recover, consume, options = {}) {
+  const cache = new PagedStorageCache(4);
+  const storage = new PagedStorage(context, 4, cache);
+  const frameStorage = recover ? storage : new PagedStorage(context, 4, cache);
+  const input = normalizeXmlChunks(source, !recover);
+  let sourceDone = false;
+  try {
+    context.registerCleanup?.(storage.close.bind(storage));
+    if (frameStorage !== storage) context.registerCleanup?.(frameStorage.close.bind(frameStorage));
+    const start = storage.allocate(0);
+    let length = 0;
+    async function readNext() {
+      const next = await input.next();
+      if (next.done) {
+        sourceDone = true;
+        return;
+      }
+      const chunk = next.value;
+      const bytes = new Uint8Array(chunk.length * 2), view = new DataView(bytes.buffer);
+      for (let index = 0; index < chunk.length; index++) view.setUint16(index * 2, chunk.charCodeAt(index), true);
+      await storage.append(bytes);
+      length += chunk.length;
+      const checkpoint = budget.tick(Math.min(chunk.length, 512));
+      if (checkpoint) await checkpoint;
+    }
+    if (recover) while (!sourceDone) await readNext();
+    async function completeSourceRead(request) {
+      while (length <= request.offset && !sourceDone) await readNext();
+      const count = Math.min(request.length, Math.max(0, length - request.offset));
+      const bytes = await storage.read(start + request.offset * 2, count * 2);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      const units = new Uint16Array(count);
+      for (let index = 0; index < units.length; index++) units[index] = view.getUint16(index * 2, true);
+      request.value = String.fromCharCode(...units);
+      if (request.streaming) request.complete = sourceDone && request.offset + count === length;
+    }
+    async function* sourceParts(span) {
+      for (let offset = span.start; offset < span.end; ) {
+        const request = { offset, length: Math.min(512, span.end - offset) };
+        await completeSourceRead(request);
+        let part = request.value;
+        const last = part.charCodeAt(part.length - 1);
+        if (offset + part.length < span.end && last >= 55296 && last <= 56319) part = part.slice(0, -1);
+        if (!part.length) throw new TypeError("Incomplete XML name source span");
+        const checkpoint = budget.tick(part.length);
+        if (checkpoint) await checkpoint;
+        yield part;
+        offset += part.length;
+      }
+    }
+    const queued = [];
+    const frames = new StoredXmlFrames(frameStorage);
+    const attributes = new StoredParserAttributes(frameStorage, budget, sourceParts);
+    const parser = parseXmlSourceSteps(recover ? length : void 0, {
+      ...budget.limits,
+      ...options,
+      maxContentNodes: budget.limits.maxNodes,
+      expectedEncoding: "UTF-8",
+      retainTree: false,
+      storeFrames: true,
+      storeNamespaces: true,
+      storeAttributes: true,
+      fragmentAttributes: true,
+      fragmentContent: true,
+      compactDeclaration: true,
+      ...recover ? { recover } : {},
+      ...consume ? { events: (event) => {
+        queued.push(event);
+      }, onAttribute: (attribute, element, continuation = false) => {
+        queued.push({ type: "attribute", attribute, element, continuation });
+      } } : {}
+    });
+    let step = parser.next();
+    try {
+      while (true) {
+        for (const event of queued) await consume(event, (reference) => new StoredStringMap(frameStorage, budget).valueParts(reference), sourceParts);
+        queued.length = 0;
+        if (step.done) {
+          await frameStorage.close();
+          await storage.close();
+          return step.value;
+        }
+        if (typeof step.value === "number") {
+          const checkpoint = budget.tick(step.value);
+          if (checkpoint) await checkpoint;
+        } else if ("attributeOperation" in step.value) {
+          await attributes.execute(step.value);
+        } else if ("namespaceOperation" in step.value) {
+          const request = step.value;
+          const scope = new StoredStringMap(frameStorage, budget, request.scope.reference);
+          const key = request.prefixSource ? await scope.storeString(sourceParts(request.prefixSource)) : request.prefix;
+          if (request.namespaceOperation === "reference") {
+            const reference = await scope.lookup(key);
+            if (reference !== void 0) request.reference = reference;
+            request.complete = true;
+          } else if (request.namespaceOperation === "has") {
+            request.found = await scope.lookup(key) !== void 0;
+          } else if (request.namespaceOperation === "get") {
+            const previous = await scope.get(key);
+            if (previous !== void 0) request.value = previous;
+            request.complete = true;
+          } else {
+            const previous = await scope.lookup(key);
+            const value = request.value;
+            const parts = typeof value === "string" ? value : (async function* () {
+              for (const part of value) {
+                if (typeof part === "string") yield part;
+                else if (typeof part === "number") {
+                  const checkpoint = budget.tick(part);
+                  if (checkpoint) await checkpoint;
+                } else await completeSourceRead(part);
+              }
+            })();
+            const next = await scope.set(key, parts);
+            request.result = { reference: next.reference, size: request.scope.size + (previous === void 0 ? 1 : 0) };
+          }
+        } else if ("frameOperation" in step.value) {
+          await frames.execute(step.value);
+        } else {
+          await completeSourceRead(step.value);
+        }
+        step = parser.next();
+      }
+    } finally {
+      if (!step.done) parser.return(void 0);
+    }
+  } catch (error) {
+    try {
+      if (!sourceDone) await input.return(void 0);
+    } catch {
+    }
+    try {
+      await frameStorage.close();
+    } catch {
+    }
+    try {
+      await storage.close();
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// packages/safe-bash-xml-engine/src/stored-document.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+var headerBytes = 80;
+var namespacesField = 72;
+var parentField = 0;
+var nextField = 8;
+var firstField = 16;
+var lastField = 24;
+var sizeField = 32;
+var firstAttributeField = 40;
+var lastAttributeField = 48;
+var flagsField = 56;
+var fragmentField = 64;
+var textFlag = 1;
+var preserveSpaceFlag = 2;
+var StoredXmlDocument = class _StoredXmlDocument {
+  constructor(context, budget, pages) {
+    this.budget = budget;
+    this.storage = new PagedStorage2(context, pages);
+  }
+  budget;
+  rootReference = 0;
+  documentReference = 0;
+  storage;
+  closing;
+  get root() {
+    return this.rootReference;
+  }
+  get document() {
+    return this.documentReference;
+  }
+  static async parse(source, context, budget, pages = 64, recover) {
+    const document = new _StoredXmlDocument(context, budget, pages);
+    try {
+      context.registerCleanup?.(document.close.bind(document));
+      document.documentReference = await document.storage.append(new Uint8Array(headerBytes));
+      const namespaces = await new StoredStringMap(document.storage, budget).set("xml", "http://www.w3.org/XML/1998/namespace");
+      await document.set(document.documentReference, namespacesField, namespaces.reference);
+      let parent = document.documentReference, fragmentTail = 0, attributeTail = 0, targetReference;
+      let attributeNames = {};
+      let pendingNamespace;
+      let tokens = new StoredStringMap(document.storage, budget);
+      const consume = async (event, namespaceParts, sourceParts) => {
+        async function retainNamespace(reference2) {
+          const key = String(reference2), previous = await tokens.lookup(key);
+          if (previous !== void 0) return previous;
+          const retained = await tokens.storeString(namespaceParts(reference2));
+          tokens = await tokens.set(key, { reference: retained });
+          return retained;
+        }
+        if (pendingNamespace && !(event.type === "attribute" && event.continuation)) {
+          const scope = await document.namespaceScope(parent);
+          const updated = await scope.set(pendingNamespace.prefix, document.text(pendingNamespace.reference));
+          await document.set(parent, namespacesField, updated.reference);
+          pendingNamespace = void 0;
+        }
+        if (event.type === "attribute") {
+          if (!event.continuation) {
+            const full = event.attribute.nameSource;
+            const local = event.attribute.localNameSource;
+            const nameReference = full ? await tokens.storeString(sourceParts(full)) : void 0;
+            const localNameReference = local ? local.start === full?.start ? nameReference : await tokens.storeString(sourceParts(local)) : void 0;
+            const prefixReference = event.attribute.prefixSource ? await tokens.storeString(sourceParts(event.attribute.prefixSource)) : void 0;
+            attributeNames = { ...prefixReference === void 0 ? {} : { prefixReference }, ...nameReference === void 0 ? {} : { nameReference }, ...localNameReference === void 0 ? {} : { localNameReference } };
+          }
+          const { nameSource: ignoredNameSource, localNameSource: ignoredLocalSource, prefixSource: ignoredPrefixSource, ...original } = event.attribute;
+          const retained = { ...original, ...attributeNames };
+          const attribute = event.attribute.namespaceReference === void 0 ? retained : {
+            ...retained,
+            namespaceReference: await retainNamespace(event.attribute.namespaceReference)
+          };
+          const reference2 = await document.append(parent, { kind: "attribute", value: attribute }, event.continuation);
+          if (event.continuation) await document.set(attributeTail, fragmentField, reference2);
+          attributeTail = reference2;
+          if (!event.continuation && event.attribute.namespace === "http://www.w3.org/2000/xmlns/")
+            pendingNamespace = { prefix: attribute.name === "xmlns" ? "" : attribute.localNameReference ?? attribute.localName, reference: reference2 };
+          return;
+        }
+        if (event.type === "close") {
+          parent = await document.field(parent, parentField);
+          return;
+        }
+        let metadata;
+        if (event.type === "content") {
+          metadata = event.content;
+          if (metadata.kind === "processing-instruction" && metadata.targetSource) {
+            if (!event.continuation) targetReference = await tokens.storeString(sourceParts(metadata.targetSource));
+            const { targetSource: ignoredSource, ...content } = metadata;
+            metadata = { ...content, targetReference };
+          }
+        } else {
+          const element = event.element;
+          const prefixReference = element.prefixSource ? await tokens.storeString(sourceParts(element.prefixSource)) : void 0;
+          const nameReference = element.nameSource ? await tokens.storeString(sourceParts(element.nameSource)) : void 0;
+          const localNameReference = element.localNameSource ? element.nameSource?.start === element.localNameSource.start ? nameReference : await tokens.storeString(sourceParts(element.localNameSource)) : void 0;
+          metadata = {
+            kind: "element",
+            ...prefixReference === void 0 ? {} : { prefixReference },
+            name: element.name,
+            localName: element.localName,
+            namespace: element.namespace,
+            ...nameReference === void 0 ? {} : { nameReference, prefix: element.prefix },
+            ...localNameReference === void 0 ? {} : { localNameReference },
+            ...element.namespaceReference === void 0 ? {} : { namespaceReference: await retainNamespace(element.namespaceReference) },
+            ...element.declaration === void 0 ? {} : { declaration: element.declaration }
+          };
+        }
+        const continuation = event.type === "content" && event.continuation === true;
+        const reference = await document.append(parent, metadata, continuation);
+        if (continuation) await document.set(fragmentTail, fragmentField, reference);
+        fragmentTail = reference;
+        if (event.type === "open") {
+          const namespaces2 = await document.namespaceScope(parent);
+          await document.set(reference, namespacesField, namespaces2.reference);
+          if (!document.rootReference) document.rootReference = reference;
+          parent = reference;
+        }
+      };
+      await parseStoredXml(source, context, budget, recover, consume, { deferNamespaces: true, deferContentNames: true, deferElementNames: true, deferAttributeNames: true });
+      return document;
+    } catch (error) {
+      try {
+        await document.close();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async field(reference, offset) {
+    const bytes = await this.storage.read(reference + offset, 8);
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(0, true);
+  }
+  async set(reference, offset, value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.storage.write(reference + offset, bytes);
+  }
+  async append(parent, metadata, fragment = false) {
+    const source = JSON.stringify(metadata);
+    const encoder = new TextEncoder();
+    let size = 0, scanned = 0;
+    for (const character of source) {
+      const point = character.codePointAt(0);
+      size += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+      if (++scanned === 4096) {
+        const checkpoint = this.budget.tick(scanned);
+        if (checkpoint) await checkpoint;
+        scanned = 0;
+      }
+    }
+    const reference = this.storage.allocate(headerBytes + size);
+    const header = new Uint8Array(headerBytes), view = new DataView(header.buffer);
+    view.setFloat64(parentField, parent, true);
+    view.setFloat64(sizeField, size, true);
+    await this.storage.write(reference, header);
+    let at = reference + headerBytes;
+    for (let offset = 0; offset < source.length; ) {
+      let end = Math.min(source.length, offset + 4096);
+      const last2 = source.charCodeAt(end - 1);
+      if (end < source.length && last2 >= 55296 && last2 <= 56319) end--;
+      const bytes = encoder.encode(source.slice(offset, end));
+      await this.storage.write(at, bytes);
+      at += bytes.length;
+      offset = end;
+      const checkpoint = this.budget.tick(bytes.length);
+      if (checkpoint) await checkpoint;
+    }
+    if (fragment) return reference;
+    const firstLink = metadata.kind === "attribute" ? firstAttributeField : firstField;
+    const lastLink = metadata.kind === "attribute" ? lastAttributeField : lastField;
+    const last = await this.field(parent, lastLink);
+    if (metadata.kind === "attribute") await this.set(reference, lastField, last);
+    if (last) await this.set(last, nextField, reference);
+    else await this.set(parent, firstLink, reference);
+    await this.set(parent, lastLink, reference);
+    return reference;
+  }
+  /** Buffering convenience API; engine traversal uses metadata and attribute links. */
+  async node(reference) {
+    const value = await this.metadata(reference);
+    if (value.kind === "element") {
+      const attributes = [];
+      for await (const attribute of this.attributes(reference)) {
+        const { valueReference: ignoredReference, ...complete } = attribute;
+        complete.value = "";
+        for await (const part of this.attributeText(attribute)) complete.value += part;
+        complete.namespace = "";
+        for await (const part of this.namespaceText(attribute)) complete.namespace += part;
+        complete.name = "";
+        complete.localName = "";
+        for await (const part of this.nameText(attribute)) complete.name += part;
+        for await (const part of this.nameText(attribute, true)) complete.localName += part;
+        delete complete.nameReference;
+        delete complete.localNameReference;
+        delete complete.prefix;
+        delete complete.prefixReference;
+        delete complete.namespaceReference;
+        attributes.push(complete);
+      }
+      const namespaces = /* @__PURE__ */ new Map();
+      for await (const [prefix, uri] of await this.namespaceScope(reference)) namespaces.set(prefix, uri);
+      let namespace = "";
+      for await (const part of this.namespaceText(value)) namespace += part;
+      let name = "", localName = "";
+      for await (const part of this.nameText(value)) name += part;
+      for await (const part of this.nameText(value, true)) localName += part;
+      const { namespaceReference: ignoredNamespaceReference, nameReference: ignoredNameReference, localNameReference: ignoredLocalReference, prefix: ignoredPrefix, prefixReference: ignoredPrefixReference, ...element } = value;
+      return { ...element, name, localName, namespace, attributes, namespaces };
+    }
+    if (value.kind === "attribute") {
+      let text = "";
+      for await (const part of this.text(reference)) text += part;
+      let namespace = "";
+      for await (const part of this.namespaceText(value.value)) namespace += part;
+      let name = "", localName = "";
+      for await (const part of this.nameText(value.value)) name += part;
+      for await (const part of this.nameText(value.value, true)) localName += part;
+      const { namespaceReference: ignoredNamespaceReference, nameReference: ignoredName, localNameReference: ignoredLocal, prefix: ignoredPrefix, prefixReference: ignoredPrefixReference, ...attribute } = value.value;
+      return { ...value, value: { ...attribute, name, localName, namespace, value: text } };
+    }
+    if (value.kind === "processing-instruction" && value.targetReference !== void 0) {
+      let target = "";
+      for await (const part of this.targetText(value)) target += part;
+      const { targetReference: ignoredReference, ...content } = value;
+      return { ...content, target };
+    }
+    return value;
+  }
+  async prefixEquals(name, expected) {
+    const colon = name.name.indexOf(":");
+    const prefix = name.prefixReference ?? name.prefix ?? (colon < 0 ? "" : name.name.slice(0, colon));
+    const tokens = new StoredStringMap(this.storage, this.budget);
+    return typeof prefix === "number" ? tokens.equals(prefix, expected) : typeof expected === "number" ? tokens.equals(expected, prefix) : prefix === expected;
+  }
+  async *nameText(name, local = false) {
+    const reference = local ? name.localNameReference : name.nameReference;
+    if (reference === void 0) yield local ? name.localName : name.name;
+    else yield* new StoredStringMap(this.storage, this.budget).valueParts(reference);
+  }
+  async nameEquals(name, expected, local = false) {
+    const reference = local ? name.localNameReference : name.nameReference;
+    const text = local ? name.localName : name.name;
+    const other = typeof expected === "string" ? expected : local ? expected.localNameReference ?? expected.localName : expected.nameReference ?? expected.name;
+    const tokens = new StoredStringMap(this.storage, this.budget);
+    if (reference !== void 0) return tokens.equals(reference, other);
+    return typeof other === "string" ? text === other : tokens.equals(other, text);
+  }
+  async *targetText(content) {
+    if (content.targetReference === void 0) yield content.target;
+    else yield* new StoredStringMap(this.storage, this.budget).valueParts(content.targetReference);
+  }
+  async *namespaceText(name) {
+    if (name.namespaceReference === void 0) yield name.namespace;
+    else yield* new StoredStringMap(this.storage, this.budget).valueParts(name.namespaceReference);
+  }
+  async namespaceEquals(name, expected) {
+    const tokens = new StoredStringMap(this.storage, this.budget);
+    if (name.namespaceReference !== void 0) return tokens.equals(name.namespaceReference, expected);
+    return typeof expected === "string" ? name.namespace === expected : tokens.equals(expected, name.namespace);
+  }
+  async namespaceScope(reference) {
+    return new StoredStringMap(this.storage, this.budget, await this.field(reference, namespacesField));
+  }
+  /** Load scalar metadata only; attributes and namespace scopes have separate iterators. */
+  async metadata(reference) {
+    const size = await this.field(reference, sizeField);
+    const decoder = new TextDecoder();
+    const parts = [];
+    for (let offset = 0; offset < size; offset += 16384) {
+      const bytes = await this.storage.read(reference + headerBytes + offset, Math.min(16384, size - offset));
+      parts.push(decoder.decode(bytes, { stream: true }));
+      const checkpoint = this.budget.tick(bytes.length);
+      if (checkpoint) await checkpoint;
+    }
+    parts.push(decoder.decode());
+    const metadata = JSON.parse(parts.join(""));
+    if (metadata.kind === "cdata" && await this.field(reference, flagsField) & textFlag)
+      return { kind: "text", text: metadata.text };
+    return metadata.kind === "element" ? { ...metadata, attributes: [], namespaces: /* @__PURE__ */ new Map(), children: [], content: [], text: "" } : metadata;
+  }
+  /** Content bodies may span parser fragments or coalesced text tokens.
+   * Replay them without making a concatenated node value. */
+  async *text(reference) {
+    let fragment = reference;
+    while (fragment) {
+      const node = await this.metadata(fragment);
+      if (node.kind === "element") throw new TypeError("Expected XML value node");
+      yield node.kind === "attribute" ? node.value.value : node.text;
+      fragment = await this.field(fragment, fragmentField);
+    }
+  }
+  /** Apply tree transformations by changing stored links. Whitespace inheritance
+   * lives on each parent record; merged text remains a chain of token bodies. */
+  async transform(options) {
+    if (!options.noblanks && !options.nocdata) return;
+    for await (const event of this.walk(this.root)) {
+      if (event.closing) continue;
+      const element = await this.metadata(event.reference);
+      if (element.kind !== "element") continue;
+      let preserve = (await this.field(await this.parent(event.reference), flagsField) & preserveSpaceFlag) !== 0;
+      for await (const attribute of this.attributes(event.reference)) {
+        if (attribute.namespace === "http://www.w3.org/XML/1998/namespace" && attribute.localName === "space")
+          preserve = await this.attributeEquals(attribute, "preserve");
+      }
+      await this.set(event.reference, flagsField, preserve ? preserveSpaceFlag : 0);
+      let current = await this.field(event.reference, firstField), previous = 0, mixed = false;
+      while (current) {
+        let child = await this.metadata(current);
+        let next = await this.field(current, nextField);
+        if (options.nocdata && (child.kind === "text" || child.kind === "cdata")) {
+          await this.set(current, flagsField, textFlag);
+          let tail = current;
+          for (let fragment = await this.field(tail, fragmentField); fragment; fragment = await this.field(tail, fragmentField)) tail = fragment;
+          while (next) {
+            const adjacent = await this.metadata(next);
+            if (adjacent.kind !== "text" && adjacent.kind !== "cdata") break;
+            await this.set(tail, fragmentField, next);
+            tail = next;
+            next = await this.field(next, nextField);
+            for (let fragment = await this.field(tail, fragmentField); fragment; fragment = await this.field(tail, fragmentField)) tail = fragment;
+          }
+          await this.set(current, nextField, next);
+          if (!next) await this.set(event.reference, lastField, current);
+          child = { kind: "text", text: child.text };
+        }
+        let skip = false;
+        if (child.kind === "text") {
+          if (options.noblanks && !preserve && !mixed && (previous !== 0 || next !== 0)) {
+            skip = true;
+            for await (const part of this.text(current)) for (const character of part) {
+              const checkpoint = this.budget.tick();
+              if (checkpoint) await checkpoint;
+              if (!" 	\r\n".includes(character)) skip = false;
+            }
+          }
+          if (!skip) mixed = true;
+        } else if (child.kind === "cdata") mixed = true;
+        if (skip) {
+          if (previous) await this.set(previous, nextField, next);
+          else await this.set(event.reference, firstField, next);
+          if (!next) await this.set(event.reference, lastField, previous);
+        } else previous = current;
+        current = next;
+      }
+    }
+  }
+  async *attributeReferences(reference, reverse = false) {
+    let attribute = await this.field(reference, reverse ? lastAttributeField : firstAttributeField);
+    while (attribute) {
+      const checkpoint = this.budget.tick();
+      if (checkpoint) await checkpoint;
+      yield attribute;
+      attribute = await this.field(attribute, reverse ? lastField : nextField);
+    }
+  }
+  async *attributes(reference) {
+    for await (const attribute of this.attributeReferences(reference)) {
+      const value = await this.metadata(attribute);
+      if (value.kind !== "attribute") throw new TypeError("Expected XML attribute");
+      yield { ...value.value, valueReference: attribute };
+    }
+  }
+  async *attributeText(attribute) {
+    if (attribute.namespaceValueReference !== void 0) yield* new StoredStringMap(this.storage, this.budget).valueParts(attribute.namespaceValueReference);
+    else if (attribute.valueReference === void 0) yield attribute.value;
+    else yield* this.text(attribute.valueReference);
+  }
+  async attributeEquals(attribute, expected) {
+    let offset = 0;
+    for await (const part of this.attributeText(attribute)) {
+      if (part.length > expected.length - offset || expected.slice(offset, offset + part.length) !== part) return false;
+      offset += part.length;
+    }
+    return offset === expected.length;
+  }
+  async *children(reference, attributes = false) {
+    let child = await this.field(reference, attributes ? firstAttributeField : firstField);
+    while (child) {
+      const checkpoint = this.budget.tick();
+      if (checkpoint) await checkpoint;
+      const value = attributes ? await this.metadata(child) : void 0;
+      if (value?.kind !== "attribute" || value.value.namespace !== "http://www.w3.org/2000/xmlns/") yield child;
+      child = await this.field(child, nextField);
+    }
+  }
+  async parent(reference) {
+    return this.field(reference, parentField);
+  }
+  /** Traverse only the requested subtree, following stored links rather than a
+   * resident stack of siblings or ancestors. Attribute nodes are separate. */
+  async *walk(reference) {
+    let current = reference;
+    while (current) {
+      const checkpoint = this.budget.tick();
+      if (checkpoint) await checkpoint;
+      yield { reference: current, closing: false };
+      const first = await this.field(current, firstField);
+      if (first) {
+        current = first;
+        continue;
+      }
+      yield { reference: current, closing: true };
+      while (current !== reference) {
+        const next = await this.field(current, nextField);
+        if (next) {
+          current = next;
+          break;
+        }
+        current = await this.field(current, parentField);
+        yield { reference: current, closing: true };
+      }
+      if (current === reference) break;
+    }
+  }
+  close() {
+    this.rootReference = 0;
+    this.documentReference = 0;
+    return this.closing ??= this.storage.close();
+  }
+};
+
+export {
+  StoredStringMap,
+  parseStoredXml,
+  StoredXmlDocument
+};