@poe-platform/safe-bash 0.1.816 → 0.1.818

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

@@ -1,3 +1,192 @@
+// 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 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(""));
+  }
+  async write(entry) {
+    const source = JSON.stringify(entry), encoder = new TextEncoder(), header = new Uint8Array(8);
+    const 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);
+      if (checkpoint) await checkpoint;
+      await this.storage.append(bytes);
+      size += bytes.length;
+      offset = end;
+    }
+    new DataView(header.buffer).setFloat64(0, size, true);
+    await this.storage.write(reference, header);
+    return reference;
+  }
+  async get(key) {
+    let reference = this.reference;
+    while (reference) {
+      const entry = await this.read(reference);
+      const checkpoint = this.budget.tick(key.length + 1);
+      if (checkpoint) await checkpoint;
+      if (key === entry.key) return entry.value;
+      reference = key < entry.key ? entry.left : entry.right;
+    }
+    return void 0;
+  }
+  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 insert = async (reference) => {
+      if (!reference) return this.write({ key, value, left: 0, right: 0, height: 1 });
+      const entry = await this.read(reference);
+      const checkpoint = this.budget.tick(key.length + value.length + 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 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]() {
+    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);
+  }
+};
+
+// packages/safe-bash-xml-engine/src/parser-attributes.ts
+var StoredParserAttributes = class {
+  constructor(storage, budget) {
+    this.storage = storage;
+    this.budget = budget;
+  }
+  storage;
+  budget;
+  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));
+      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);
+      }
+      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 { value: ignoredValue, ...metadata } = request.attribute;
+      const attribute = await this.append(metadata);
+      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 ? await values.get(metadata.name) : "";
+      if (value === void 0) throw new TypeError("Missing stored XML attribute value");
+      request.result = { ...metadata, value, next: await this.number(request.reference) };
+    }
+  }
+};
+
 // packages/safe-bash-xml-engine/src/frames.ts
 var StoredXmlFrames = class {
   constructor(storage) {
@@ -13,7 +202,8 @@ var StoredXmlFrames = class {
         name: frame.name,
         element,
         namespaces: [...frame.namespaces],
-        retainNamespaces: namespaces2 === 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);
@@ -51,6 +241,7 @@ var StoredXmlFrames = class {
       name: record.name,
       namespaces,
       content: void 0,
+      ...record.namespaceScope ? { namespaceScope: record.namespaceScope } : {},
       element: { ...record.element, namespaces: record.retainNamespaces ? namespaces : /* @__PURE__ */ new Map() }
     };
   }
@@ -87,17 +278,22 @@ async function parseStoredXml(source, context, budget, recover, consume) {
     if (recover) while (!sourceDone) await readNext();
     const queued = [];
     const frames = new StoredXmlFrames(frameStorage);
+    const attributes = new StoredParserAttributes(frameStorage, budget);
     const parser = parseXmlSourceSteps(recover ? length : void 0, {
       ...budget.limits,
       maxContentNodes: budget.limits.maxNodes,
       expectedEncoding: "UTF-8",
       retainTree: false,
       storeFrames: true,
+      storeNamespaces: true,
+      storeAttributes: true,
       fragmentContent: true,
       compactDeclaration: true,
       ...recover ? { recover } : {},
       ...consume ? { events: (event) => {
         queued.push(event);
+      }, onAttribute: (attribute, element) => {
+        queued.push({ type: "attribute", attribute, element });
       } } : {}
     });
     let step = parser.next();
@@ -113,6 +309,19 @@ async function parseStoredXml(source, context, budget, recover, consume) {
         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 previous = await scope.get(request.prefix);
+          if (request.namespaceOperation === "get") {
+            if (previous !== void 0) request.value = previous;
+            request.complete = true;
+          } else {
+            const next = await scope.set(request.prefix, request.value);
+            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 {
@@ -150,7 +359,8 @@ async function parseStoredXml(source, context, budget, recover, consume) {
 
 // packages/safe-bash-xml-engine/src/stored-document.ts
 import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
-var headerBytes = 72;
+var headerBytes = 80;
+var namespacesField = 72;
 var parentField = 0;
 var nextField = 8;
 var firstField = 16;
@@ -183,8 +393,19 @@ var StoredXmlDocument = class _StoredXmlDocument {
     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;
       const consume = async (event) => {
+        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);
+          }
+          return;
+        }
         if (event.type === "close") {
           parent = await document.field(parent, parentField);
           return;
@@ -198,7 +419,6 @@ var StoredXmlDocument = class _StoredXmlDocument {
             name: element.name,
             localName: element.localName,
             namespace: element.namespace,
-            namespaces: [...element.namespaces],
             ...element.declaration === void 0 ? {} : { declaration: element.declaration }
           };
         }
@@ -207,9 +427,8 @@ var StoredXmlDocument = class _StoredXmlDocument {
         if (continuation) await document.set(fragmentTail, fragmentField, reference);
         fragmentTail = reference;
         if (event.type === "open") {
-          for (const attribute of event.element.attributes) {
-            await document.append(reference, { kind: "attribute", value: attribute });
-          }
+          const namespaces2 = await document.namespaceScope(parent);
+          await document.set(reference, namespacesField, namespaces2.reference);
           if (!document.rootReference) document.rootReference = reference;
           parent = reference;
         }
@@ -279,10 +498,16 @@ var StoredXmlDocument = class _StoredXmlDocument {
     if (value.kind === "element") {
       const attributes = [];
       for await (const attribute of this.attributes(reference)) attributes.push(attribute);
-      return { ...value, attributes };
+      const namespaces = /* @__PURE__ */ new Map();
+      for await (const [prefix, uri] of await this.namespaceScope(reference)) namespaces.set(prefix, uri);
+      return { ...value, attributes, namespaces };
     }
     return value;
   }
+  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();
@@ -297,7 +522,7 @@ var StoredXmlDocument = class _StoredXmlDocument {
     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: new Map(metadata.namespaces), children: [], content: [], text: "" } : metadata;
+    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. */
@@ -428,6 +653,7 @@ var StoredXmlDocument = class _StoredXmlDocument {
 };
 
 export {
+  StoredStringMap,
   parseStoredXml,
   StoredXmlDocument
 };

package/dist/safe-bash/command-chunks/{chunk-NKK76B4V.js → chunk-MN7EEK6Y.js}

@@ -1,23 +1,23 @@
 import {
   createPropertyPart
-} from "./chunk-OFONWWEZ.js";
+} from "./chunk-5IHJWBDR.js";
 import {
   measurePackageResourceSerialization
-} from "./chunk-RTHYAGKI.js";
+} from "./chunk-ETN25WCR.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   normalizeDocxPropertyOptions
-} from "./chunk-GAROGIVU.js";
+} from "./chunk-NP2QXF2X.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-N3ZH4YYH.js";
+} from "./chunk-LTWX23FS.js";
 import {
   SemanticValidationError,
   validateDocumentArchive
-} from "./chunk-WMV5224N.js";
+} from "./chunk-FILE5PBI.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
@@ -26,7 +26,7 @@ import {
   UnsupportedEditError,
   editActivePropertyXml,
   xmlValue
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   customPropertyFormatId,
   normalizePropertyDate,
@@ -37,7 +37,7 @@ import {
   readPropertyNodes,
   readPropertyParts,
   serializePropertyScalar
-} from "./chunk-QDV2NIFR.js";
+} from "./chunk-2TMTGVJR.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-OBIXFO25.js → chunk-MOJQT6RW.js}

