@poe-platform/safe-bash 0.1.815 → 0.1.816

package/dist/image-ast/index.js

@@ -1890,7 +1890,7 @@ async function openPdfImage(source, fs, directory, signal, options, storage) {
     if (failure) throw failure.error;
   };
   try {
-    document = await PdfRetainedDocument.open(retained, { fs, directory }, { signal, recovery: "repair", compactNumbers: !0, compactKeywords: !0, chunkBytes: 16384, maxNodes: 1 / 0, maxTokenBytes: 1 / 0, maxRecursionDepth: 1 / 0, maxPageTreeDepth: 1 / 0, xref: { arrayStorage: values, storedArrayKeys: ["Index"] }, valueArrays: { dictionaryStorage: values, storedDictionaryKeys: ["Font", "XObject", "Properties"], containerStorage: values, stringStorage: values, storedStringKeys: ["ActualText"], arrayStorage: values, storedArrayKeys: ["Contents", "Annots", "Kids", "Widths", "W", "Differences", "ON", "OFF", "OCGs"], storedArrayPaths: [["ExtGState", "*", "D"]] } });
+    document = await PdfRetainedDocument.open(retained, { fs, directory }, { signal, recovery: "repair", compactNumbers: !0, compactKeywords: !0, chunkBytes: 16384, maxNodes: 1 / 0, maxTokenBytes: 1 / 0, maxRecursionDepth: 1 / 0, maxPageTreeDepth: 1 / 0, xref: { arrayStorage: values, storedArrayKeys: ["Index"] }, valueArrays: { dictionaryStorage: values, deferDictionaryValues: !0, storedDictionaryKeys: ["Font", "XObject", "Properties"], storedDictionaryPaths: [["Resources", "*"]], containerStorage: values, stringStorage: values, storedStringKeys: ["ActualText"], arrayStorage: values, storedArrayKeys: ["Contents", "Annots", "Kids", "Widths", "W", "Differences", "ON", "OFF", "OCGs"], storedArrayPaths: [["ExtGState", "*", "D"]] } });
     let pages = 0, selected;
     for await (let page of document.pages())
       pages++, page.index <= Math.max(0, settings.page ?? 0) && (selected = page);

package/dist/mp4-ast/codecs.d.ts

@@ -1,3 +1,4 @@
+import type { Mp4SampleSteps, Mp4TableRange } from './mp4-sample-source.js';
 import type { Mp4AudioSpecificConfig, Mp4Av1CConfig, Mp4AvcCConfig, Mp4HvcCConfig, Mp4OpusConfig, Mp4VpcCConfig } from "./types.js";
 export interface ParsedH264Sps {
     readonly profileIdc: number;
@@ -24,6 +25,8 @@ export declare function buildAvcC(spsList: readonly Uint8Array[], ppsList: reado
 export declare function parseHvcC(payload: Uint8Array): Mp4HvcCConfig;
 export declare function parseAv1C(payload: Uint8Array): Mp4Av1CConfig;
 export declare function parseVpcC(payload: Uint8Array): Mp4VpcCConfig;
+/** Shared descriptor traversal. Only resident convenience callers retain decoder bytes. */
+export declare function esdsSteps(table: Mp4TableRange, retainDecoderBytes?: boolean): Mp4SampleSteps<Omit<Mp4AudioSpecificConfig, 'rawEsdsBytes'>>;
 export declare function parseEsds(payload: Uint8Array): Mp4AudioSpecificConfig;
 export declare function parseAudioSpecificConfig(asc: Uint8Array): {
     audioObjectType: number;

package/dist/mp4-ast/esds-source.d.ts

@@ -0,0 +1,7 @@
+import { type Mp4SampleScanOptions, type Mp4TableRange } from './mp4-sample-source.js';
+import type { MediaProbeSource, Mp4AudioSpecificConfig } from './types.js';
+export type Mp4AudioSpecificMetadata = Omit<Mp4AudioSpecificConfig, 'decoderSpecificInfo' | 'rawEsdsBytes'>;
+/** Read ES descriptor metadata with one 16 KiB page; skip opaque decoder payloads.
+ * The caller owns source admission and lifetime. No filesystem or codec payload is retained.
+ */
+export declare function probeEsdsSource(source: MediaProbeSource, range: Mp4TableRange, options?: Pick<Mp4SampleScanOptions, 'signal' | 'budget' | 'checkpoint'>): Promise<Mp4AudioSpecificMetadata>;

package/dist/mp4-ast/index.d.ts

@@ -1,6 +1,7 @@
+export { probeEsdsSource, type Mp4AudioSpecificMetadata } from './esds-source.js';
 export * from "./types.js";
 export * from "./binary.js";
-export * from "./codecs.js";
+export { parseH264Sps, parseAvcC, buildAvcC, parseHvcC, parseAv1C, parseVpcC, parseEsds, parseAudioSpecificConfig, buildAudioSpecificConfig, buildEsdsBox, parseDOps, avccToAnnexB, annexBToAvcc, buildH264SpsPps, encodeH264IdrFrame, decodeH264FrameToRgba, createSilentAacFrame, wrapAdtsFrame, parseAdtsStream, type ParsedH264Sps, type H264ReferenceBuffer } from "./codecs.js";
 export * from "./mp4.js";
 export * from "./mp4-source.js";
 export * from "./containers/mkv.js";
@@ -11,3 +12,6 @@ export * from "./containers/streaming.js";
 export { decodeH264Samples } from "./h264.js";
 export { scanMp4SampleTable, type Mp4SampleTables, type Mp4TableRange, type Mp4SampleSpan, type Mp4SampleScanOptions } from "./mp4-sample-source.js";
 export { scanMp4Fragment, type Mp4FragmentDefaults, type Mp4FragmentState, type Mp4FragmentScanOptions } from "./mp4-fragment-source.js";
+export { scanMp4Packets, scanMp4Frames, type Mp4PacketScanOptions } from './mp4-packets-source.js';
+export { scanMp4CodecDescriptions } from './mp4-codec-source.js';
+export type { Mp4CodecMetadata } from './mp4-codec-metadata.js';

package/dist/mp4-ast/mp4-codec-metadata.d.ts

@@ -0,0 +1,48 @@
+import type { MediaCodecDescription, MediaTrackType } from './types.js';
+import type { Mp4AudioSpecificMetadata } from './esds-source.js';
+export type Mp4CodecMetadata = Omit<MediaCodecDescription, 'avcC' | 'hvcC' | 'av1C' | 'vpcC' | 'esds' | 'dOps' | 'extraData' | 'rawStsdEntryBytes'>;
+type MutableMetadata = {
+    -readonly [K in keyof Mp4CodecMetadata]: Mp4CodecMetadata[K];
+};
+export type CodecEntryState = {
+    metadata: MutableMetadata;
+    kind?: 'video' | 'audio';
+    childOffset?: number;
+};
+export type CodecMetadataChild = {
+    type: 'avcC';
+    levelIdc: number;
+    sps?: Uint8Array | undefined;
+} | {
+    type: 'hvcC';
+    generalLevelIdc: number;
+    generalProfileIdc: number;
+    bitDepthLumaMinus8: number;
+} | {
+    type: 'av1C';
+    seqProfile: number;
+    seqLevelIdx0: number;
+    highBitdepth: boolean;
+} | {
+    type: 'vpcC';
+    profile: number;
+    level: number;
+} | {
+    type: 'esds' | 'wave-esds';
+    config: Mp4AudioSpecificMetadata;
+} | {
+    type: 'dOps';
+    inputSampleRate: number;
+    outputChannelCount: number;
+} | {
+    type: 'pasp';
+    sarWidth: number;
+    sarHeight: number;
+};
+/** Scalar interpretation shared by resident entries and caller-owned source ranges. */
+export declare function sampleEntryHeader(formatFourCC: string, body: Uint8Array): CodecEntryState;
+export declare function applyCodecMetadata(state: CodecEntryState, child: CodecMetadataChild): void;
+export declare function finishCodecMetadata(state: CodecEntryState): Mp4CodecMetadata;
+/** Existing general-media PCM naming, shared by resident and source frame probes. */
+export declare function probeSampleFormat(type: MediaTrackType, codecName: string): string | undefined;
+export {};

package/dist/mp4-ast/mp4-codec-source.d.ts

@@ -0,0 +1,8 @@
+import { type Mp4CodecMetadata } from './mp4-codec-metadata.js';
+import { type Mp4TableRange, type Mp4SampleScanOptions } from './mp4-sample-source.js';
+import type { MediaProbeSource } from './types.js';
+/** Enumerate scalar stsd descriptions without retaining entries or opaque codec payloads.
+ * Reads are <=16 KiB; only the first length-bounded H.264 SPS is retained while interpreted.
+ * The caller owns input admission, source lifetime and publication after complete validation.
+ */
+export declare function scanMp4CodecDescriptions(source: MediaProbeSource, range: Mp4TableRange, options?: Pick<Mp4SampleScanOptions, 'signal' | 'budget' | 'checkpoint'>): AsyncGenerator<Mp4CodecMetadata, void>;

package/dist/mp4-ast/mp4-packets-source.d.ts

@@ -0,0 +1,11 @@
+import { type Mp4SampleScanOptions } from './mp4-sample-source.js';
+import { type MediaProbePacket, type MediaProbeFrame, type MediaProbeSource, type MediaResourceLimits } from './types.js';
+export interface Mp4PacketScanOptions extends Omit<Mp4SampleScanOptions, 'type' | 'syncSamples'> {
+    readonly limits?: MediaResourceLimits;
+    /** A fresh caller-owned membership index for each track; its lifetime belongs to the caller. */
+    readonly syncSamples?: (trackIndex: number) => Mp4SampleScanOptions['syncSamples'] | Promise<Mp4SampleScanOptions['syncSamples']>;
+}
+/** Replay packet descriptors without retaining tracks, boxes, table rows or payloads. */
+export declare function scanMp4Packets(source: MediaProbeSource, options?: Mp4PacketScanOptions): AsyncGenerator<MediaProbePacket, void>;
+/** Replay frame descriptors with bounded scalar codec metadata; no media decoding. */
+export declare function scanMp4Frames(source: MediaProbeSource, options?: Mp4PacketScanOptions): AsyncGenerator<MediaProbeFrame, void>;

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

@@ -26,6 +26,8 @@ export interface PdfCosName {
     readonly span?: ByteSpan | undefined;
 }
 export interface PdfCosString {
+    /** Implicit resource-value backing, expanded only when the resource is selected. */
+    readonly deferred?: boolean;
     /** Retained content payload. When present, bytes is empty and the caller owns backing lifetime. */
     readonly storedBytes?: PdfStoredBytes;
     readonly kind: "string";
@@ -35,6 +37,8 @@ export interface PdfCosString {
     readonly span?: ByteSpan | undefined;
 }
 export interface PdfCosArray {
+    /** Implicit resource-value backing, expanded only when the resource is selected. */
+    readonly deferred?: boolean;
     /** Retained elements; items is empty when this descriptor is present. */
     readonly storedItems?: PdfStoredItems;
     readonly kind: "array";
@@ -46,6 +50,8 @@ export interface PdfDictEntry {
     readonly value: PdfCosNode;
 }
 export interface PdfCosDict {
+    /** Implicit resource-value backing, expanded only when the resource is selected. */
+    readonly deferred?: boolean;
     /** Caller-backed ordered entries; entries is empty when this descriptor is present. */
     readonly storedEntries?: PdfStoredItems;
     readonly kind: "dict";

package/dist/pdf-ast/content/evaluator.d.ts

@@ -1,3 +1,4 @@
+import type { PdfResourceRequest } from "./stored-dictionary.js";
 import type { StoredTrueTypeFont } from "../fonts/stored-truetype.js";
 import type { StoredCMap } from "../fonts/stored-cmap.js";
 import { StoredMetadataStack } from "./stored-record.js";
@@ -56,7 +57,7 @@ export interface PdfFunctionReadRequest {
 }
 export declare function evalShadingFunctionToComponents(doc: ParsedCosDocument, fnNode: PdfCosNode | undefined, inputs: number | readonly number[]): number[];
 export declare function evalShadingFunctionSteps(doc: ParsedCosDocument, fnNode: import("../ast.js").PdfCosNode | undefined, inputs: number | readonly number[], sources?: WeakMap<PdfCosStream, PdfFunctionSource>): Generator<PdfFunctionReadRequest, number[], Uint8Array>;
-export type PdfColorRequest = {
+export type PdfColorRequest = PdfResourceRequest | {
     readonly kind: "resolve";
     readonly node: PdfCosNode | undefined;
 } | {
@@ -158,6 +159,7 @@ export type PdfEvaluationRequest = {
     readonly kind: "dictionary-value";
     readonly dict: PdfCosDict;
     readonly key: string;
+    readonly preserveDeferred?: boolean;
 } | {
     readonly kind: "array-reference";
     readonly items: import("../ast.js").PdfStoredItems;
@@ -250,6 +252,7 @@ export type PdfEvaluationRequest = {
     readonly kind: "resolve";
     readonly node: PdfCosNode;
     readonly storeRootArray?: boolean;
+    readonly storeRootDictionary?: boolean;
     readonly arrayPathPrefix?: readonly string[];
 } | {
     readonly kind: "catalog";

package/dist/pdf-ast/content/stored-dictionary.d.ts

@@ -1,10 +1,24 @@
 import { type PdfIndexStorage } from "../cos/object-index.js";
 import type { PdfCosDict, PdfCosNode, PdfDictEntry } from "../ast.js";
 /** Preserve source order and duplicates while keeping only one entry resident. */
+export declare function readRawPdfDictionaryEntries(dict: PdfCosDict, signal?: AbortSignal): AsyncGenerator<PdfDictEntry, void>;
+/** Expand only implicit resource-value backing. Explicit source selectors keep
+ * their descriptors so width/string/resource consumers can stream as before. */
+export declare function materializeResourceValue(node: PdfCosNode, signal?: AbortSignal): Promise<PdfCosNode>;
+/** Visit resources one at a time, expanding only the current definition. */
 export declare function readPdfDictionaryEntries(dict: PdfCosDict, signal?: AbortSignal): AsyncGenerator<PdfDictEntry, void>;
 /** Same last-key-wins semantics as dictGet, without collecting a retained map. */
-export declare function readPdfDictionaryValue(dict: PdfCosDict, key: string, signal?: AbortSignal): Promise<PdfCosNode | undefined>;
+export declare function readPdfDictionaryValue(dict: PdfCosDict, key: string, signal?: AbortSignal, options?: {
+    preserveDeferred?: boolean;
+}): Promise<PdfCosNode | undefined>;
 /** Clone a resource map and fill missing keys from an appearance. Destination
  * duplicates keep their first insertion order and last value; source keys keep
  * their first value. External indexes replace an unbounded resident name map. */
 export declare function mergePdfResourceDictionaries(destination: PdfCosDict, source: PdfCosDict | undefined, indexStorage: PdfIndexStorage, signal?: AbortSignal): Promise<PdfCosDict>;
+/** Lookup only the selected entry of a possibly indirect resource map. */
+export interface PdfResourceRequest {
+    readonly kind: "resource";
+    readonly resources: PdfCosDict;
+    readonly category: string;
+    readonly name: string;
+}

package/dist/pdf-ast/content/stored-record.d.ts

@@ -6,6 +6,12 @@ export declare function readStoredRecord<T>(storage: PdfPixelStorage, position:
     value: T;
     next: number;
 }>;
+/** Compare one string property without decoding the rest of a record.
+ * Paths are caller-defined; input-controlled nesting is skipped with bounded scratch. */
+export declare function storedRecordMatches(storage: PdfPixelStorage, position: number, path: readonly string[], expected: string, signal?: AbortSignal): Promise<{
+    matched: boolean;
+    next: number;
+}>;
 /** Persistent linked frames; only the frame currently being read is resident. */
 export declare class StoredMetadataStack<T> {
     private readonly storage;

package/dist/pdf-ast/cos/retained-writer.d.ts

@@ -25,6 +25,7 @@ export interface PdfSerializedOutputObject {
 }
 export declare function pdfOutputStreamDictionary(value: PdfCosNode, length: number): {
     entries: import("../ast.js").PdfDictEntry[];
+    deferred?: boolean;
     storedEntries?: import("../ast.js").PdfStoredItems;
     kind: "dict";
     span?: import("../ast.js").ByteSpan | undefined;

package/dist/pdf-ast/cos/value-parser.d.ts

@@ -2,8 +2,12 @@ import type { PdfCosNode, PdfCosDict, PdfDictEntry, PdfPixelStorage, PdfStoredIt
 import type { CosToken } from "./lexer.js";
 export interface ValueArrayStorage {
     readonly dictionaryStorage?: PdfPixelStorage;
+    /** Defer unused resource values; all value and container stores must share backing. */
+    readonly deferDictionaryValues?: boolean;
     /** Select resource maps; their entry names are data, not nested map selectors. */
     readonly storedDictionaryKeys?: readonly string[];
+    /** Select dictionary path suffixes; entry names of backed maps remain opaque. */
+    readonly storedDictionaryPaths?: readonly (readonly string[])[];
     readonly storeRootDictionary?: boolean;
     readonly arrayStorage?: PdfPixelStorage;
     /** Back suspended parser containers; selected descriptors must share this storage. */
@@ -35,6 +39,7 @@ export type ValueContainer = ({
     key?: PdfDictEntry["key"];
 }) & {
     path: readonly (string | null)[];
+    deferred?: boolean;
 };
 export type ValueWork<T> = Generator<void | "token" | PdfCosDict | {
     kind: "dictionary-append";

package/dist/pdf-ast/edit/retained-graph.d.ts

@@ -24,6 +24,7 @@ export type EditRetainedDocumentOptions = Pick<SaveRetainedDocumentOptions, "lin
     readonly attachmentPageIndex?: number;
     readonly stamps?: Iterable<RetainedStampInput> | AsyncIterable<RetainedStampInput>;
     readonly generateAppearances?: boolean;
+    readonly flattenForms?: boolean;
     readonly flattenAnnotations?: "all" | "print" | "screen";
     readonly flattenRotation?: boolean;
     readonly externalizeInlineImages?: RetainedInlineImageOptions;

package/dist/pdf-ast/edit/retained-page-copy.d.ts

@@ -1,3 +1,4 @@
+import { type PdfRect } from "../ast.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
 import { PdfRetainedDocument } from "../retained-document.js";
 export interface CopyRetainedPageOptions {
@@ -6,6 +7,15 @@ export interface CopyRetainedPageOptions {
     /** Override a source page's rotation before cloning its indirect values.
      * Return undefined to preserve the source; angles must be quarter turns. */
     readonly pageRotation?: (document: PdfRetainedDocument, index: number) => number | undefined | Promise<number | undefined>;
+    /** Override copied page boxes after cloning. Source geometry is unrotated;
+     * indices refer to the source document. Returning undefined preserves boxes. */
+    readonly pageBoxes?: (size: {
+        readonly width: number;
+        readonly height: number;
+    }, index: number) => {
+        readonly mediaBox?: PdfRect;
+        readonly cropBox?: PdfRect;
+    } | undefined;
     /** Override copied metadata; an empty object keeps only the default producer. */
     readonly metadata?: Readonly<Record<string, string>>;
     /** Merge all source embedded files; the first occurrence of each name wins. */

package/dist/pdf-ast/extract/images.d.ts

@@ -1,3 +1,4 @@
+import type { PdfResourceRequest } from "../content/stored-dictionary.js";
 import { type CalibratedColorSpace } from "../content/calibrated-color.js";
 import { type PdfCosDict, type PdfCosNode, type PdfCosStream } from "../ast.js";
 import { type PdfFunctionSource } from "../content/evaluator.js";
@@ -48,7 +49,7 @@ export interface ResolvedColorSpace {
     readonly calibrated?: CalibratedColorSpace | undefined;
     readonly alternateCalibrated?: CalibratedColorSpace | undefined;
 }
-export type PdfImageColorRequest = {
+export type PdfImageColorRequest = PdfResourceRequest | {
     kind: "resolve";
     node: PdfCosNode | undefined;
 } | {

package/dist/pdf-ast/fonts/resolve.d.ts

@@ -41,6 +41,7 @@ export type FontResolutionRequest = PdfDictionaryEntryRequest | {
     node: PdfCosNode | undefined;
     storeRootArray?: boolean;
     storeRootDictionary?: boolean;
+    arrayPathPrefix?: readonly string[];
 } | {
     kind: "decode";
     stream: PdfCosStream;

package/dist/pdf-ast/index.d.ts

@@ -46,6 +46,8 @@ export * from "./source.js";
 export * from "./staged-outputs.js";
 export type { PdfRetainedFont, PdfFontSelection } from "./extract/retained-fonts.js";
 export { encodePortableBitmapChunks, type PdfPortableBitmapFormat, type PdfPortableBitmapOptions } from "./render/portable-bitmap-stream.js";
+export { encodeSvgPathDataChunks, type PdfSvgPathOptions } from "./render/svg-path-stream.js";
+export { encodeSvgImageChunks } from "./render/svg-image-stream.js";
 export { encodeRetainedPng, type PdfRetainedPngOptions } from "./render/retained-png.js";
 export type { PdfRetainedImage, PdfImageSelection } from "./extract/retained-images.js";
 export { decodeRetainedSampleRows, type PdfSampleRowOptions } from "./extract/retained-samples.js";