@poe-platform/safe-bash 0.1.818 → 0.1.819

package/dist/safe-bash/command-chunks/{chunk-MMSKDYK6.js → chunk-WOECEZAC.js}

@@ -9,48 +9,116 @@ var StoredStringMap = class _StoredStringMap {
   budget;
   reference;
   async read(reference) {
-    const header = await this.storage.read(reference, 8);
-    const size = new DataView(header.buffer, header.byteOffset, 8).getFloat64(0, true);
-    const 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(reference + 8 + offset, length), { stream: true }));
-    }
-    parts.push(decoder.decode());
-    return JSON.parse(parts.join(""));
+    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 source = JSON.stringify(entry), encoder = new TextEncoder(), header = new Uint8Array(8);
-    const reference = await this.storage.append(header);
+    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 (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);
+    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 += bytes.length;
-      offset = end;
+      size += length;
     }
     new DataView(header.buffer).setFloat64(0, size, true);
     await this.storage.write(reference, header);
     return reference;
   }
-  async get(key) {
+  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 entry = await this.read(reference);
-      const checkpoint = this.budget.tick(key.length + 1);
+      const checkpoint = this.budget.tick(1);
       if (checkpoint) await checkpoint;
-      if (key === entry.key) return entry.value;
-      reference = key < entry.key ? entry.left : entry.right;
+      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;
   }
@@ -77,19 +145,23 @@ var StoredStringMap = class _StoredStringMap {
     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, value, left: 0, right: 0, height: 1 });
+      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(key.length + value.length + 1);
+      const checkpoint = this.budget.tick(1);
       if (checkpoint) await checkpoint;
-      if (key === entry.key) return entry.value === value ? reference : this.write({ ...entry, value });
-      const side = key < entry.key ? "left" : "right";
+      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));
   }
-  async *[Symbol.asyncIterator]() {
+  /** 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);
@@ -99,16 +171,24 @@ var StoredStringMap = class _StoredStringMap {
     };
     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) {
+  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);
@@ -142,20 +222,39 @@ var StoredParserAttributes = class {
     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));
-      request.found = await values.get(request.name) !== void 0;
-      if (request.attributeOperation === "expanded" && !request.found) {
-        const next = await values.set(request.name, "1");
-        await this.set(store, offset, next.reference);
+      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 existing = await values.get(request.attribute.name);
-      const updated = await values.set(request.attribute.name, request.attribute.value);
+      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);
+      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);
@@ -180,9 +279,10 @@ var StoredParserAttributes = class {
       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 ? await values.get(metadata.name) : "";
+      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");
-      request.result = { ...metadata, value, next: await this.number(request.reference) };
+      const { nameKey: ignoredKey, ...attribute } = metadata;
+      request.result = { ...attribute, value, next: await this.number(request.reference) };
     }
   }
 };
@@ -250,7 +350,7 @@ var StoredXmlFrames = class {
 // 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) {
+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);
@@ -276,30 +376,56 @@ async function parseStoredXml(source, context, budget, recover, consume) {
       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);
+    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) => {
-        queued.push({ type: "attribute", attribute, element });
+      }, 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);
+        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();
@@ -314,26 +440,36 @@ async function parseStoredXml(source, context, budget, recover, consume) {
         } else if ("namespaceOperation" in step.value) {
           const request = step.value;
           const scope = new StoredStringMap(frameStorage, budget, request.scope.reference);
-          const previous = await scope.get(request.prefix);
-          if (request.namespaceOperation === "get") {
+          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 next = await scope.set(request.prefix, request.value);
+            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 {
-          const request = step.value;
-          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;
+          await completeSourceRead(step.value);
         }
         step = parser.next();
       }
@@ -395,15 +531,44 @@ var StoredXmlDocument = class _StoredXmlDocument {
       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;
-      const consume = async (event) => {
+      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") {
-          await document.append(parent, { kind: "attribute", value: event.attribute });
-          if (event.attribute.namespace === "http://www.w3.org/2000/xmlns/") {
-            const scope = await document.namespaceScope(parent);
-            const updated = await scope.set(event.attribute.name === "xmlns" ? "" : event.attribute.localName, event.attribute.value);
-            await document.set(parent, namespacesField, updated.reference);
+          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") {
@@ -411,14 +576,27 @@ var StoredXmlDocument = class _StoredXmlDocument {
           return;
         }
         let metadata;
-        if (event.type === "content") metadata = event.content;
-        else {
+        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 }
           };
         }
@@ -433,7 +611,7 @@ var StoredXmlDocument = class _StoredXmlDocument {
           parent = reference;
         }
       };
-      await parseStoredXml(source, context, budget, recover, consume);
+      await parseStoredXml(source, context, budget, recover, consume, { deferNamespaces: true, deferContentNames: true, deferElementNames: true, deferAttributeNames: true });
       return document;
     } catch (error) {
       try {
@@ -497,13 +675,84 @@ var StoredXmlDocument = class _StoredXmlDocument {
     const value = await this.metadata(reference);
     if (value.kind === "element") {
       const attributes = [];
-      for await (const attribute of this.attributes(reference)) attributes.push(attribute);
+      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);
-      return { ...value, attributes, namespaces };
+      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));
   }
@@ -530,8 +779,8 @@ var StoredXmlDocument = class _StoredXmlDocument {
     let fragment = reference;
     while (fragment) {
       const node = await this.metadata(fragment);
-      if (node.kind === "element" || node.kind === "attribute") throw new TypeError("Expected XML content node");
-      yield node.text;
+      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);
     }
   }
@@ -546,7 +795,7 @@ var StoredXmlDocument = class _StoredXmlDocument {
       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 = attribute.value === "preserve";
+          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;
@@ -603,8 +852,21 @@ var StoredXmlDocument = class _StoredXmlDocument {
     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;
+      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);

package/dist/safe-bash/command-chunks/{chunk-5OS4Q3AX.js → chunk-WOO3YO2X.js}

@@ -1,25 +1,25 @@
 import {
   Presentation
-} from "./chunk-FDRE535F.js";
+} from "./chunk-3MFYCMQU.js";
 import {
   SlidePlaceholder
-} from "./chunk-6LOAJOWK.js";
+} from "./chunk-PYYAX5FB.js";
 import {
   chartTypes,
   validateChartData
-} from "./chunk-QNLX3CZH.js";
+} from "./chunk-2VSNIHIW.js";
 import {
   admitImage
-} from "./chunk-4IDV763L.js";
+} from "./chunk-ZS4J5B6Y.js";
 import {
   readSelectionIndex
-} from "./chunk-3W3HLPCX.js";
+} from "./chunk-SKF6PGA5.js";
 import {
   readBinary
-} from "./chunk-FAU2KL6I.js";
+} from "./chunk-S5MBHFLB.js";
 import {
   ValueError
-} from "./chunk-G3FK5VVG.js";
+} from "./chunk-HTBUIRTH.js";
 
 // packages/safe-bash-presentation-engine/src/command-placeholder.ts
 async function insertPlaceholder(input, options, context) {