@@ -1,9 +1,9 @@
 import {
   packageViewBatchActions
-} from "./chunk-35DU6I2M.js";
+} from "./chunk-7ZEGARPB.js";
 import {
   imageBatchActions
-} from "./chunk-WIW3KDBS.js";
+} from "./chunk-7NFICYRU.js";
 import {
   packUriBatchActions
 } from "./chunk-EBWCAGLA.js";
@@ -23,20 +23,20 @@ import {
   TableStyle,
   modelOutput,
   setStyleLinks
-} from "./chunk-ET6LMDEX.js";
+} from "./chunk-EV3DPRWE.js";
 import {
   StylesPart,
   XmlElementView
-} from "./chunk-TXU7MMHN.js";
+} from "./chunk-5RDS6CNQ.js";
 import {
   modelVfsResolver
-} from "./chunk-IZ3SD5S2.js";
+} from "./chunk-K2NV6H7E.js";
 import {
   partProviderReceivers
-} from "./chunk-BKK4MS3V.js";
+} from "./chunk-RR6XG2I6.js";
 import {
   publishDocumentArchive
-} from "./chunk-N3ZH4YYH.js";
+} from "./chunk-LTWX23FS.js";
 import {
   Cm,
   Emu,
@@ -54,7 +54,7 @@ import {
   enumToXml,
   enumValue,
   isLength
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 import {
   DocxUsageError
 } from "./chunk-WXMYTNWS.js";

package/dist/safe-bash/command-chunks/{chunk-HOKPYTHQ.js → chunk-MPRUGL4W.js}

@@ -1,6 +1,6 @@
 import {
   characterizeRasterHeader
-} from "./chunk-JA36YOZI.js";
+} from "./chunk-LUJUYUOG.js";
 import {
   UnsupportedEditError,
   activeXmlChildren,
@@ -10,7 +10,7 @@ import {
   runElementOpen,
   splitNativeTextRunXml,
   xmlValue
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   dialectForNamespace,
   documentDialects

package/dist/safe-bash/command-chunks/{chunk-CORUUCS2.js → chunk-MRBX4KEP.js}

@@ -1,14 +1,14 @@
 import {
   applyTableUpdate,
   readTable
-} from "./chunk-HOJ7WDTS.js";
+} from "./chunk-IJZUUXLL.js";
 import {
   nodeFor
-} from "./chunk-LMLBQSAM.js";
+} from "./chunk-YW7WU7W2.js";
 import {
   attr,
   required
-} from "./chunk-A5SPMSKD.js";
+} from "./chunk-A32PUWYE.js";
 import {
   parseXmlPart
 } from "./chunk-7PYDVQPB.js";

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

