@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,237 @@
+import {
+  nodeFor,
+  selected,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  readShape
+} from "./chunk-HHLVI2CB.js";
+import {
+  applyDrawingUpdate,
+  readDrawingFormat,
+  validateDrawingUpdate
+} from "./chunk-A3XE767Q.js";
+import {
+  readShapeGeometry
+} from "./chunk-TGHQGJNR.js";
+import {
+  escape,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+import {
+  crc32
+} from "./chunk-XIC45QAG.js";
+
+// packages/safe-bash-presentation-engine/src/picture-input.ts
+function invalid() {
+  throw new OfficeError(
+    "invalid-value",
+    "Picture input requires a complete PNG or JPEG container.",
+    "validate-intent"
+  );
+}
+function validatePictureInput(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length >= 8 && [137, 80, 78, 71, 13, 10, 26, 10].every((n, i) => bytes[i] === n)) {
+    let offset = 8, header = false, data = false;
+    while (offset + 12 <= bytes.length) {
+      const size = view.getUint32(offset), tag = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+      if (size > bytes.length - offset - 12) invalid();
+      if (crc32(bytes.subarray(offset + 4, offset + 8 + size)) !== view.getUint32(offset + 8 + size))
+        invalid();
+      if (!header && tag !== "IHDR") invalid();
+      if (tag === "IHDR") {
+        if (header || size !== 13 || view.getUint32(offset + 8) === 0 || view.getUint32(offset + 12) === 0 || bytes[offset + 18] !== 0 || bytes[offset + 19] !== 0 || ![0, 1].includes(bytes[offset + 20]))
+          invalid();
+        const depths = {
+          0: [1, 2, 4, 8, 16],
+          2: [8, 16],
+          3: [1, 2, 4, 8],
+          4: [8, 16],
+          6: [8, 16]
+        };
+        if (!depths[bytes[offset + 17]]?.includes(bytes[offset + 16])) invalid();
+        header = true;
+      }
+      if (tag === "IDAT") data = true;
+      offset += size + 12;
+      if (tag === "IEND") {
+        if (size !== 0 || !data || offset !== bytes.length) invalid();
+        return "png";
+      }
+    }
+    invalid();
+  }
+  if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216) {
+    let offset = 2, frame = false, scan = false;
+    while (offset < bytes.length) {
+      if (bytes[offset++] !== 255) invalid();
+      while (bytes[offset] === 255) offset++;
+      const marker = bytes[offset++];
+      if (marker === void 0) invalid();
+      if (marker === 217) {
+        if (!frame || !scan || offset !== bytes.length) invalid();
+        return "jpeg";
+      }
+      if (marker === 0 || marker === 216 || marker >= 208 && marker <= 215) invalid();
+      if (offset + 2 > bytes.length) invalid();
+      const size = view.getUint16(offset);
+      if (size < 2 || size > bytes.length - offset) invalid();
+      if ([192, 193, 194].includes(marker)) {
+        if (frame || size < 8 || view.getUint16(offset + 3) === 0 || view.getUint16(offset + 5) === 0 || size !== 8 + 3 * bytes[offset + 7])
+          invalid();
+        frame = true;
+      }
+      offset += size;
+      if (marker === 218) {
+        if (!frame || size < 6) invalid();
+        scan = true;
+        while (offset < bytes.length) {
+          if (bytes[offset] !== 255) {
+            offset++;
+            continue;
+          }
+          const next = bytes[offset + 1];
+          if (next === 0 || next !== void 0 && next >= 208 && next <= 215) {
+            offset += 2;
+            continue;
+          }
+          break;
+        }
+      }
+    }
+    invalid();
+  }
+  invalid();
+}
+
+// packages/safe-bash-presentation-engine/src/drawing-operations.ts
+async function readDrawing(input, options, context) {
+  validateSelection(options, "read");
+  const s = await loadShared(input, context, false);
+  return selected(s, options).map((record) => {
+    const root = s.doc(record.part).root;
+    const node = nodeFor(root, record.id);
+    return {
+      ...readShape(node),
+      geometry: readShapeGeometry(root, node),
+      location: record.location,
+      token: record.token,
+      part: record.part,
+      drawing: readDrawingFormat(node)
+    };
+  });
+}
+async function mutateDrawing(input, options, context) {
+  if (!options || typeof options !== "object")
+    throw new OfficeError("invalid-value", "Invalid drawing selection options.", "usage");
+  const { image, ...selectionOptions } = options;
+  validateSelection(selectionOptions, "set");
+  if (!options.update || typeof options.update !== "object")
+    throw new OfficeError("invalid-value", "Drawing update is required.", "usage");
+  if (image !== void 0 && (options.update.fill?.kind !== "picture" || options.update.fill.relationshipId !== void 0))
+    throw new OfficeError(
+      "invalid-value",
+      "Image input requires a picture fill without a relationship ID.",
+      "usage"
+    );
+  const update = image !== void 0 && options.update.fill?.kind === "picture" ? { ...options.update, fill: { ...options.update.fill, relationshipId: "pending" } } : options.update;
+  validateDrawingUpdate(update);
+  if (!options.select && options.shape === void 0 && options.slide === void 0 && !options.part && !options.all)
+    throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context);
+  const records = selected(s, options);
+  if (!records.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((x) => x.location)
+    );
+  let imagePart;
+  if (image !== void 0 && records.length) {
+    const bytes = await readBinary(image, context);
+    const png = validatePictureInput(bytes) === "png";
+    const extension = png ? "png" : "jpg";
+    let index = 1;
+    while (s.reader.names.some((name) => name.toLowerCase() === `/ppt/media/image${index}.${extension}`))
+      index++;
+    imagePart = `/ppt/media/image${index}.${extension}`;
+    s.changes.set(imagePart, bytes);
+    const types = s.doc("/[Content_Types].xml");
+    s.save(
+      "/[Content_Types].xml",
+      types.spliceChildren(types.root, types.root.children.length, 0, [
+        `<Override xmlns="${types.root.name.namespace}" PartName="${imagePart}" ContentType="image/${png ? "png" : "jpeg"}"/>`
+      ])
+    );
+  }
+  const relationships = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    let shapeUpdate = update;
+    const fill = update.fill;
+    if (imagePart && fill?.kind === "picture") {
+      let id = relationships.get(record.part);
+      if (!id) {
+        const part = relPart(record.part);
+        const rels = s.reader.has(part) ? s.doc(part) : parseXmlPart(
+          new TextEncoder().encode(
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>'
+          ),
+          context.xmlLimits
+        );
+        id = nextRel(rels);
+        relationships.set(record.part, id);
+        s.save(
+          part,
+          rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+            `<Relationship xmlns="${rels.root.name.namespace}" Id="${id}" Type="${s.r}/image" Target="${escape(relativePartReference(imagePart, record.part.slice(0, record.part.lastIndexOf("/"))))}"/>`
+          ])
+        );
+      }
+      shapeUpdate = { ...update, fill: { ...fill, relationshipId: id } };
+    }
+    if (fill?.kind === "picture" && !imagePart) {
+      const relation = s.index.inventory.relationships.find(
+        (e) => e.owner === record.part && e.id === fill.relationshipId
+      );
+      if (!relation || relation.external || !relation.targetPart || relation.type !== `${s.r}/image` || !s.reader.has(relation.targetPart))
+        throw new OfficeError(
+          "invalid-value",
+          "Picture fill requires an existing internal image relationship.",
+          "validate-intent"
+        );
+    }
+    const doc = s.doc(record.part);
+    s.save(record.part, applyDrawingUpdate(doc, nodeFor(doc.root, record.id), shapeUpdate));
+  }
+  return {
+    ...await s.finish(
+      records[0]?.part ?? s.main,
+      s.index.inventory.slides.filter((x) => records.some((r) => [x.part, x.master, x.layout].includes(r.part))).map((x) => x.position)
+    ),
+    affected: records.length,
+    records
+  };
+}
+
+export {
+  readDrawing,
+  mutateDrawing
+};

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

