@poe-platform/safe-bash 0.1.835 → 0.1.837

package/dist/image-ast/browser/codecs/gif-output-parts.d.ts

@@ -11,6 +11,8 @@ export declare class GifPalette {
     private readonly colors;
     private readonly used;
     private readonly missing;
+    private readonly histogram;
+    private quantized?;
     constructor();
     add(r: number, g: number, b: number, a: number): void;
     finish(): void;

package/dist/image-ast/browser/codecs/gif-storage.d.ts

@@ -1,4 +1,4 @@
 import type { ImageByteStorage, StoredRgbaImage } from "./png-storage.js";
 import { type GifOptions } from "./gif-output-parts.js";
-/** Multipass GIF encoding with a fixed palette and pull-driven owned subblocks. */
+/** Multipass GIF encoding with a source-derived palette and pull-driven owned subblocks. */
 export declare function encodeGifFromStorage(image: StoredRgbaImage, storage: ImageByteStorage, signal: AbortSignal, options?: GifOptions): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;

package/dist/image-ast/codecs/gif-output-parts.d.ts

@@ -11,6 +11,8 @@ export declare class GifPalette {
     private readonly colors;
     private readonly used;
     private readonly missing;
+    private readonly histogram;
+    private quantized?;
     constructor();
     add(r: number, g: number, b: number, a: number): void;
     finish(): void;

package/dist/image-ast/codecs/gif-storage.d.ts

@@ -1,4 +1,4 @@
 import type { ImageByteStorage, StoredRgbaImage } from "./png-storage.js";
 import { type GifOptions } from "./gif-output-parts.js";
-/** Multipass GIF encoding with a fixed palette and pull-driven owned subblocks. */
+/** Multipass GIF encoding with a source-derived palette and pull-driven owned subblocks. */
 export declare function encodeGifFromStorage(image: StoredRgbaImage, storage: ImageByteStorage, signal: AbortSignal, options?: GifOptions): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;

package/dist/image-ast/index.js

@@ -5394,12 +5394,66 @@ function decodeWebpImage(bytes) {
   };
 }
 
+// src/codecs/gif-quantization.ts
+function quantizeGif(histogram, palette) {
+  let bins = [];
+  for (let id = 0; id < 32768; id++) {
+    let at = id * 4, count = histogram[at + 3];
+    count && bins.push([
+      histogram[at] / count,
+      histogram[at + 1] / count,
+      histogram[at + 2] / count,
+      count,
+      id
+    ]);
+  }
+  let box2 = (colors) => {
+    let sum = [0, 0, 0], squares = [0, 0, 0], count = 0;
+    for (let color of colors) {
+      count += color[3];
+      for (let c = 0; c < 3; c++)
+        sum[c] += color[c] * color[3], squares[c] += color[c] ** 2 * color[3];
+    }
+    let variance = squares.map((value, c) => Math.max(0, value - sum[c] ** 2 / count)), axis = variance.indexOf(Math.max(...variance));
+    return { colors, count, sum, axis, error: colors.length > 1 ? variance[axis] : 0 };
+  }, boxes = [box2(bins)];
+  for (; boxes.length < 254; ) {
+    let best = 0;
+    for (let i = 1; i < boxes.length; i++) boxes[i].error > boxes[best].error && (best = i);
+    let current = boxes[best];
+    if (current.error <= 0) break;
+    current.colors.sort((a, b) => a[current.axis] - b[current.axis]);
+    let count = 0, split = 0;
+    do
+      count += current.colors[split++][3];
+    while (count < current.count / 2 && split < current.colors.length - 1);
+    boxes[best] = box2(current.colors.slice(0, split)), boxes.push(box2(current.colors.slice(split)));
+  }
+  palette.fill(0, 0, 762);
+  for (let i = 0; i < boxes.length; i++)
+    for (let c = 0; c < 3; c++)
+      palette[i * 3 + c] = Math.round(boxes[i].sum[c] / boxes[i].count);
+  let indices2 = new Uint8Array(32768);
+  for (let color of bins) {
+    let distance = 1 / 0, nearest = 0;
+    for (let i = 0; i <= boxes.length; i++) {
+      let index = i === boxes.length ? 254 : i, error = 0;
+      for (let c = 0; c < 3; c++) error += (color[c] - palette[index * 3 + c]) ** 2;
+      error < distance && (distance = error, nearest = index);
+    }
+    indices2[color[4]] = nearest;
+  }
+  return indices2;
+}
+
 // src/codecs/gif-output-parts.ts
 var GifPalette = class {
   bytes = new Uint8Array(768);
   colors = /* @__PURE__ */ new Map();
   used = /* @__PURE__ */ new Set();
   missing = /* @__PURE__ */ new Set();
+  histogram = new Float64Array(32768 * 4);
+  quantized;
   constructor() {
     for (let i = 0; i < 254; i++) {
       let r = Math.round((i >>> 5 & 7) * 255 / 7), g = Math.round((i >>> 2 & 7) * 255 / 7), b = Math.round((i & 3) * 255 / 3);
@@ -5409,6 +5463,10 @@ var GifPalette = class {
   }
   add(r, g, b, a) {
     if (a < 128) return;
+    if (r !== 255 || g !== 255 || b !== 255) {
+      let at = (r >>> 3 << 10 | g >>> 3 << 5 | b >>> 3) * 4;
+      this.histogram[at] += r, this.histogram[at + 1] += g, this.histogram[at + 2] += b, this.histogram[at + 3]++;
+    }
     let key = r << 16 | g << 8 | b, existing = this.colors.get(key);
     existing !== void 0 ? this.used.add(existing) : this.missing.size < 255 && this.missing.add(key);
   }
@@ -5420,10 +5478,13 @@ var GifPalette = class {
         if (probe >= 254) break;
         this.used.add(probe), this.colors.set(key, probe), this.bytes.set([key >>> 16 & 255, key >>> 8 & 255, key & 255], probe * 3);
       }
-    }
+    } else
+      this.quantized = quantizeGif(this.histogram, this.bytes);
   }
   index(r, g, b, a) {
     if (a < 128) return 255;
+    if (this.quantized)
+      return r === 255 && g === 255 && b === 255 ? 254 : this.quantized[r >>> 3 << 10 | g >>> 3 << 5 | b >>> 3];
     let exact = this.colors.get(r << 16 | g << 8 | b);
     if (exact !== void 0) return exact;
     let value = r >>> 5 << 5 | g >>> 5 << 2 | b >>> 6;

package/dist/pdf-ast/image.js

@@ -5,7 +5,7 @@ import {
   PdfRetainedReader,
   renderPdfPageToPng,
   renderRetainedPagePixels
-} from "../safe-bash/command-chunks/chunk-YHRESVJ7.js";
+} from "../safe-bash/command-chunks/chunk-4BSD2RGK.js";
 import "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
 import "../safe-bash/command-chunks/chunk-NUGQQDGE.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/pdf-ast/index.js

@@ -257,7 +257,7 @@ import {
   transformNodeStringsAndStreamsSteps,
   transformPathSegment,
   transformPoint
-} from "../safe-bash/command-chunks/chunk-YHRESVJ7.js";
+} from "../safe-bash/command-chunks/chunk-4BSD2RGK.js";
 import "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
 import "../safe-bash/command-chunks/chunk-NUGQQDGE.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/pdf-ast/render/raster.d.ts

