@poe-platform/safe-bash 0.1.818 → 0.1.819

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

@@ -1,26 +1,26 @@
 import {
   createPropertyPart
 } from "./chunk-5IHJWBDR.js";
-import {
-  measurePackageResourceSerialization
-} from "./chunk-ETN25WCR.js";
-import {
-  validateDocxInvocation
-} from "./chunk-BDGNKRY4.js";
-import {
-  normalizeDocxPropertyOptions
-} from "./chunk-NP2QXF2X.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-LTWX23FS.js";
+} from "./chunk-QQ7ORF2D.js";
 import {
   SemanticValidationError,
   validateDocumentArchive
 } from "./chunk-FILE5PBI.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-KD4JUF6R.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
+import {
+  normalizeDocxPropertyOptions
+} from "./chunk-NP2QXF2X.js";
 import {
   DocumentXmlEditor,
   UnsupportedEditError,

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

@@ -0,0 +1,192 @@
+// packages/safe-bash-presentation-engine/src/image-metadata.ts
+function normalizeImageDpi(value) {
+  const axes = Array.isArray(value) ? value : [];
+  const axis = (raw) => {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) return 72;
+    const lower = Math.floor(raw);
+    const rounded = raw - lower === 0.5 ? lower + (lower % 2 === 0 ? 0 : 1) : Math.round(raw);
+    return rounded >= 1 && rounded <= 2048 ? rounded : 72;
+  };
+  return [axis(axes[0]), axis(axes[1])];
+}
+var emptyMetadata = () => ({
+  pixelWidth: null,
+  pixelHeight: null,
+  dpiX: 72,
+  dpiY: 72
+});
+function* read(offset, length) {
+  const bytes = yield { offset, length };
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+var matches = (bytes, offset, values) => values.every(
+  (value, index) => offset + index < bytes.byteLength && bytes.getUint8(offset + index) === value
+);
+function* tiffMetadata(size, base = 0) {
+  const result = emptyMetadata();
+  if (size < 8) return result;
+  const header = yield* read(base, 8), little = matches(header, 0, [73, 73]);
+  if (!little && !matches(header, 0, [77, 77]) || header.getUint16(2, little) !== 42)
+    return result;
+  const start = header.getUint32(4, little);
+  if (start < 8 || start > size - 2) return result;
+  const count = (yield* read(base + start, 2)).getUint16(0, little);
+  if (count > Math.floor((size - start - 2) / 12)) return result;
+  let x, y, unit = 2;
+  for (let index = 0; index < count; index++) {
+    const entry = yield* read(base + start + 2 + index * 12, 12), tag = entry.getUint16(0, little), type = entry.getUint16(2, little);
+    if (entry.getUint32(4, little) !== 1) continue;
+    let value;
+    if (type === 3) value = entry.getUint16(8, little);
+    if (type === 4) value = entry.getUint32(8, little);
+    if (type === 5) {
+      const pointer = entry.getUint32(8, little);
+      if (pointer <= size - 8) {
+        const fraction = yield* read(base + pointer, 8), denominator = fraction.getUint32(4, little);
+        if (denominator !== 0) value = fraction.getUint32(0, little) / denominator;
+      }
+    }
+    if (value === void 0) continue;
+    if (tag === 256 && (type === 3 || type === 4) && value > 0) result.pixelWidth = value;
+    if (tag === 257 && (type === 3 || type === 4) && value > 0) result.pixelHeight = value;
+    if (tag === 282) x = value;
+    if (tag === 283) y = value;
+    if (tag === 296) unit = value;
+  }
+  const multiplier = unit === 3 ? 2.54 : unit === 2 ? 1 : 0;
+  [result.dpiX, result.dpiY] = normalizeImageDpi([
+    x === void 0 ? null : x * multiplier,
+    y === void 0 ? null : y * multiplier
+  ]);
+  return result;
+}
+function* metadataRanges(size, mediaType) {
+  if (mediaType === "image/tiff") return yield* tiffMetadata(size);
+  const result = emptyMetadata(), header = yield* read(0, Math.min(size, 54));
+  if (mediaType === "image/x-wmf" && size >= 22 && header.getUint32(0, true) === 2596720087) {
+    const units = header.getUint16(14, true), width = header.getInt16(10, true) - header.getInt16(6, true), height = header.getInt16(12, true) - header.getInt16(8, true);
+    if (units && width > 0 && height > 0) {
+      result.pixelWidth = Math.max(1, Math.floor(width * 72 / units));
+      result.pixelHeight = Math.max(1, Math.floor(height * 72 / units));
+    }
+  } else if (mediaType === "image/png" && size >= 33 && matches(header, 0, [137, 80, 78, 71, 13, 10, 26, 10]) && header.getUint32(8) === 13 && matches(header, 12, [73, 72, 68, 82])) {
+    result.pixelWidth = header.getUint32(16) || null;
+    result.pixelHeight = header.getUint32(20) || null;
+    let offset = 33;
+    while (offset <= size - 12) {
+      const chunk = yield* read(offset, 8), length = chunk.getUint32(0);
+      if (length > size - offset - 12) break;
+      if (matches(chunk, 4, [112, 72, 89, 115]) && length === 9) {
+        const physical = yield* read(offset + 8, 9);
+        if (physical.getUint8(8) === 1)
+          [result.dpiX, result.dpiY] = normalizeImageDpi([
+            physical.getUint32(0) * 0.0254,
+            physical.getUint32(4) * 0.0254
+          ]);
+      }
+      if (matches(chunk, 4, [73, 69, 78, 68])) break;
+      offset += length + 12;
+    }
+  } else if (mediaType === "image/gif" && size >= 13 && (matches(header, 0, [71, 73, 70, 56, 55, 97]) || matches(header, 0, [71, 73, 70, 56, 57, 97]))) {
+    result.pixelWidth = header.getUint16(6, true) || null;
+    result.pixelHeight = header.getUint16(8, true) || null;
+  } else if (mediaType === "image/bmp" && size >= 26 && matches(header, 0, [66, 77])) {
+    const headerSize = header.getUint32(14, true);
+    if (headerSize === 12) {
+      result.pixelWidth = header.getUint16(18, true) || null;
+      result.pixelHeight = header.getUint16(20, true) || null;
+    } else if (headerSize >= 40 && headerSize <= size - 14) {
+      const width = header.getInt32(18, true), height = header.getInt32(22, true);
+      result.pixelWidth = width > 0 ? width : null;
+      result.pixelHeight = Math.abs(height) || null;
+      [result.dpiX, result.dpiY] = normalizeImageDpi([
+        header.getInt32(38, true) * 0.0254,
+        header.getInt32(42, true) * 0.0254
+      ]);
+    }
+  } else if (mediaType === "image/jpeg" && matches(header, 0, [255, 216])) {
+    let offset = 2;
+    while (offset < size) {
+      if ((yield* read(offset++, 1)).getUint8(0) !== 255) break;
+      let marker;
+      while (offset < size) {
+        marker = (yield* read(offset++, 1)).getUint8(0);
+        if (marker !== 255) break;
+      }
+      if (marker === void 0 || marker === 255 || marker === 217 || marker === 218) break;
+      if (marker === 1 || marker >= 208 && marker <= 215) continue;
+      if (offset > size - 2) break;
+      const length = (yield* read(offset, 2)).getUint16(0);
+      if (length < 2 || length > size - offset) break;
+      if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker) && length >= 8) {
+        const frame = yield* read(offset + 3, 4);
+        result.pixelHeight = frame.getUint16(0) || null;
+        result.pixelWidth = frame.getUint16(2) || null;
+      }
+      if (marker === 224 && length >= 16) {
+        const jfif = yield* read(offset + 2, 14);
+        if (matches(jfif, 0, [74, 70, 73, 70, 0])) {
+          const unit = jfif.getUint8(7), multiplier = unit === 1 ? 1 : unit === 2 ? 2.54 : 0;
+          [result.dpiX, result.dpiY] = normalizeImageDpi([
+            jfif.getUint16(8) * multiplier,
+            jfif.getUint16(10) * multiplier
+          ]);
+        }
+      }
+      if (marker === 225 && length >= 16 && matches(yield* read(offset + 2, 6), 0, [69, 120, 105, 102, 0, 0])) {
+        const metadata = yield* tiffMetadata(length - 8, offset + 8);
+        result.dpiX = metadata.dpiX;
+        result.dpiY = metadata.dpiY;
+      }
+      offset += length;
+    }
+  }
+  return result;
+}
+function imageMetadata(bytes, mediaType) {
+  const reader = metadataRanges(bytes.length, mediaType);
+  let next = reader.next();
+  while (!next.done)
+    next = reader.next(bytes.subarray(next.value.offset, next.value.offset + next.value.length));
+  return next.value;
+}
+async function readImageMetadata(source, mediaType, signal) {
+  const size = source.size;
+  if (!Number.isSafeInteger(size) || size < 0)
+    throw new RangeError("Invalid image metadata source size.");
+  const reader = metadataRanges(size, mediaType);
+  let next = reader.next(), cache = new Uint8Array(), start = 0;
+  try {
+    while (!next.done) {
+      signal?.throwIfAborted();
+      const request = next.value, field = new Uint8Array(request.length);
+      let used = 0;
+      while (used < field.length) {
+        const offset = request.offset + used;
+        if (offset < start || offset >= start + cache.length) {
+          signal?.throwIfAborted();
+          const length = Math.min(16384, size - offset), bytes = await source.read(offset, length);
+          signal?.throwIfAborted();
+          if (!(bytes instanceof Uint8Array) || !bytes.length || bytes.length > length)
+            throw new RangeError("Invalid image metadata range result.");
+          cache = new Uint8Array(bytes);
+          start = offset;
+        }
+        const amount = Math.min(field.length - used, start + cache.length - offset);
+        field.set(cache.subarray(offset - start, offset - start + amount), used);
+        used += amount;
+      }
+      next = reader.next(field);
+    }
+    signal?.throwIfAborted();
+    return next.value;
+  } finally {
+    reader.return(emptyMetadata());
+  }
+}
+
+export {
+  normalizeImageDpi,
+  imageMetadata,
+  readImageMetadata
+};