@@ -0,0 +1,137 @@
+import {
+  characters
+} from "./chunk-KM2SMMXZ.js";
+import {
+  readJsonNumber
+} from "./chunk-NUGQQDGE.js";
+
+// packages/safe-bash-presentation-engine/src/property-value.ts
+function decodePropertyValue(type, value) {
+  if (type === "number")
+    return value.trim() !== "" && Number.isFinite(Number(value)) ? Number(value) : null;
+  if (type === "boolean")
+    return value === "true" || value === "1" ? true : value === "false" || value === "0" ? false : null;
+  if (type === "date") {
+    const segments = value.split("T");
+    if (segments.length > 2) return null;
+    const calendar = segments[0].split("-");
+    if (calendar.length > 3 || calendar[0]?.length !== 4 || calendar.some(
+      (v, i) => v.length !== (i === 0 ? 4 : 2) || [...v].some((c) => c < "0" || c > "9")
+    ))
+      return null;
+    const year = Number(calendar[0]), month = Number(calendar[1] ?? 1), day = Number(calendar[2] ?? 1);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    if (year < 1 || month < 1 || month > 12 || day < 1 || day > [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1])
+      return null;
+    if (segments.length === 2 && (calendar.length !== 3 || !(value.endsWith("Z") || value.slice(19).includes("+") || value.slice(19).includes("-"))))
+      return null;
+    const date = new Date(
+      segments.length === 1 ? `${calendar[0]}-${calendar[1] ?? "01"}-${calendar[2] ?? "01"}T00:00:00Z` : value
+    );
+    return Number.isFinite(date.getTime()) ? date.toISOString().slice(0, 19) + "Z" : null;
+  }
+  return value;
+}
+
+// packages/safe-bash-presentation-engine/src/retained-property-value.ts
+async function readRetainedPropertyValue(type, source, check) {
+  if (type !== "number") {
+    let value2 = "", overflow = false, fraction = false, fractionDigits = 0;
+    const limit = type === "boolean" ? 5 : 128;
+    for await (const character of characters(source)) {
+      check();
+      if (overflow) continue;
+      if (type === "date") {
+        if (fraction && character >= "0" && character <= "9") {
+          if (fractionDigits++ < 3) value2 += character;
+          continue;
+        }
+        fraction = value2.length === 19 && character === ".";
+      }
+      if (value2.length >= limit) overflow = true;
+      else value2 += character;
+    }
+    check();
+    return overflow ? null : decodePropertyValue(type, value2);
+  }
+  let state = "start";
+  let invalid = false, trailing = false, signed = false, firstZero = false, integerDigits = 0, radix = 0, radixDigits = 0, prefix = "", radixOverflow = false;
+  async function* decimal() {
+    for await (const character of characters(source)) {
+      check();
+      if (invalid) continue;
+      if (character.trim() === "") {
+        if (state !== "start") trailing = true;
+        continue;
+      }
+      if (trailing) {
+        invalid = true;
+        continue;
+      }
+      const digit = character >= "0" && character <= "9";
+      if (state === "radix") {
+        const code = character.toLowerCase().charCodeAt(0), value2 = digit ? code - 48 : code >= 97 && code <= 102 ? code - 87 : Infinity;
+        if (value2 >= radix) {
+          invalid = true;
+          continue;
+        }
+        radixDigits++;
+        if (prefix || value2) {
+          if (prefix.length < 1024) prefix += character;
+          else radixOverflow = true;
+        }
+        continue;
+      }
+      if (state === "start" || state === "sign") {
+        if (state === "start" && (character === "+" || character === "-")) {
+          signed = true;
+          state = "sign";
+          yield character;
+          continue;
+        }
+        if (digit) {
+          state = "integer";
+          integerDigits = 1;
+          firstZero = character === "0";
+        } else if (character === ".") state = "dot";
+        else invalid = true;
+      } else if (state === "integer") {
+        if (digit) integerDigits++;
+        else if (!signed && firstZero && integerDigits === 1 && ["x", "b", "o"].includes(character.toLowerCase())) {
+          radix = { x: 16, b: 2, o: 8 }[character.toLowerCase()];
+          state = "radix";
+          continue;
+        } else if (character === ".") state = "fraction";
+        else if (character === "e" || character === "E") state = "exponent";
+        else invalid = true;
+      } else if (state === "dot") {
+        if (digit) state = "fraction";
+        else invalid = true;
+      } else if (state === "fraction") {
+        if (character === "e" || character === "E") state = "exponent";
+        else if (!digit) invalid = true;
+      } else if (state === "exponent" || state === "exponent-sign") {
+        if (digit) state = "exponent-digits";
+        else if (state === "exponent" && (character === "+" || character === "-")) state = "exponent-sign";
+        else invalid = true;
+      } else if (!digit) invalid = true;
+      if (!invalid) yield character;
+    }
+  }
+  const value = await readJsonNumber(decimal(), async () => {
+    check();
+  }, false);
+  check();
+  if (invalid || ["start", "sign", "dot", "exponent", "exponent-sign"].includes(state)) return null;
+  if (radix) {
+    if (!radixDigits || radixOverflow) return null;
+    const result = Number(`0${radix === 16 ? "x" : radix === 8 ? "o" : "b"}${prefix || "0"}`);
+    return Number.isFinite(result) ? result : null;
+  }
+  return Number.isFinite(value) ? value : null;
+}
+
+export {
+  decodePropertyValue,
+  readRetainedPropertyValue
+};