@@ -0,0 +1,32 @@
+import {
+  PackURI
+} from "./chunk-S6PPBBXX.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/pack-uri-batch-operations.ts
+var packUriBatchActions = /* @__PURE__ */ new Map();
+var prefix = "model.opc.packuri.PackURI";
+packUriBatchActions.set(`${prefix}.call`, (_receiver, args) => new PackURI(args.packUriStr));
+packUriBatchActions.set(`${prefix}.from_rel_ref.call`, (_receiver, args) => {
+  return PackURI.from_rel_ref(args.baseURI, args.relativeRef);
+});
+for (const name of ["baseURI", "ext", "filename", "idx", "membername", "rels_uri"]) {
+  packUriBatchActions.set(`${prefix}.${name}.get`, (receiver) => {
+    if (!(receiver instanceof PackURI)) throw new DocxUsageError("Expected a checked package URI receiver.");
+    return receiver[name];
+  });
+}
+packUriBatchActions.set(`${prefix}.relative_ref.call`, (receiver, args) => {
+  if (!(receiver instanceof PackURI)) throw new DocxUsageError("Expected a checked package URI receiver.");
+  return receiver.relative_ref(args.baseURI);
+});
+packUriBatchActions.set(`${prefix}.string_protocol.call`, (receiver) => {
+  if (!(receiver instanceof PackURI)) throw new DocxUsageError("Expected a checked package URI receiver.");
+  return receiver.toString();
+});
+
+export {
+  packUriBatchActions
+};

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