package/dist/safe-bash/command-chunks/{chunk-F2NF6FHV.js → chunk-ZXIOTUXC.js}

@@ -1,9 +1,9 @@
 import {
   admitImage
-} from "./chunk-4IDV763L.js";
+} from "./chunk-ZS4J5B6Y.js";
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/image-value.ts
 import { sha1 } from "@noble/hashes/legacy.js";

package/dist/safe-bash/command-chunks/{chunk-DJB5RB6U.js → chunk-ZZ6EIACJ.js}

@@ -1,37 +1,41 @@
 import {
-  openRetainedPresentationIndex,
+  openRetainedPresentationIndex
+} from "./chunk-LZHFVNEV.js";
+import {
   stageRetainedOutput,
   streamJson
-} from "./chunk-3ZGO24WG.js";
+} from "./chunk-R36PDP3L.js";
 import {
   writePackageArchive
-} from "./chunk-TG2RVQLP.js";
+} from "./chunk-5KWEZV5H.js";
 import {
   readPackage
-} from "./chunk-Q65GWGQR.js";
-import {
-  readBinary
-} from "./chunk-FAU2KL6I.js";
+} from "./chunk-KVTZJBLM.js";
 import {
   openRetainedPresentationValidation,
   validatePresentation
-} from "./chunk-N6VNHC3B.js";
+} from "./chunk-SKDJCMGI.js";
+import {
+  dialects
+} from "./chunk-P3LHQOX7.js";
 import {
-  dialects,
   openRetainedContentTypes
-} from "./chunk-6KJDTKE4.js";
+} from "./chunk-O4H7HPMP.js";
 import {
   parseXmlPart
-} from "./chunk-7PYDVQPB.js";
+} from "./chunk-YWP62BAZ.js";
 import {
   readRelationshipGraph
-} from "./chunk-4YFTJS5U.js";
+} from "./chunk-QMXOKYMJ.js";
 import {
   parseContentTypes
-} from "./chunk-XFIDOCYH.js";
+} from "./chunk-6ZHNKHQQ.js";
 import {
   relativePartReference
-} from "./chunk-MOUCMZZP.js";
+} from "./chunk-PZVFNPRC.js";
+import {
+  readBinary
+} from "./chunk-S5MBHFLB.js";
 import {
   OfficeError,
   characters,
@@ -39,7 +43,7 @@ import {
   literal,
   openRetainedXmlDocument,
   resolveOfficeResources
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/settings-scaling.ts
 function unsupported() {
@@ -174,57 +178,6 @@ async function numeric(document, node, name) {
   if (!digits) invalid("Invalid numeric presentation setting.");
   return negative ? -number : number;
 }
-async function* escaped(source) {
-  let buffer = "";
-  for await (const character of characters(source)) {
-    buffer += { "&": "&amp;", "<": "&lt;", '"': "&quot;", "	": "&#9;", "\n": "&#10;", "\r": "&#13;" }[character] ?? character;
-    if (buffer.length >= 2048) {
-      yield* literal(buffer);
-      buffer = "";
-    }
-  }
-  if (buffer) yield* literal(buffer);
-}
-async function* standalone(document, node, maxCharacters) {
-  async function* declarations() {
-    if (node === document.root) return;
-    for await (const inherited of document.declarations(document.root)) {
-      if (await equal(document.raw(inherited.name), literal("xmlns:xml"))) continue;
-      let local = false;
-      for await (const own of document.declarations(node)) if (await equal(document.raw(own.name), document.raw(inherited.name))) {
-        local = true;
-        break;
-      }
-      if (local) continue;
-      yield* literal(" ");
-      yield* document.raw(inherited.name);
-      yield* literal('="');
-      yield* escaped(document.text(inherited));
-      yield* literal('"');
-    }
-  }
-  async function* markup() {
-    let remaining = node.name.length + 1;
-    for await (const bytes of document.markup(node)) {
-      if (remaining) {
-        const size = Math.min(remaining, bytes.length);
-        yield bytes.subarray(0, size);
-        remaining -= size;
-        if (!remaining) yield* declarations();
-        if (size < bytes.length) yield bytes.subarray(size);
-      } else yield bytes;
-    }
-  }
-  let count = 0;
-  const decoder = new TextDecoder();
-  for await (const bytes of markup()) {
-    count += decoder.decode(bytes, { stream: true }).length;
-    if (count > maxCharacters) throw new OfficeError("resource-limit", "XML resource limit exceeded.", "parse");
-    yield bytes;
-  }
-  count += decoder.decode().length;
-  if (count > maxCharacters) throw new OfficeError("resource-limit", "XML resource limit exceeded.", "parse");
-}
 async function openRetainedPresentationSettings(archive, fingerprint, settings2) {
   const context = { ...resolveOfficeResources(settings2), workingStorage: { ...settings2.workingStorage } };
   const index = await openRetainedPresentationIndex(archive, fingerprint, context), owned = [index];
@@ -277,7 +230,7 @@ async function openRetainedPresentationSettings(archive, fingerprint, settings2)
       return { part, document };
     }
     const properties = await related("presProps"), view = await related("viewProps");
-    const viewXml = view ? () => standalone(view.document, view.document.root, context.xmlLimits.maxBytes) : void 0;
+    const viewXml = view ? () => view.document.markup(view.document.root, true) : void 0;
     if (viewXml) for await (const ignored of viewXml()) check();
     const print = properties && await child2(properties.document, properties.document.root, "prnPr");
     const slide = await child2(main, main.root, "sldSz"), notes = await child2(main, main.root, "notesSz");
@@ -307,7 +260,7 @@ async function openRetainedPresentationSettings(archive, fingerprint, settings2)
     if (count > 1) invalid("Ambiguous slideshow mode.");
     const slideNumberStart = await numeric(main, main.root, "firstSlideNum") ?? 1;
     if (slideNumberStart < -2147483648 || slideNumberStart > 2147483647) invalid("Invalid slide numbering value.");
-    const printXml = print ? () => standalone(properties.document, print, context.xmlLimits.maxBytes) : void 0;
+    const printXml = print ? () => properties.document.markup(print, true) : void 0;
     if (printXml) for await (const ignored of printXml()) check();
     const value = {
       width,

package/dist/safe-bash/command-chunks/{chunk-XMRQ6UP2.js → chunk-ZZO3GYEZ.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-5VF2EA7Z.js";
+} from "./chunk-U7J3R7HX.js";
 
 // packages/safe-bash-command-rg/src/shared.ts
 import { readFileStream } from "../../safe-bash-contracts/filesystem.js";
@@ -22,7 +22,6 @@ var emptyBuffer = filledBytes(0);
 var OUT_BUFFER_SIZE = 64 * 1024;
 var sharedOutBuf = new Uint8Array(OUT_BUFFER_SIZE);
 var sharedOutBufInUse = false;
-var sharedOutBufGeneration = 0;
 var Limits = class {
   constructor(context, options) {
     this.context = context;
@@ -97,7 +96,6 @@ var Limits = class {
     if (!buf) {
       if (!sharedOutBufInUse) {
         sharedOutBufInUse = true;
-        sharedOutBufGeneration = sharedOutBufGeneration + 1 | 0;
         this.usingSharedBuf = true;
         buf = this.outBuf = sharedOutBuf;
       } else {
@@ -152,13 +150,6 @@ var Limits = class {
       this.releaseOutBuf();
     }
   }
-  flushCachedSharedSync(len) {
-    if (sharedOutBufInUse) return false;
-    const syncSink = this.context.stdout;
-    if (typeof syncSink.writeRangeSync !== "function") return false;
-    (this._signal ?? this.context.signal).throwIfAborted();
-    return syncSink.writeRangeSync(sharedOutBuf, len) === true;
-  }
   flushSyncOrAsync() {
     if (this.outPos > 0 && this.outBuf) {
       const syncSink = this.context.stdout;
@@ -764,7 +755,6 @@ Object.assign(Limits.prototype, {
 export {
   pathFor,
   OutputClosed,
-  sharedOutBufGeneration,
   Limits,
   fileInput,
   diagnostic,