@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-3VETFXYR.js

@@ -0,0 +1,170 @@
+import {
+  SemanticValidationError,
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  asPermissionError
+} from "./chunk-JGGRMERW.js";
+import {
+  CancellationError,
+  InputTypeError,
+  InvalidContainerError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings,
+  hasArchiveDrivePrefix
+} from "./chunk-IQFRPIXH.js";
+import {
+  createZipCodec
+} from "./chunk-XIC45QAG.js";
+import {
+  CodecError
+} from "./chunk-GEDRBQGT.js";
+
+// packages/safe-bash-docx-engine/src/archive-write.ts
+var SinkError = class extends Error {
+  code = "sink-failure";
+};
+var zip = createZipCodec(void 0, {
+  rejectDuplicateNames: true,
+  utcDates: true,
+  validatePayloads: true
+});
+function compareNames(first, second) {
+  let left = 0;
+  let right = 0;
+  while (left < first.length && right < second.length) {
+    const a = first.codePointAt(left);
+    const b = second.codePointAt(right);
+    if (a !== b) return a - b;
+    left += a > 65535 ? 2 : 1;
+    right += b > 65535 ? 2 : 1;
+  }
+  return first.length - left - (second.length - right);
+}
+async function writeArchive(archive, sink, options, context) {
+  const { limits, signal, codecLimits: admittedCodecLimits, budget } = archiveSettings(context);
+  const remainingOutput = budget.limits.serializedOutput - budget.usage.serializedOutput;
+  if (remainingOutput < 22) throw new ResourceLimitError("Archive output byte budget exceeded.");
+  const codecLimits = { ...admittedCodecLimits, maxArchiveBytes: Math.min(admittedCodecLimits.maxArchiveBytes, remainingOutput) };
+  if (!archive || !Array.isArray(archive.members) || !(archive.comment instanceof Uint8Array) || !sink || typeof sink.write !== "function" || !options)
+    throw new InputTypeError("Expected archive members, a byte sink and explicit writer options.");
+  const { order, compression } = options;
+  if (order !== "name" && order !== "input" || compression !== "store" && compression !== "deflate" || Object.keys(options).some((key) => key !== "order" && key !== "compression"))
+    throw new InvalidValueError("Invalid archive writer options.");
+  const write = sink.write.bind(sink);
+  const inputMembers = archive.members;
+  let publishing = false;
+  try {
+    signal.throwIfAborted();
+    if (inputMembers.length > Math.min(limits.maxMembers, 65534))
+      throw new ResourceLimitError("Archive member limit exceeded.");
+    let total = 0;
+    let metadata = 22;
+    let payloadBound = 0;
+    const names = /* @__PURE__ */ new Set();
+    for (const member of inputMembers) {
+      if (!member || typeof member.name !== "string" || !(member.bytes instanceof Uint8Array) || typeof member.directory !== "boolean")
+        throw new InputTypeError("Expected typed archive members.");
+      if (member.name.length > Math.min(limits.maxPathBytes, 65535))
+        throw new ResourceLimitError("Archive path limit exceeded.");
+      let nameBytes = 0;
+      for (const char of member.name) {
+        const point = char.codePointAt(0);
+        nameBytes += point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4;
+      }
+      if (nameBytes > Math.min(limits.maxPathBytes, 65535))
+        throw new ResourceLimitError("Archive path limit exceeded.");
+      if (46 + nameBytes > 65535)
+        throw new InvalidContainerError("OPC central directory headers cannot exceed 65535 bytes.");
+      const parts = member.name.split("/");
+      if (parts.at(-1) === "") parts.pop();
+      if (!member.name || member.name.includes("\\") || hasArchiveDrivePrefix(member.name) || member.name.includes("\0") || parts.some((part) => !part || part === "." || part === "..") || names.has(member.name) || member.directory !== member.name.endsWith("/") || member.directory && member.bytes.length !== 0)
+        throw new InvalidContainerError("Unsafe or inconsistent document archive member.");
+      if (parts.length > limits.maxDepth)
+        throw new ResourceLimitError("Archive path depth limit exceeded.");
+      names.add(member.name);
+      if (member.bytes.length > Math.min(limits.maxEntryBytes, 4294967294))
+        throw new ResourceLimitError("Archive entry limit exceeded.");
+      total += member.bytes.length;
+      metadata += 76 + 2 * nameBytes;
+      payloadBound += compression === "store" || member.directory ? member.bytes.length : member.bytes.length + Math.ceil(member.bytes.length / 8) + Math.ceil(member.bytes.length / 64) + 32;
+      if (!Number.isSafeInteger(total) || total > limits.maxTotalBytes || !Number.isSafeInteger(metadata) || metadata > codecLimits.maxArchiveBytes || !Number.isSafeInteger(payloadBound))
+        throw new ResourceLimitError("Archive byte budget exceeded.");
+    }
+    const outputBound = Math.min(metadata + payloadBound, codecLimits.maxArchiveBytes, 4294967294);
+    const retained = 2 * total + 3 * outputBound + 3 * metadata + (compression === "deflate" ? 1024 * 1024 : 65536) + 2 * Math.min(limits.chunkSize, 65536);
+    if (!Number.isSafeInteger(retained) || retained > limits.maxRetainedBytes || compression === "store" && metadata + total > codecLimits.maxArchiveBytes)
+      throw new ResourceLimitError("Archive output or retained byte budget exceeded.");
+    budget.charge("retainedBytes", retained);
+    budget.charge("work", total * 64 + metadata * 8);
+    const members = inputMembers.map((member) => ({
+      name: member.name,
+      directory: member.directory,
+      bytes: new Uint8Array(member.bytes)
+    }));
+    if (order === "name") members.sort((a, b) => compareNames(a.name, b.name));
+    const entries = [];
+    let encodedBytes = metadata;
+    for (const member of members) {
+      const entry = await zip.makeZipEntry(
+        member.name,
+        member.bytes,
+        {
+          modified: new Date(Date.UTC(1980, 0, 1)),
+          mode: member.directory ? 16877 : 33188,
+          directory: member.directory,
+          symlink: false,
+          compression: member.directory ? "store" : compression
+        },
+        codecLimits,
+        signal
+      );
+      entry.localExtra = new Uint8Array();
+      entry.centralExtra = new Uint8Array();
+      encodedBytes += entry.data.length;
+      if (encodedBytes > Math.min(limits.maxArchiveBytes, 4294967294))
+        throw new ResourceLimitError("Archive output byte budget exceeded.");
+      entries.push(entry);
+    }
+    const bytes = await zip.writeZipArchive(
+      { entries, comment: new Uint8Array() },
+      codecLimits,
+      signal
+    );
+    budget.charge("serializedOutput", bytes.length);
+    const chunkSize = Math.min(limits.chunkSize, 65536);
+    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+      signal.throwIfAborted();
+      publishing = true;
+      await write(new Uint8Array(bytes.subarray(offset, offset + chunkSize)), signal);
+    }
+    signal.throwIfAborted();
+  } catch (error) {
+    if (signal.aborted) throw new CancellationError("Archive writing cancelled.");
+    if (publishing) throw asPermissionError(error) ?? new SinkError("Archive output failed.");
+    if (error instanceof CodecError) {
+      if (error.code === "resource-limit") throw new ResourceLimitError("Archive limit exceeded.");
+      throw new InvalidContainerError("Invalid document archive.");
+    }
+    throw error;
+  }
+}
+
+// packages/safe-bash-docx-engine/src/document-write.ts
+async function writeDocumentArchive(archive, sink, options, context) {
+  const { limits, signal, budget } = archiveSettings(context);
+  if (signal.aborted) throw new CancellationError("Document publication cancelled.");
+  const total = archive?.members?.reduce((sum, member) => sum + (member.bytes?.length ?? 0), 0) ?? 0;
+  if (total * 32 + 65536 > limits.maxRetainedBytes)
+    throw new ResourceLimitError("Document validation retained byte limit exceeded.");
+  const report = validateDocumentArchive(archive, { maxBytes: limits.maxTotalBytes, maxParts: limits.maxMembers, maxNodes: budget.limits.xmlNodes }, budget);
+  if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+  await writeArchive(archive, sink, options, { ...context, budget });
+}
+
+export {
+  SinkError,
+  writeArchive,
+  writeDocumentArchive
+};