package/dist/safe-bash/command-chunks/{chunk-RRAQII52.js → chunk-MURNTGDL.js}

@@ -1,22 +1,22 @@
 import {
   openDocumentLocations
-} from "./chunk-KDBU5Q2N.js";
+} from "./chunk-MWVELMXZ.js";
 import {
   embeddedFontContentTypes,
   fontResourceRole
-} from "./chunk-OIHQXURE.js";
+} from "./chunk-ROE6KD4C.js";
 import {
   measurePackageResourceSerialization
-} from "./chunk-RTHYAGKI.js";
+} from "./chunk-ETN25WCR.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
 import {
   revisionInfo
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-KDBU5Q2N.js → chunk-MWVELMXZ.js}

@@ -1,27 +1,27 @@
 import {
   readTextSegments
-} from "./chunk-A6OTPNNI.js";
+} from "./chunk-LPKMNCC5.js";
 import {
   DocumentArchiveEditor
-} from "./chunk-N4HWOLGZ.js";
+} from "./chunk-GY2C555A.js";
 import {
   LocationIndex,
   addressKey,
   documentScopes,
   pathContains
-} from "./chunk-OCV5ZU35.js";
+} from "./chunk-VSTAHYCV.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
 import {
   UnsupportedEditError
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   docxOperationSchemas
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 import {
   SelectionError,
   closedRecord,