@poe-platform/safe-bash 0.1.815 → 0.1.816

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

@@ -0,0 +1,733 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-FB2WPI3M.js";
+import {
+  attr,
+  escape,
+  invalid,
+  loadShared,
+  nextRel
+} from "./chunk-A5SPMSKD.js";
+import {
+  SelectionError
+} from "./chunk-NCNHJRIY.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-6W4RMBFH.js";
+import {
+  dialects
+} from "./chunk-6KJDTKE4.js";
+import {
+  parseXmlPart
+} from "./chunk-7PYDVQPB.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} 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/properties.ts
+import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-properties.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+
+// 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 invalid2 = 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 (invalid2) continue;
+      if (character.trim() === "") {
+        if (state !== "start") trailing = true;
+        continue;
+      }
+      if (trailing) {
+        invalid2 = 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) {
+          invalid2 = 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 invalid2 = 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 invalid2 = true;
+      } else if (state === "dot") {
+        if (digit) state = "fraction";
+        else invalid2 = true;
+      } else if (state === "fraction") {
+        if (character === "e" || character === "E") state = "exponent";
+        else if (!digit) invalid2 = true;
+      } else if (state === "exponent" || state === "exponent-sign") {
+        if (digit) state = "exponent-digits";
+        else if (state === "exponent" && (character === "+" || character === "-")) state = "exponent-sign";
+        else invalid2 = true;
+      } else if (!digit) invalid2 = true;
+      if (!invalid2) yield character;
+    }
+  }
+  const value = await readJsonNumber(decimal(), async () => {
+    check();
+  }, false);
+  check();
+  if (invalid2 || ["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;
+}
+
+// packages/safe-bash-presentation-engine/src/retained-properties.ts
+var coreNamespace = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
+var terms = "http://purl.org/dc/terms/";
+var customNamespaces = ["http://schemas.openxmlformats.org/officeDocument/2006/custom-properties", "http://purl.oclc.org/ooxml/officeDocument/customProperties"];
+var valueNamespaces = ["http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes", "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes"];
+var types = ["unknown", "string", "number", "boolean", "date"];
+var kinds = ["unknown", "core", "custom"];
+async function openRetainedProperties(archive, fingerprint, query, settings) {
+  if (!query || typeof query !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(query)) || Object.keys(query).some((key) => key !== "name")) throw new OfficeError("invalid-value", "Invalid property options.", "usage");
+  if (query.name !== void 0 && (typeof query.name !== "string" || !query.name)) throw new OfficeError("invalid-value", "Expected property name.", "usage");
+  const selected = query.name, context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, head = 0, tail = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Properties are closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), pages.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  const range = (row2, offset) => ({ start: row2[offset], length: row2[offset + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 12 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 12 /* Count */ }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  async function bounded(value) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const bytes of values.read(value)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  async function matches(document, node, local, namespace) {
+    return await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), literal(namespace));
+  }
+  async function attribute(document, node, local, namespace = "") {
+    for await (const attr2 of document.attributes(node)) if (await matches(document, attr2, local, namespace)) return attr2;
+    return void 0;
+  }
+  async function unknownType(document, node) {
+    const annotation = await attribute(document, node, "type", "http://www.w3.org/2001/XMLSchema-instance");
+    if (!annotation) return false;
+    if (!await equal(document.namespace(node), literal(terms))) return true;
+    let colons = 0, local = "";
+    for await (const char of characters(document.text(annotation))) {
+      if (char === ":") {
+        colons++;
+        local = "";
+      } else if (local.length <= 6) local += char;
+    }
+    if (colons > 1 || local !== "W3CDTF") return true;
+    async function* prefix() {
+      if (colons) for await (const char of characters(document.text(annotation))) {
+        if (char === ":") break;
+        yield* literal(char);
+      }
+    }
+    const resolved = await document.resolveNamespace(node, prefix);
+    return !resolved || !await equal(resolved, literal(terms));
+  }
+  try {
+    const validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    for await (const part of archive.parts()) {
+      const key = await values.store(folded(literal(part))), value = await values.store(literal(part));
+      await values.insert("parts", key, value);
+    }
+    const main = await openRetainedXmlDocument(archive.read(index.records.main), { ...context, workingStorage: working });
+    let dialect = dialects[0], failed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+    for await (const edge of index.inventory.relationships) {
+      if (edge.owner !== "/" || edge.external) continue;
+      const core = await equal(edge.type(), literal("http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"));
+      if (!core && !await equal(edge.type(), literal(`${dialect.r}/custom-properties`))) continue;
+      const original = edge.targetPart ? await values.find("parts", () => folded(edge.targetPart())) : void 0;
+      if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+      const part = await values.store(edge.targetPart());
+      const document = await openRetainedXmlDocument(archive.read(await bounded(original)), { ...context, workingStorage: working });
+      let failed2 = false;
+      try {
+        let admitted = core ? await matches(document, document.root, "coreProperties", coreNamespace) : false;
+        if (!core) {
+          for (const namespace of customNamespaces) if (await matches(document, document.root, "Properties", namespace)) admitted = true;
+        }
+        if (!admitted) throw new OfficeError("invalid-opc", "Invalid metadata root.", "index");
+        for await (const node of document.children(document.root)) {
+          if (node.kind !== "element") continue;
+          let definition;
+          if (core) {
+            for (const [name2, schema] of Object.entries(corePropertyDefinitions)) if (await matches(document, node, schema[1], schema[0])) {
+              definition = [name2, schema];
+              break;
+            }
+          }
+          const custom2 = !core && await equal(document.namespace(node), document.namespace(document.root)) && await equal(document.raw(node.localName), literal("property"));
+          let valueNode, count = 0;
+          if (custom2) {
+            for await (const child of document.children(node)) if (child.kind === "element") {
+              valueNode = child;
+              count++;
+            }
+          }
+          if (count !== 1) valueNode = void 0;
+          let type = definition?.[1][2] ?? "unknown";
+          if (!definition && valueNode) {
+            for (const namespace2 of valueNamespaces) for (const [local, value2] of Object.entries({ lpwstr: "string", lpstr: "string", bstr: "string", i4: "number", int: "number", r8: "number", bool: "boolean", filetime: "date" })) if (await matches(document, valueNode, local, namespace2)) type = value2;
+          }
+          if (await unknownType(document, node)) type = "unknown";
+          const nameAttribute = custom2 ? await attribute(document, node, "name") : void 0;
+          const name = await values.store(definition ? literal(definition[0]) : nameAttribute ? document.text(nameAttribute) : document.raw(node.localName));
+          const namespace = await values.store(document.namespace(node));
+          let value, scalar = false;
+          if (type === "string" || type === "unknown") value = await values.store(document.text(valueNode ?? node));
+          else {
+            const decoded = await readRetainedPropertyValue(type, document.text(valueNode ?? node), check);
+            scalar = typeof decoded !== "string";
+            value = await values.store(literal(scalar ? JSON.stringify(Object.is(decoded, -0) ? "-0" : decoded) : decoded));
+          }
+          const pointer = pages.allocate(12 /* Count */ * 8);
+          await write(pointer, [0, name.start, name.length, namespace.start, namespace.length, part.start, part.length, value.start, value.length, types.indexOf(type), kinds.indexOf(definition ? "core" : custom2 ? "custom" : "unknown"), Number(scalar)]);
+          if (tail) await write(tail, [pointer]);
+          else head = pointer;
+          tail = pointer;
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed2) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    return Object.freeze({ close, async *records() {
+      check();
+      for (let pointer = head; pointer; ) {
+        const data = await row(pointer);
+        pointer = data[0 /* Next */];
+        if (selected !== void 0 && !await equal(values.read(range(data, 1 /* Name */)), literal(selected))) continue;
+        const scalar = data[11 /* Scalar */] ? JSON.parse(await bounded(range(data, 7 /* Value */))) : void 0;
+        yield { name: () => values.read(range(data, 1 /* Name */)), kind: kinds[data[10 /* Kind */]], type: types[data[9 /* Type */]], value: data[11 /* Scalar */] ? scalar === "-0" ? -0 : scalar : () => values.read(range(data, 7 /* Value */)), part: () => values.read(range(data, 5 /* Part */)), namespace: () => values.read(range(data, 3 /* Namespace */)) };
+      }
+      check();
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Property storage operation failed.", "index");
+  }
+}
+async function stageRetainedProperties(archive, fingerprint, query, settings, output) {
+  const format = { ...output };
+  if (!["properties.list", "properties.get"].includes(format.operation)) throw new OfficeError("invalid-value", "Invalid property read operation.", "usage");
+  const properties = await openRetainedProperties(archive, fingerprint, query, settings);
+  let staged;
+  try {
+    if (format.operation === "properties.get") {
+      let count = 0;
+      for await (const ignoredRecord of properties.records()) count++;
+      if (count !== 1) throw new SelectionError(count ? "ambiguous-selection" : "missing-selection");
+    }
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: format.operation, ok: true, data: { properties: properties.records() }, affected: 0, warnings: [], errors: [], locations: [] });
+        yield* literal("\n");
+      } else for await (const property of properties.records()) {
+        yield* streamJson(property.name);
+        yield* literal(": ");
+        yield* streamJson(property.value);
+        yield* literal("\n");
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await properties.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([properties.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/properties.ts
+var cp = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
+var dc = "http://purl.org/dc/elements/1.1/";
+var terms2 = "http://purl.org/dc/terms/";
+var custom = "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties";
+var vt = "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes";
+var strictCustom = "http://purl.oclc.org/ooxml/officeDocument/customProperties";
+var strictVt = "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes";
+var relationships = "http://schemas.openxmlformats.org/package/2006/relationships";
+var corePropertyDefinitions = Object.freeze({
+  author: [dc, "creator", "string"],
+  category: [cp, "category", "string"],
+  comments: [dc, "description", "string"],
+  content_status: [cp, "contentStatus", "string"],
+  created: [terms2, "created", "date"],
+  identifier: [dc, "identifier", "string"],
+  keywords: [cp, "keywords", "string"],
+  language: [dc, "language", "string"],
+  last_modified_by: [cp, "lastModifiedBy", "string"],
+  last_printed: [cp, "lastPrinted", "date"],
+  modified: [terms2, "modified", "date"],
+  revision: [cp, "revision", "number"],
+  subject: [dc, "subject", "string"],
+  title: [dc, "title", "string"],
+  version: [cp, "version", "string"]
+});
+function coreDefinition(name) {
+  return Object.hasOwn(corePropertyDefinitions, name) ? corePropertyDefinitions[name] : void 0;
+}
+function text(doc, node) {
+  let value = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("text", (s) => value += s);
+  parser.on("cdata", (s) => value += s);
+  parser.write(doc.markup(node, true)).close();
+  return value;
+}
+function validatePropertyValue(name, type, value) {
+  const known = coreDefinition(name);
+  for (const input of [name, ...typeof value === "string" ? [value] : []])
+    for (const c of input) {
+      const p = c.codePointAt(0);
+      if (p < 32 && p !== 9 && p !== 10 && p !== 13 || p >= 55296 && p <= 57343 || p === 65534 || p === 65535)
+        invalid("Invalid XML property text.");
+    }
+  if (!name || !["string", "number", "boolean", "date"].includes(type) || known && known[2] !== type)
+    invalid("Invalid property name or type.");
+  if (type === "string" && (typeof value !== "string" || known && [...value].length > 255))
+    invalid("Core strings allow at most 255 Unicode code points.");
+  if (type === "number" && (typeof value !== "number" || !Number.isFinite(value) || name === "revision" && (!Number.isSafeInteger(value) || value < 0)))
+    invalid("Invalid numeric property.");
+  if (type === "boolean" && typeof value !== "boolean") invalid("Expected a boolean property.");
+  if (type === "date") {
+    if (typeof value !== "string" || value.length !== 20 || value.startsWith("0000") || !value.endsWith("Z"))
+      invalid("Expected UTC date in whole seconds.");
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()) || date.toISOString() !== value.slice(0, -1) + ".000Z")
+      invalid("Invalid UTC date.");
+  }
+}
+function parts(s) {
+  return s.index.inventory.relationships.filter(
+    (e) => e.owner === "/" && !e.external && (e.type === `${relationships}/metadata/core-properties` || e.type === `${s.r}/custom-properties`)
+  ).map((e) => ({
+    part: e.targetPart,
+    kind: e.type === `${relationships}/metadata/core-properties` ? "core" : "custom"
+  }));
+}
+function records(s) {
+  return parts(s).flatMap(({ part, kind }) => {
+    const doc = s.doc(part);
+    if ((kind === "core" ? doc.root.name.namespace !== cp : ![custom, strictCustom].includes(doc.root.name.namespace)) || doc.root.name.localName !== (kind === "core" ? "coreProperties" : "Properties"))
+      throw new OfficeError("invalid-opc", "Invalid metadata root.", "index");
+    return doc.root.children.map((node) => {
+      const definition = kind === "core" ? Object.entries(corePropertyDefinitions).find(
+        ([, d]) => d[0] === node.name.namespace && d[1] === node.name.localName
+      ) : void 0;
+      const customNode = kind === "custom" && node.name.namespace === doc.root.name.namespace && node.name.localName === "property";
+      const valueNode = customNode && node.children.length === 1 ? node.children[0] : void 0;
+      const types2 = {
+        lpwstr: "string",
+        lpstr: "string",
+        bstr: "string",
+        i4: "number",
+        int: "number",
+        r8: "number",
+        bool: "boolean",
+        filetime: "date"
+      };
+      const type = unknownDeclaredType(doc, node) ? "unknown" : definition?.[1][2] ?? (valueNode && [vt, strictVt].includes(valueNode.name.namespace) && Object.hasOwn(types2, valueNode.name.localName) ? types2[valueNode.name.localName] : void 0) ?? "unknown";
+      const name = definition?.[0] ?? (customNode ? attr(node, "name") : void 0) ?? node.name.localName;
+      return {
+        doc,
+        node,
+        record: {
+          name,
+          kind: definition ? "core" : customNode ? "custom" : "unknown",
+          type,
+          value: decodePropertyValue(type, text(doc, valueNode ?? node)),
+          part,
+          namespace: node.name.namespace
+        }
+      };
+    });
+  });
+}
+function options(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((k) => !keys.includes(k)))
+    invalid("Invalid property options.");
+}
+async function readProperties(input, query, context) {
+  options(query, ["name"]);
+  if (query.name !== void 0 && (typeof query.name !== "string" || !query.name))
+    invalid("Expected property name.");
+  return records(await loadShared(input, context, false)).map((x) => x.record).filter((x) => query.name === void 0 || x.name === query.name);
+}
+function createPropertyPart(s, kind, context) {
+  let part = `/docProps/${kind}.xml`;
+  let suffix = 1;
+  while (s.reader.has(part)) part = `/docProps/${kind}${suffix++}.xml`;
+  const doc = parseXmlPart(
+    new TextEncoder().encode(
+      `<${kind === "core" ? "coreProperties" : "Properties"} xmlns="${kind === "core" ? cp : s.r.startsWith("http://purl.oclc.org/") ? strictCustom : custom}"/>`
+    ),
+    context.xmlLimits
+  );
+  s.save(part, doc);
+  const rel = s.doc("/_rels/.rels");
+  s.save(
+    "/_rels/.rels",
+    rel.spliceChildren(rel.root, rel.root.children.length, 0, [
+      `<Relationship xmlns="${relationships}" Id="${nextRel(rel)}" Type="${kind === "core" ? `${relationships}/metadata/core-properties` : `${s.r}/custom-properties`}" Target="${part.slice(1)}"/>`
+    ])
+  );
+  const types2 = s.doc("/[Content_Types].xml");
+  s.save(
+    "/[Content_Types].xml",
+    types2.spliceChildren(types2.root, types2.root.children.length, 0, [
+      `<Override xmlns="${types2.root.name.namespace}" PartName="${part}" ContentType="application/vnd.openxmlformats-${kind === "core" ? "package.core-properties" : "officedocument.custom-properties"}+xml"/>`
+    ])
+  );
+  return part;
+}
+async function mutateProperty(input, action, query, context) {
+  options(query, action === "set" ? ["name", "value", "type"] : ["name"]);
+  if (typeof query.name !== "string" || !query.name || !["set", "remove"].includes(action))
+    invalid("Invalid property operation.");
+  const s = await loadShared(input, context);
+  const matches = records(s).filter((x) => x.record.name === query.name);
+  if (matches.length > 1)
+    throw new OfficeError("ambiguous-selection", "Property name is ambiguous.", "select");
+  const found = matches[0];
+  if (action === "remove") {
+    if (!found) throw new OfficeError("missing-selection", "Property is absent.", "select");
+    if (found.record.type === "unknown" || !safeRemoval(found.node, found.record.kind))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Unknown property is preserved.",
+        "validate-intent"
+      );
+    s.save(
+      found.record.part,
+      found.doc.spliceChildren(found.doc.root, found.doc.root.children.indexOf(found.node), 1, [])
+    );
+    return s.finish(found.record.part, []);
+  }
+  const type = query.type ?? found?.record.type ?? coreDefinition(query.name)?.[2];
+  if (found?.record.type === "unknown")
+    throw new OfficeError("unsupported-edit", "Unknown property is preserved.", "validate-intent");
+  if (!type || type === "unknown") invalid("New properties require an explicit supported type.");
+  if (found && found.record.type !== type) invalid("Property type cannot be coerced.");
+  validatePropertyValue(query.name, type, query.value);
+  if (found?.record.kind === "custom" && ["i4", "int"].includes(found.node.children[0]?.name.localName ?? "") && (!Number.isInteger(query.value) || query.value < -2147483648 || query.value > 2147483647))
+    invalid("Integer property exceeds signed 32-bit bounds.");
+  const definition = coreDefinition(query.name);
+  if (found && definition && found.record.kind !== "core")
+    invalid("Custom names cannot collide with core names.");
+  const kind = definition ? "core" : "custom";
+  const candidates = parts(s).filter((p) => p.kind === kind);
+  if (candidates.length > 1)
+    throw new OfficeError("ambiguous-selection", "Multiple property parts.", "select");
+  const part = found?.record.part ?? candidates[0]?.part ?? createPropertyPart(s, kind, context);
+  let doc = s.doc(part);
+  if (found && kind === "core")
+    doc = setCoreText(
+      doc,
+      doc.root.children[found.doc.root.children.indexOf(found.node)],
+      String(query.value)
+    );
+  else if (found) {
+    const node = doc.root.children[found.doc.root.children.indexOf(found.node)];
+    doc = doc.setText(node.children[0], String(query.value));
+  } else {
+    let markup;
+    if (definition) {
+      const [ns, local] = definition;
+      markup = `<m:${local} xmlns="" xmlns:m="${ns}"${type === "date" && ns === terms2 ? ` xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcterms="${terms2}" xsi:type="dcterms:W3CDTF"` : ""}>${escape(String(query.value))}</m:${local}>`;
+    } else {
+      let pid = 2;
+      const ids = new Set(doc.root.children.map((n) => attr(n, "pid")));
+      while (ids.has(String(pid))) pid++;
+      const tag = { string: "lpwstr", number: "r8", boolean: "bool", date: "filetime" }[type];
+      markup = `<property xmlns="${doc.root.name.namespace}" fmtid="{D5CDD505-2E9C-101B-9397-08002B2CF9AE}" pid="${pid}" name="${escape(query.name)}"><vt:${tag} xmlns:vt="${doc.root.name.namespace === strictCustom ? strictVt : vt}">${escape(String(query.value))}</vt:${tag}></property>`;
+    }
+    doc = doc.spliceChildren(doc.root, doc.root.children.length, 0, [markup]);
+  }
+  s.save(part, doc);
+  return s.finish(part, []);
+}
+function unknownDeclaredType(doc, node) {
+  const annotation = node.attributes.find(
+    (a) => a.name.namespace === "http://www.w3.org/2001/XMLSchema-instance" && a.name.localName === "type"
+  );
+  if (!annotation) return false;
+  const names = annotation.value.split(":");
+  const prefix = names.length === 2 ? names[0] : "";
+  const local = names.at(-1);
+  return node.name.namespace !== terms2 || names.length > 2 || local !== "W3CDTF" || doc.resolveNamespace(node, prefix) !== terms2;
+}
+function setCoreText(doc, node, value) {
+  if (unknownDeclaredType(doc, node))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Unknown declared property type is preserved.",
+      "validate-intent"
+    );
+  const index = doc.root.children.indexOf(node);
+  let updated = doc.setText(node, value);
+  if (node.name.namespace !== terms2) return updated;
+  let qname = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentag", (tag) => {
+    if (!qname) qname = tag.name;
+  });
+  parser.write(doc.markup(node, true)).close();
+  const colon = qname.indexOf(":");
+  const prefix = colon < 0 ? "" : qname.slice(0, colon) + ":";
+  updated = updated.merge(updated.root.children[index], {
+    attributes: [
+      {
+        namespace: "http://www.w3.org/2001/XMLSchema-instance",
+        localName: "type",
+        value: prefix + "W3CDTF"
+      }
+    ]
+  });
+  return updated;
+}
+function safeRemoval(node, kind) {
+  return kind === "core" ? node.children.length === 0 && node.attributes.every(
+    (a) => a.name.namespace === "http://www.w3.org/2001/XMLSchema-instance" && a.name.localName === "type"
+  ) : node.children.length === 1 && node.children[0].children.length === 0 && node.children[0].attributes.length === 0 && node.attributes.every(
+    (a) => a.name.namespace === "" && ["name", "pid", "fmtid"].includes(a.name.localName)
+  );
+}
+async function sanitizeProperties(input, context) {
+  const s = await loadShared(input, context);
+  const known = records(s).filter(
+    (x) => x.record.type !== "unknown" && safeRemoval(x.node, x.record.kind)
+  );
+  for (const part of new Set(known.map((x) => x.record.part))) {
+    let doc = s.doc(part);
+    const indices = known.filter((x) => x.record.part === part).map((x) => x.doc.root.children.indexOf(x.node)).sort((a, b) => b - a);
+    for (const index of indices) doc = doc.spliceChildren(doc.root, index, 1, []);
+    s.save(part, doc);
+  }
+  return s.finish(s.main, []);
+}
+var CoreProperties = class {
+  #read;
+  constructor(read, write) {
+    this.#read = read;
+    for (const [name, [namespace, localName, type]] of Object.entries(corePropertyDefinitions))
+      Object.defineProperty(this, name, {
+        enumerable: true,
+        get: () => {
+          const doc = read();
+          const matches = doc.root.children.filter(
+            (n) => n.name.namespace === namespace && n.name.localName === localName
+          );
+          if (matches.length > 1)
+            throw new OfficeError("ambiguous-selection", "Duplicate core property.", "select");
+          const raw = matches[0] ? text(doc, matches[0]) : "";
+          if (type === "string") return raw;
+          if (type === "number") {
+            const value2 = Number(raw);
+            const digits = raw.trim();
+            const unsigned = digits.startsWith("+") ? digits.slice(1) : digits;
+            return unsigned && [...unsigned].every((c) => c >= "0" && c <= "9") && Number.isSafeInteger(value2) && value2 >= 0 ? value2 : 0;
+          }
+          const value = decodePropertyValue("date", raw);
+          return value === null ? null : new Date(value);
+        },
+        set: (value) => {
+          const serialized = type === "date" ? value instanceof Date && Number.isFinite(value.getTime()) ? value.toISOString().slice(0, 19) + "Z" : invalid("Expected valid UTC Date.") : value;
+          validatePropertyValue(name, type, serialized);
+          let doc = read();
+          const matches = doc.root.children.filter(
+            (n) => n.name.namespace === namespace && n.name.localName === localName
+          );
+          if (matches.length > 1)
+            throw new OfficeError("ambiguous-selection", "Duplicate core property.", "select");
+          if (matches[0]) doc = setCoreText(doc, matches[0], String(serialized));
+          else
+            doc = doc.spliceChildren(doc.root, doc.root.children.length, 0, [
+              `<m:${localName} xmlns="" xmlns:m="${namespace}"${type === "date" && namespace === terms2 ? ` xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcterms="${terms2}" xsi:type="dcterms:W3CDTF"` : ""}>${escape(String(serialized))}</m:${localName}>`
+            ]);
+          write(doc);
+        }
+      });
+  }
+  get part() {
+    return this.#read();
+  }
+};
+async function openPropertySession(input, context) {
+  const s = await loadShared(input, context);
+  const candidates = parts(s).filter((p) => p.kind === "core");
+  if (candidates.length > 1)
+    throw new OfficeError("ambiguous-selection", "Multiple core property parts.", "select");
+  let part = candidates[0]?.part;
+  let model;
+  return {
+    get core_properties() {
+      part ??= createPropertyPart(s, "core", context);
+      return model ??= new CoreProperties(
+        () => s.doc(part),
+        (doc) => s.save(part, doc)
+      );
+    },
+    async save() {
+      return (await s.finish(s.main, [])).bytes;
+    }
+  };
+}
+
+export {
+  readRetainedPropertyValue,
+  openRetainedProperties,
+  stageRetainedProperties,
+  corePropertyDefinitions,
+  coreDefinition,
+  validatePropertyValue,
+  readProperties,
+  createPropertyPart,
+  mutateProperty,
+  sanitizeProperties,
+  CoreProperties,
+  openPropertySession
+};