package/dist/safe-bash/command-chunks/chunk-3W6PTHHB.js

@@ -0,0 +1,65 @@
+import {
+  InvalidXmlError,
+  TypeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/xml-scalars.ts
+function numericToken(value) {
+  if (typeof value !== "string") throw new TypeError("XML numeric token must be a string.");
+  let start = 0;
+  let end = value.length;
+  while (start < end && " 	\r\n".includes(value[start])) start++;
+  while (end > start && " 	\r\n".includes(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+function decimal(value, fraction) {
+  let digits = 0;
+  let dot = false;
+  for (const [index, character] of [...value].entries()) {
+    if (index === 0 && (character === "+" || character === "-")) continue;
+    if (fraction && character === "." && !dot) {
+      dot = true;
+      continue;
+    }
+    if (character < "0" || character > "9") throw new InvalidXmlError("Invalid numeric XML token.");
+    digits++;
+  }
+  const result = Number(value);
+  if (!digits || !Number.isFinite(result)) throw new InvalidXmlError("Invalid numeric XML token.");
+  return result;
+}
+function readXmlInteger(value) {
+  const result = decimal(numericToken(value), false);
+  if (!Number.isSafeInteger(result))
+    throw new InvalidXmlError("XML integer exceeds the safe range.");
+  return result;
+}
+function readXmlCoordinate(value) {
+  value = numericToken(value);
+  const units = {
+    in: 914400,
+    mm: 36e3,
+    cm: 36e4,
+    pt: 12700,
+    pc: 152400,
+    pi: 152400
+  };
+  const scale = units[value.slice(-2)];
+  if (scale === void 0) return readXmlInteger(value);
+  const scaled = decimal(value.slice(0, -2), true) * scale;
+  const result = Math.sign(scaled) * Math.round(Math.abs(scaled));
+  if (!Number.isSafeInteger(result))
+    throw new InvalidXmlError("XML coordinate exceeds the safe range.");
+  return result === 0 ? 0 : result;
+}
+function readXmlPercentage(value) {
+  if (value === void 0) throw new InvalidXmlError("Missing percentage value.");
+  value = numericToken(value);
+  return value.endsWith("%") ? decimal(value.slice(0, -1), true) / 100 : readXmlInteger(value) / 1e5;
+}
+
+export {
+  readXmlInteger,
+  readXmlCoordinate,
+  readXmlPercentage
+};

package/dist/safe-bash/command-chunks/chunk-457CU3IC.js

@@ -0,0 +1,8 @@
+// packages/safe-bash-command-node/src/commands/safejs/options.ts
+import { defaultSafeJsLimits, commandLimits, invocation } from "../../safe-bash-command-safejs/options.js";
+
+export {
+  defaultSafeJsLimits,
+  commandLimits,
+  invocation
+};

package/dist/safe-bash/command-chunks/chunk-45BW6MGM.js

@@ -0,0 +1,250 @@
+import {
+  imageMetadata
+} from "./chunk-UPXFSGQG.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+import {
+  crc32
+} from "./chunk-XIC45QAG.js";
+
+// packages/safe-bash-presentation-engine/src/image-admission.ts
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "admit");
+}
+function dimensions(width, height) {
+  if (width === 0 || height === 0) invalid("Image dimensions must be positive.");
+  if (width > 1e6 || height > 1e6 || width * height > 1e8)
+    throw new OfficeError(
+      "resource-limit",
+      "Image pixel dimensions exceed the admission budget.",
+      "admit"
+    );
+}
+function png(bytes, view) {
+  if (![137, 80, 78, 71, 13, 10, 26, 10].every((byte, index) => bytes[index] === byte))
+    invalid("Invalid PNG signature.");
+  let offset = 8, header = false, data = false, palette = false, endedData = false, color = 0;
+  while (offset <= bytes.length - 12) {
+    const length = view.getUint32(offset);
+    if (length > bytes.length - offset - 12) invalid("Truncated PNG chunk.");
+    const name = bytes.subarray(offset + 4, offset + 8);
+    if (!name.every((byte) => byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122) || (name[2] & 32) !== 0)
+      invalid("Invalid PNG chunk name.");
+    const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+    if (crc32(bytes.subarray(offset + 4, offset + 8 + length)) !== view.getUint32(offset + 8 + length))
+      invalid("Invalid PNG chunk checksum.");
+    if (!header && type !== "IHDR") invalid("PNG must start with its image header.");
+    if (type === "IHDR") {
+      if (header || length !== 13) invalid("Invalid PNG image header.");
+      dimensions(view.getUint32(offset + 8), view.getUint32(offset + 12));
+      const depth = bytes[offset + 16];
+      color = bytes[offset + 17];
+      const depths = {
+        0: [1, 2, 4, 8, 16],
+        2: [8, 16],
+        3: [1, 2, 4, 8],
+        4: [8, 16],
+        6: [8, 16]
+      };
+      if (!depths[color]?.includes(depth) || bytes[offset + 18] !== 0 || bytes[offset + 19] !== 0 || bytes[offset + 20] > 1)
+        invalid("Unsupported PNG header fields.");
+      header = true;
+    } else if (type === "PLTE") {
+      if (palette || data || length === 0 || length > 768 || length % 3 !== 0 || color === 0 || color === 4)
+        invalid("Invalid PNG palette.");
+      palette = true;
+    } else if (type === "IDAT") {
+      if (endedData || color === 3 && !palette) invalid("Invalid PNG image data order.");
+      data = true;
+    } else if (type === "IEND") {
+      if (!data || length !== 0 || offset + 12 !== bytes.length) invalid("Invalid PNG ending.");
+      return;
+    } else {
+      if (data) endedData = true;
+      if ((bytes[offset + 4] & 32) === 0) invalid("Unsupported critical PNG chunk.");
+    }
+    offset += length + 12;
+  }
+  invalid("PNG is missing its ending.");
+}
+function gif(bytes, view) {
+  const signature = String.fromCharCode(...bytes.subarray(0, 6));
+  if (bytes.length < 13 || signature !== "GIF87a" && signature !== "GIF89a")
+    invalid("Invalid GIF header.");
+  const width = view.getUint16(6, true), height = view.getUint16(8, true);
+  dimensions(width, height);
+  let offset = 13 + (bytes[10] & 128 ? 3 * 2 ** ((bytes[10] & 7) + 1) : 0), frames = 0, pixels = 0;
+  while (offset < bytes.length) {
+    const marker = bytes[offset++];
+    if (marker === 59) {
+      if (!frames || offset !== bytes.length) invalid("Invalid GIF ending.");
+      return;
+    }
+    if (marker === 44) {
+      if (offset > bytes.length - 9) invalid("Truncated GIF image descriptor.");
+      const left = view.getUint16(offset, true), top = view.getUint16(offset + 2, true);
+      const frameWidth = view.getUint16(offset + 4, true), frameHeight = view.getUint16(offset + 6, true);
+      dimensions(frameWidth, frameHeight);
+      if (left + frameWidth > width || top + frameHeight > height)
+        invalid("GIF frame exceeds logical screen.");
+      pixels += frameWidth * frameHeight;
+      if (pixels > 1e8)
+        throw new OfficeError("resource-limit", "GIF frame pixel budget exceeded.", "admit");
+      const packed = bytes[offset + 8];
+      offset += 9 + (packed & 128 ? 3 * 2 ** ((packed & 7) + 1) : 0);
+      if (offset >= bytes.length || bytes[offset] < 2 || bytes[offset] > 8)
+        invalid("Invalid GIF code size.");
+      offset++;
+      frames++;
+    } else if (marker === 33) {
+      if (offset >= bytes.length) invalid("Truncated GIF extension.");
+      offset++;
+    } else invalid("Invalid GIF block marker.");
+    while (true) {
+      if (offset >= bytes.length) invalid("Truncated GIF data block.");
+      const length = bytes[offset++];
+      if (length === 0) break;
+      if (length > bytes.length - offset) invalid("Truncated GIF data block.");
+      offset += length;
+    }
+  }
+  invalid("GIF is missing its ending.");
+}
+function jpeg(bytes, view) {
+  if (bytes[0] !== 255 || bytes[1] !== 216) invalid("Invalid JPEG signature.");
+  let offset = 2, entropy = false;
+  while (offset < bytes.length) {
+    if (entropy && bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    if (bytes[offset++] !== 255) invalid("Invalid JPEG marker.");
+    while (bytes[offset] === 255) offset++;
+    const marker = bytes[offset++];
+    if (marker === 217) {
+      if (offset !== bytes.length) invalid("Unexpected bytes after JPEG ending.");
+      return;
+    }
+    if (entropy && marker === 0) continue;
+    if (marker === void 0 || marker === 0 || marker === 216) invalid("Invalid JPEG marker.");
+    if (marker === 1 || marker >= 208 && marker <= 215) continue;
+    entropy = false;
+    if (offset > bytes.length - 2) invalid("Truncated JPEG segment.");
+    const length = view.getUint16(offset);
+    if (length < 2 || length > bytes.length - offset) invalid("Invalid JPEG segment length.");
+    if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker)) {
+      if (length < 8 || bytes[offset + 7] === 0 || length !== 8 + 3 * bytes[offset + 7])
+        invalid("Invalid JPEG frame header.");
+      dimensions(view.getUint16(offset + 5), view.getUint16(offset + 3));
+    }
+    if (marker === 218) {
+      if (length < 6 || bytes[offset + 2] === 0 || length !== 6 + 2 * bytes[offset + 2])
+        invalid("Invalid JPEG scan header.");
+      entropy = true;
+    }
+    offset += length;
+  }
+  invalid("JPEG is missing its ending.");
+}
+function bmp(bytes, view) {
+  if (bytes.length < 26 || bytes[0] !== 66 || bytes[1] !== 77) invalid("Invalid BMP header.");
+  if (view.getUint32(2, true) !== bytes.length) invalid("Invalid BMP byte length.");
+  const header = view.getUint32(14, true), pixelOffset = view.getUint32(10, true);
+  if (![12, 40, 52, 56, 108, 124].includes(header) || header > bytes.length - 14)
+    invalid("Unsupported or truncated BMP information header.");
+  if (pixelOffset < 14 + header || pixelOffset >= bytes.length)
+    invalid("Invalid BMP pixel offset.");
+  const planes = view.getUint16(header === 12 ? 22 : 26, true);
+  const depth = view.getUint16(header === 12 ? 24 : 28, true);
+  if (planes !== 1 || ![1, 4, 8, 16, 24, 32].includes(depth))
+    invalid("Invalid BMP planes or bit depth.");
+  const metadata = imageMetadata(bytes, "image/bmp");
+  if (!metadata.pixelWidth || !metadata.pixelHeight) invalid("Invalid BMP dimensions.");
+  dimensions(metadata.pixelWidth, metadata.pixelHeight);
+  const compression = header === 12 ? 0 : view.getUint32(30, true);
+  if (compression === 0) {
+    const stride = Math.ceil(metadata.pixelWidth * depth / 32) * 4;
+    if (stride * metadata.pixelHeight > bytes.length - pixelOffset)
+      invalid("Truncated BMP pixels.");
+  }
+}
+function tiff(bytes, view) {
+  const little = bytes[0] === 73 && bytes[1] === 73;
+  if (bytes.length < 8 || !little && !(bytes[0] === 77 && bytes[1] === 77) || view.getUint16(2, little) !== 42)
+    invalid("Invalid TIFF header.");
+  let offset = view.getUint32(4, little);
+  const visited = /* @__PURE__ */ new Set();
+  while (offset !== 0) {
+    if (visited.has(offset) || offset < 8 || offset > bytes.length - 6)
+      invalid("Invalid TIFF directory offset.");
+    visited.add(offset);
+    const count = view.getUint16(offset, little);
+    if (count > Math.floor((bytes.length - offset - 6) / 12)) invalid("Truncated TIFF directory.");
+    for (let index = 0; index < count; index++) {
+      const entry = offset + 2 + index * 12, type = view.getUint16(entry + 2, little);
+      const widths = [0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8];
+      const width = widths[type];
+      if (!width) invalid("Unsupported TIFF field type.");
+      const size = view.getUint32(entry + 4, little) * width;
+      if (size > 4) {
+        const pointer = view.getUint32(entry + 8, little);
+        if (pointer < 8 || pointer > bytes.length || size > bytes.length - pointer)
+          invalid("Truncated TIFF field.");
+      }
+    }
+    offset = view.getUint32(offset + 2 + count * 12, little);
+  }
+  const metadata = imageMetadata(bytes, "image/tiff");
+  if (!metadata.pixelWidth || !metadata.pixelHeight) invalid("TIFF dimensions are missing.");
+  dimensions(metadata.pixelWidth, metadata.pixelHeight);
+}
+function wmf(bytes, view) {
+  if (bytes.length < 46 || view.getUint32(0, true) !== 2596720087)
+    invalid("A placeable WMF header is required.");
+  let checksum = 0;
+  for (let offset2 = 0; offset2 < 20; offset2 += 2) checksum ^= view.getUint16(offset2, true);
+  if (checksum !== view.getUint16(20, true) || view.getUint16(14, true) === 0)
+    invalid("Invalid WMF placeable header.");
+  if (![1, 2].includes(view.getUint16(22, true)) || view.getUint16(24, true) !== 9 || ![256, 768].includes(view.getUint16(26, true)) || view.getUint32(28, true) * 2 !== bytes.length - 22)
+    invalid("Invalid WMF standard header.");
+  let offset = 40;
+  while (offset <= bytes.length - 6) {
+    const words = view.getUint32(offset, true), type = view.getUint16(offset + 4, true);
+    if (words < 3 || words * 2 > bytes.length - offset) invalid("Invalid WMF record size.");
+    offset += words * 2;
+    if (type === 0) {
+      if (words !== 3 || offset !== bytes.length) invalid("Invalid WMF ending.");
+      const metadata = imageMetadata(bytes, "image/x-wmf");
+      if (!metadata.pixelWidth || !metadata.pixelHeight) invalid("Invalid WMF bounds.");
+      dimensions(metadata.pixelWidth, metadata.pixelHeight);
+      return;
+    }
+  }
+  invalid("WMF is missing its ending.");
+}
+function admitImage(bytes, contentType) {
+  if (!(bytes instanceof Uint8Array))
+    throw new OfficeError("invalid-type", "Image bytes must be a Uint8Array.", "admit");
+  if (bytes.byteLength > 32 * 1024 * 1024)
+    throw new OfficeError("resource-limit", "Encoded image exceeds 32 MiB.", "admit");
+  if (typeof contentType !== "string")
+    throw new OfficeError("invalid-type", "Image content type must be a string.", "admit");
+  const formats = {
+    "image/png": { extension: "png", validate: png },
+    "image/jpeg": { extension: "jpg", validate: jpeg },
+    "image/gif": { extension: "gif", validate: gif },
+    "image/bmp": { extension: "bmp", validate: bmp },
+    "image/tiff": { extension: "tiff", validate: tiff },
+    "image/x-wmf": { extension: "wmf", validate: wmf }
+  };
+  const format = Object.hasOwn(formats, contentType) ? formats[contentType] : void 0;
+  if (!format)
+    throw new OfficeError("unsupported-profile", "Unsupported image content type.", "admit");
+  format.validate(bytes, new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  return { ...imageMetadata(bytes, contentType), extension: format.extension };
+}
+
+export {
+  admitImage
+};