@@ -0,0 +1,75 @@
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  documentPartRole
+} from "./chunk-DXX2Z2QA.js";
+import {
+  DocumentXmlEditor,
+  styleAttribute,
+  styleIds,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/style-allocation.ts
+function styleAllocationIds(parts, budget, parsed) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    budget.charge("work", 1);
+    const type = parseMediaType(part.content_type);
+    if (!type.startsWith("application/vnd.openxmlformats-officedocument.wordprocessingml.") || !type.endsWith("+xml")) continue;
+    const root = parsed?.get(part.bytes) ?? parseDocumentXml(part.bytes, {}, budget).root;
+    if (!Object.values(documentDialects).some((dialect) => dialect.w === root.namespace)) continue;
+    const styles = type === "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml" && root.localName === "styles";
+    const numbering = type === "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml" && root.localName === "numbering";
+    const role = documentPartRole(type, root);
+    if (!styles && !numbering && role !== "story" && role !== "glossary" && role !== "settings") continue;
+    if (styles) for (const id of styleIds(root, budget)) ids.add(id);
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      budget.charge("work", 1 + node.children.length);
+      if (node.namespace === root.namespace && ["pStyle", "rStyle", "tblStyle", "basedOn", "next", "link", "styleLink", "numStyleLink", "defaultTableStyle"].includes(node.localName)) {
+        const id = styleAttribute(node, "val");
+        if (id !== void 0) ids.add(id);
+      }
+      for (const child of node.children) stack.push(child);
+    }
+  }
+  return ids;
+}
+
+// packages/safe-bash-docx-engine/src/styles-part.ts
+function addDocumentStylesPart(archive, template, styles, budget) {
+  const name = template.package.allocatePartName("/" + template.mainPart.slice(0, template.mainPart.lastIndexOf("/") + 1) + "styles", ".xml");
+  const { w, r } = documentDialects[template.dialect];
+  const types = archive.members.find((member) => member.name === "[Content_Types].xml");
+  const typesEditor = new DocumentXmlEditor(types.bytes, {}, void 0, budget);
+  typesEditor.insertChildren(typesEditor.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(name)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>`);
+  const main = template.mainPart, split = main.lastIndexOf("/");
+  const relationshipsName = findRelationshipPart(template.package, "/" + main, budget)?.name ?? main.slice(0, split + 1) + "_rels/" + main.slice(split + 1) + ".rels";
+  const relationships = archive.members.find((member) => member.name === relationshipsName);
+  const namespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+  const relEditor = new DocumentXmlEditor(relationships?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${namespace}"/>`), {}, void 0, budget);
+  const id = template.package.allocateRelationshipId("/" + main);
+  relEditor.insertChildren(relEditor.root, `<Relationship xmlns="${namespace}" Id="${id}" Type="${r}/styles" Target="${xmlValue(relativePartTarget("/" + main, name))}"/>`);
+  const members = archive.members.map((member) => member === types ? { ...member, bytes: typesEditor.serialize() } : member === relationships ? { ...member, bytes: relEditor.serialize() } : member);
+  if (!relationships) members.push({ name: relationshipsName, bytes: relEditor.serialize(), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+  members.push({ name: name.slice(1), bytes: new TextEncoder().encode(`<w:styles xmlns:w="${w}">${styles}</w:styles>`), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+  return { archive: { ...archive, members }, name: name.slice(1) };
+}
+
+export {
+  styleAllocationIds,
+  addDocumentStylesPart
+};

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

@@ -0,0 +1,171 @@
+import {
+  SinkError,
+  writeDocumentArchive
+} from "./chunk-3VETFXYR.js";
+import {
+  asPermissionError
+} from "./chunk-JGGRMERW.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  CancellationError,
+  InputTypeError,
+  ResourceLimitError,
+  archiveSettings,
+  documentByteView
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/io.ts
+var DocumentIo = class {
+  #controller = new AbortController();
+  #borrowed;
+  #context;
+  #pending = /* @__PURE__ */ new Set();
+  #closed = false;
+  #completion;
+  constructor(context) {
+    const { limits, signal, budget } = archiveSettings(context);
+    this.#borrowed = signal;
+    this.#context = { limits, signal: AbortSignal.any([signal, this.#controller.signal]), budget };
+    context.registerCleanup?.(this.cleanup);
+  }
+  cleanup = () => {
+    if (this.#completion) return this.#completion;
+    this.#closed = true;
+    let complete;
+    this.#completion = new Promise((resolve) => {
+      complete = resolve;
+    });
+    const admitted = [...this.#pending];
+    this.#controller.abort(new CancellationError("Document I/O closed."));
+    void Promise.allSettled(admitted).then(() => {
+      complete();
+    });
+    return this.#completion;
+  };
+  #check() {
+    if (this.#context.signal.aborted || this.#closed)
+      throw new CancellationError("Document I/O cancelled.", {
+        cause: this.#borrowed.aborted ? this.#borrowed.reason : this.#controller.signal.reason
+      });
+  }
+  #run(operation) {
+    let resolve;
+    let reject;
+    const pending = new Promise((done, fail) => {
+      resolve = done;
+      reject = fail;
+    });
+    this.#pending.add(pending);
+    void pending.then(() => {
+      this.#pending.delete(pending);
+    }, () => {
+      this.#pending.delete(pending);
+    });
+    try {
+      this.#check();
+      void operation().then((value) => {
+        try {
+          this.#check();
+          resolve(value);
+        } catch (error) {
+          reject(error);
+        }
+      }, (error) => {
+        if (this.#borrowed.aborted || this.#controller.signal.aborted && error instanceof CancellationError) {
+          try {
+            this.#check();
+          } catch (cancelled) {
+            reject(cancelled);
+          }
+        } else reject(error);
+      });
+    } catch (error) {
+      reject(error);
+    }
+    return pending;
+  }
+  read(source) {
+    return this.#run(async () => readDocumentArchive(await this.readBytes(source), this.#context));
+  }
+  readBytes(source) {
+    return this.#run(async () => {
+      if (!source || typeof source.open !== "function") throw new InputTypeError("Expected a document byte source.");
+      const { limits, signal, budget } = archiveSettings(this.#context);
+      const chunks = [];
+      let size = 0;
+      const iterator = source.open(signal)[Symbol.asyncIterator]();
+      let exhausted = false;
+      let failed = false;
+      let failure;
+      try {
+        while (true) {
+          this.#check();
+          const item = await iterator.next();
+          this.#check();
+          if (item.done) {
+            exhausted = true;
+            break;
+          }
+          const bytes2 = documentByteView(item.value);
+          if (bytes2.length > limits.maxArchiveBytes - size)
+            throw new ResourceLimitError("Document input byte limit exceeded.");
+          budget.check("work", budget.usage.work + bytes2.length + 1);
+          budget.charge("retainedBytes", bytes2.length ? bytes2.length * 2 + 64 : 0);
+          size += bytes2.length;
+          if (bytes2.length) chunks.push(new Uint8Array(bytes2));
+          await budget.checkpoint(bytes2.length + 1);
+        }
+      } catch (error) {
+        failed = true;
+        failure = error;
+      } finally {
+        if (!exhausted && iterator.return) {
+          try {
+            await iterator.return();
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        }
+      }
+      if (failed) throw failure;
+      this.#check();
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return bytes;
+    }).catch((error) => {
+      throw asPermissionError(error) ?? error;
+    });
+  }
+  write(archive, sink, options) {
+    return this.#run(async () => {
+      if (!sink || typeof sink.write !== "function") throw new InputTypeError("Expected a document byte sink.");
+      let sinkFailure;
+      try {
+        await writeDocumentArchive(archive, { write: async (bytes, signal) => {
+          try {
+            await sink.write(bytes, signal);
+          } catch (error) {
+            if (!(error instanceof CancellationError))
+              sinkFailure = asPermissionError(error) ?? new SinkError("Document output failed.", { cause: error });
+            throw error;
+          }
+        } }, options, this.#context);
+      } catch (error) {
+        throw sinkFailure ?? error;
+      }
+    });
+  }
+};
+
+export {
+  DocumentIo
+};