@@ -3,7 +3,7 @@ import { type PdfRetainedPixelOptions } from "./retained-page-pixels.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
 import type { PdfRetainedPngOptions } from "./retained-png.js";
 import { type ParsedCosDocument } from "../cos/parser.js";
-import type { PdfDisplayList, PdfPaintOperation, PdfRgbColor, PdfSoftMask } from "../ast.js";
+import type { PdfStoredOperations, PdfDisplayList, PdfPaintOperation, PdfRgbColor, PdfSoftMask } from "../ast.js";
 export interface RgbaBitmap {
     readonly width: number;
     readonly height: number;
@@ -48,10 +48,11 @@ export type PdfRasterWindowOptions = Pick<RenderToPngOptions, "scale" | "dpi" |
  * by the caller. Crop, rotation and anisotropic resampling belong to the driver. */
 export declare function renderDisplayListWindowSteps(displayList: PdfDisplayList, window: PdfCropRect, options?: PdfRasterWindowOptions): Generator<void, RgbaBitmap, void>;
 /** Consume a replayable operation source without collecting a page display list.
- * Opaque output makes a compositing prepass to preserve background quantization.
+ * Opaque output uses stored effect flags or a compositing prepass to preserve
+ * background quantization.
  * Each operation is painted before advancing its source. Individual paths,
  * resources and nested captures still have the evaluator's memory ownership. */
-export declare function renderOperationStreamWindow(page: Pick<PdfDisplayList, "width" | "height" | "origin">, operations: () => AsyncIterable<PdfPaintOperation>, window: PdfCropRect, options?: PdfRasterWindowOptions & {
+export declare function renderOperationStreamWindow(page: Pick<PdfDisplayList, "width" | "height" | "origin">, operations: (() => AsyncIterable<PdfPaintOperation>) | PdfStoredOperations, window: PdfCropRect, options?: PdfRasterWindowOptions & {
     readonly signal?: AbortSignal;
 }): Promise<RgbaBitmap>;
 export declare function renderDisplayListToBitmapSteps(displayList: PdfDisplayList, options?: RenderToPngOptions): Generator<void, RgbaBitmap, void>;

package/dist/pdf-ast/render/retained-page-pixels.d.ts

@@ -15,6 +15,7 @@ export interface PdfRetainedPixels {
 }
 /** Render one bounded window at a time into caller-backed tile storage, then
  * read transformed pixels without allocating the full page or collecting paints.
- * Replays page evaluation per tile; nested captures/resources retain their own
- * admission contracts. Storage is acquired lazily and owned by the iterator. */
+ * With caller-owned image backing, evaluate once and replay stored paints per
+ * tile. Otherwise replay evaluation. Nested captures/resources retain their own
+ * admission contracts. Tile storage is acquired lazily and owned by the iterator. */
 export declare function renderRetainedPagePixels(page: PdfRetainedPage, storage: PdfIndexStorage, options?: PdfRetainedPixelOptions): Promise<PdfRetainedPixels>;

package/dist/safe-bash/command-chunks/{chunk-YHRESVJ7.js → chunk-4BSD2RGK.js}

@@ -26663,6 +26663,71 @@ var PdfStagingStorage = class {
   }
 };
 
+// packages/pdf-ast/src/content/stored-operations.ts
+function operationEffects(operation) {
+  const value = operation.value;
+  let effects = (value.softMask ? 2 : 0) | (value.blendMode && value.blendMode !== "Normal" && value.blendMode !== "Compatible" ? 1 : 0);
+  if (operation.kind === "group") {
+    let children = operation.value.storedOperations?.effects ?? 0;
+    for (const child of operation.value.operations) children |= operationEffects(child);
+    if (operation.value.isolated === false && children & 3) effects |= 4;
+    effects |= children;
+  }
+  return effects;
+}
+var StoredOperationsWriter = class {
+  constructor(storage, signal) {
+    this.storage = storage;
+    this.signal = signal;
+  }
+  storage;
+  signal;
+  first = -1;
+  last = -1;
+  count = 0;
+  effects = 0;
+  async append(operation) {
+    const position = await writeStoredRecord(this.storage, operation, -1, this.signal);
+    const header2 = new Uint8Array(8), view = new DataView(header2.buffer);
+    if (this.last >= 0) {
+      view.setFloat64(0, position, true);
+      await this.storage.write(
+        this.last,
+        header2.subarray(0, 8),
+        this.signal ? { signal: this.signal } : void 0
+      );
+    }
+    this.signal?.throwIfAborted();
+    if (this.first < 0) this.first = position;
+    this.last = position;
+    this.count++;
+    this.effects |= operationEffects(operation);
+  }
+  snapshot() {
+    return {
+      kind: "stored-operations",
+      storage: this.storage,
+      position: this.first,
+      count: this.count,
+      effects: this.effects
+    };
+  }
+};
+async function* readStoredOperations(source, signal) {
+  if (!Number.isSafeInteger(source.count) || source.count < 0)
+    throw new RangeError("Invalid capture count");
+  let position = source.position;
+  for (let record = 0; record < source.count; record++) {
+    const { value, next } = await readStoredRecord(
+      source.storage,
+      position,
+      signal
+    );
+    yield value;
+    position = next;
+  }
+}
+
 // packages/pdf-ast/src/render/raster.ts
 import { PagedStorage as PagedStorage3, IntegerTable as IntegerTable3 } from "@poe-platform/safe-fs/storage";
 
@@ -27077,71 +27142,6 @@ async function* encodeSvgPathDataChunks(input, height, options = {}) {
   if (used) yield buffer.slice(0, used);
 }
 
-// packages/pdf-ast/src/content/stored-operations.ts
-function operationEffects(operation) {
-  const value = operation.value;
-  let effects = (value.softMask ? 2 : 0) | (value.blendMode && value.blendMode !== "Normal" && value.blendMode !== "Compatible" ? 1 : 0);
-  if (operation.kind === "group") {
-    let children = operation.value.storedOperations?.effects ?? 0;
-    for (const child of operation.value.operations) children |= operationEffects(child);
-    if (operation.value.isolated === false && children & 3) effects |= 4;
-    effects |= children;
-  }
-  return effects;
-}
-var StoredOperationsWriter = class {
-  constructor(storage, signal) {
-    this.storage = storage;
-    this.signal = signal;
-  }
-  storage;
-  signal;
-  first = -1;
-  last = -1;
-  count = 0;
-  effects = 0;
-  async append(operation) {
-    const position = await writeStoredRecord(this.storage, operation, -1, this.signal);
-    const header2 = new Uint8Array(8), view = new DataView(header2.buffer);
-    if (this.last >= 0) {
-      view.setFloat64(0, position, true);
-      await this.storage.write(
-        this.last,
-        header2.subarray(0, 8),
-        this.signal ? { signal: this.signal } : void 0
-      );
-    }
-    this.signal?.throwIfAborted();
-    if (this.first < 0) this.first = position;
-    this.last = position;
-    this.count++;
-    this.effects |= operationEffects(operation);
-  }
-  snapshot() {
-    return {
-      kind: "stored-operations",
-      storage: this.storage,
-      position: this.first,
-      count: this.count,
-      effects: this.effects
-    };
-  }
-};
-async function* readStoredOperations(source, signal) {
-  if (!Number.isSafeInteger(source.count) || source.count < 0)
-    throw new RangeError("Invalid capture count");
-  let position = source.position;
-  for (let record = 0; record < source.count; record++) {
-    const { value, next } = await readStoredRecord(
-      source.storage,
-      position,
-      signal
-    );
-    yield value;
-    position = next;
-  }
-}
-
 // packages/pdf-ast/src/content/stored-clips.ts
 var PAGE_BYTES = 4096;
 var RECORD_BYTES2 = 64;
@@ -48242,8 +48242,46 @@ function strokeEdges(contours) {
   } };
 }
 var SUB_OFFSETS_4X4 = [0.125, 0.375, 0.625, 0.875];
+function* cacheSmallEdgesSteps(edges) {
+  if (Array.isArray(edges)) return edges;
+  const cached = [];
+  for (const edge of edges) {
+    if (!edge) {
+      yield;
+      continue;
+    }
+    if (cached.length === 128) return edges;
+    cached.push(edge);
+  }
+  return cached;
+}
 function* computeSubScanlineCountsSteps(edges, scanY, fillRule, deltas, winding, rowCounts) {
   const samples = winding.length;
+  if (Array.isArray(edges)) {
+    const crossings = [];
+    for (const edge of edges) {
+      if (edge.y0 <= scanY && edge.y1 > scanY || edge.y1 <= scanY && edge.y0 > scanY) {
+        crossings.push({ x: edge.x0 + (scanY - edge.y0) / (edge.y1 - edge.y0) * (edge.x1 - edge.x0), direction: edge.y0 < edge.y1 ? 1 : -1 });
+      }
+    }
+    crossings.sort((a, b) => a.x - b.x);
+    let value2 = 0, start = 0;
+    for (const crossing of crossings) {
+      const before = value2;
+      value2 = fillRule === "evenodd" ? 1 - value2 : value2 + crossing.direction;
+      if (before === 0 && value2 !== 0) start = crossing.x;
+      else if (before !== 0 && value2 === 0) {
+        const first = Math.max(0, Math.ceil((start - 0.125) * 4));
+        const end = Math.min(samples, Math.floor((crossing.x - 0.125) * 4) + 1);
+        for (let index2 = first; index2 < end; ) {
+          const count = Math.min(end - index2, 4 - index2 % 4);
+          rowCounts[index2 >>> 2] = rowCounts[index2 >>> 2] + count;
+          index2 += count;
+        }
+      }
+    }
+    return;
+  }
   deltas.fill(0);
   let work = 0;
   for (const edge of edges) {
@@ -48279,6 +48317,7 @@ function* computeSubScanlineCountsSteps(edges, scanY, fillRule, deltas, winding,
   }
 }
 function* fillEdgesScanline4x4Steps(rgba, width, height, edges, color, alpha = 1, fillRule = "nonzero", clipScreen, antialias = true, blendMode, clipMask, groupAlpha) {
+  edges = yield* cacheSmallEdgesSteps(edges);
   let work = 0;
   let minY = Infinity;
   let maxY = -Infinity;
@@ -48318,6 +48357,7 @@ function* fillEdgesScanline4x4Steps(rgba, width, height, edges, color, alpha = 1
   }
 }
 function* fillMaskScanline4x4Steps(mask, width, height, edges, fillRule = "nonzero", intersect = false) {
+  edges = yield* cacheSmallEdgesSteps(edges);
   let work = 0;
   let minY = Infinity;
   let maxY = -Infinity;
@@ -48536,6 +48576,21 @@ function* renderDisplayListLayerSteps(displayList, options, scale, backdrop, win
     if (++work % 16384 === 0) yield;
     if (original.kind === "glyph" && (original.value.renderMode === 3 || !original.value.outline && !original.value.unicode.trim())) continue;
     let operation = original.kind === "glyph" ? { kind: "path", value: glyphPaint(original.value) } : original;
+    let fillEdges;
+    if (operation.kind === "path" && operation.value.fillColor && !operation.value.strokeColor) {
+      const path = operation.value;
+      fillEdges = yield* cacheSmallEdgesSteps(screenFillEdges(path.segments, toScreen, path.storedSegments, images));
+      if (Array.isArray(fillEdges)) {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const edge of fillEdges) {
+          minX = Math.min(minX, edge.x0, edge.x1);
+          minY = Math.min(minY, edge.y0, edge.y1);
+          maxX = Math.max(maxX, edge.x0, edge.x1);
+          maxY = Math.max(maxY, edge.y0, edge.y1);
+        }
+        if (maxX < 0 || maxY < 0 || minX > width || minY > height) continue;
+      }
+    }
     if (operation.kind === "group") {
       const group = operation.value;
       const bitmap = yield* renderDisplayListLayerSteps(
@@ -48637,7 +48692,7 @@ function* renderDisplayListLayerSteps(displayList, options, scale, backdrop, win
     if (operation.kind === "path") {
       const path = operation.value;
       if (path.fillColor) {
-        const edges = screenFillEdges(path.segments, toScreen, path.storedSegments, images);
+        const edges = fillEdges ?? screenFillEdges(path.segments, toScreen, path.storedSegments, images);
         const clipScreen = path.clipRect ? [(path.clipRect[0] - originX) * scale - offsetX, (pageTop - path.clipRect[3]) * scale - offsetY, (path.clipRect[2] - originX) * scale - offsetX, (pageTop - path.clipRect[1]) * scale - offsetY] : void 0;
         yield* fillEdgesScanline4x4Steps(rgba, width, height, edges, path.fillColor, path.fillAlpha ?? 1, path.fillRule ?? "nonzero", clipScreen, original.kind === "glyph" ? aaTxt : aaVec, path.blendMode, clipMask, groupAlpha);
       }
@@ -48797,7 +48852,7 @@ async function renderOperationStreamWindow(page2, operations, window, options =
   const { signal } = options;
   signal?.throwIfAborted();
   async function* cursor() {
-    const source2 = operations()[Symbol.asyncIterator]();
+    const source2 = (typeof operations === "function" ? operations() : readStoredOperations(operations, signal))[Symbol.asyncIterator]();
     let failed2 = false, pulls = 0;
     try {
       while (true) {
@@ -48819,8 +48874,8 @@ async function renderOperationStreamWindow(page2, operations, window, options =
       }
     }
   }
-  const input = { requested: false, next: void 0, compositing: false };
-  if (!options.transparent) for await (const operation of cursor()) {
+  const input = { requested: false, next: void 0, compositing: typeof operations !== "function" && !!(operations.effects & 1) };
+  if (!options.transparent && typeof operations === "function") for await (const operation of cursor()) {
     if (hasCompositingEffects([operation])) {
       input.compositing = true;
       break;
@@ -49671,10 +49726,17 @@ async function renderRetainedPagePixels(page2, storage, options = {}) {
     let source, failed = false;
     async function* tiles() {
       let work = 0;
+      const paints = options.imageStorage ? new StoredOperationsWriter(options.imageStorage, signal) : void 0;
+      if (paints) for await (const event of page2.evaluateSteps(shared, options)) {
+        if (!event.captured) await paints.append(event.operation);
+        if (++work % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+        signal?.throwIfAborted();
+      }
+      const stored = paints?.snapshot();
       for (let y = 0; y < height; y += tileSize) for (let x = 0; x < width; x += tileSize) {
         if (++work % 32 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
         signal?.throwIfAborted();
-        const tile = await renderOperationStreamWindow(geometry, async function* () {
+        const tile = await renderOperationStreamWindow(geometry, stored ?? async function* () {
           for await (const event of page2.evaluateSteps(shared, options)) if (!event.captured) yield event.operation;
         }, { x, y, width: Math.min(tileSize, width - x), height: Math.min(tileSize, height - y) }, { ...options, scale: scaleX });
         yield tile.data;