@poe-platform/safe-bash 0.1.814 → 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";
@@ -10,3 +11,7 @@ export * from "./containers/adapters.js";
 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-fragment-source.d.ts

@@ -0,0 +1,35 @@
+import { type Mp4BoxScanOptions } from './mp4-source.js';
+import { type Mp4SampleSteps, type Mp4SampleSpan, type Mp4SampleScanOptions, type Mp4TableRange } from './mp4-sample-source.js';
+import type { MediaProbeSource } from './types.js';
+export interface Mp4FragmentDefaults {
+    readonly defaultSampleDescriptionIndex: number;
+    readonly defaultSampleDuration: number;
+    readonly defaultSampleSize: number;
+    readonly defaultSampleFlags: number;
+}
+export interface Mp4FragmentState {
+    readonly dts: number;
+    readonly sampleCount: number;
+}
+export interface Mp4FragmentScanOptions extends Omit<Mp4SampleScanOptions, 'syncSamples'> {
+    readonly trackId: number;
+    readonly moofOffset: number;
+    readonly defaults: Mp4FragmentDefaults;
+    /** Carry the end of the last retained sample and count across classic tables and fragments. */
+    readonly state?: Mp4FragmentState;
+}
+interface FragmentHeader extends Mp4FragmentDefaults {
+    readonly baseDataOffset: number;
+}
+/** Shared header interpretation, including the resident reader's truncated-field zeros. */
+export declare function mp4FragmentHeader(bytes: Uint8Array, options: Mp4FragmentScanOptions): FragmentHeader | undefined;
+export declare function mp4FragmentTime(bytes: Uint8Array, fallback: number): number;
+/** Traverse a single run without retaining its rows or payload. */
+export declare function mp4FragmentRunSteps(size: number, table: Mp4TableRange, header: FragmentHeader, state: Mp4FragmentState, options: Mp4SampleScanOptions): Mp4SampleSteps<Mp4FragmentState>;
+/**
+ * Replay one traf's children. Two sibling scans keep headers independent of box order
+ * without collecting runs. Returns carried state even when tfdt has no samples.
+ * Source ownership, trex lookup, track iteration and staged publication belong to the caller.
+ */
+export declare function scanMp4Fragment(source: MediaProbeSource, range: Pick<Mp4BoxScanOptions, 'offset' | 'length' | 'depth'>, options: Mp4FragmentScanOptions): AsyncGenerator<Mp4SampleSpan, Mp4FragmentState>;
+export {};

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/mp4-ast/mp4-sample-source.d.ts

@@ -40,13 +40,16 @@ type Step = {
     kind: 'sample';
     sample: Mp4SampleSpan;
 };
-type Steps<T> = Generator<Step, T, Uint8Array | boolean | undefined>;
+export type Mp4SampleSteps<T> = Generator<Step, T, Uint8Array | boolean | undefined>;
 /** One traversal shared by the resident parser and asynchronous caller ranges. */
-export declare function mp4SampleTableSteps(size: number, tables: Mp4SampleTables, options?: Pick<Mp4SampleScanOptions, 'type' | 'budget'>): Steps<void>;
+export declare function mp4SampleTableSteps(size: number, tables: Mp4SampleTables, options?: Pick<Mp4SampleScanOptions, 'type' | 'budget'>): Mp4SampleSteps<void>;
 /**
  * Replay a classic (non-fragmented) stbl without materializing tables or payloads.
  * At most seven 16 KiB table pages are cached; sync membership belongs to the caller.
  * Input/index lifetime, publication after validation, and fragmented runs remain caller-owned.
  */
 export declare function scanMp4SampleTable(source: MediaProbeSource, tables: Mp4SampleTables, options?: Mp4SampleScanOptions): AsyncGenerator<Mp4SampleSpan, void>;
+export declare function readMp4SampleRange(source: MediaProbeSource, offset: number, length: number, options: Mp4SampleScanOptions): Promise<Uint8Array>;
+/** Drive the shared sample traversal with bounded owned table pages. */
+export declare function consumeMp4SampleSteps<T>(source: MediaProbeSource, steps: Mp4SampleSteps<T>, options: Mp4SampleScanOptions): AsyncGenerator<Mp4SampleSpan, T>;
 export {};

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

@@ -375,6 +375,15 @@ export type MediaProbeRecords = Omit<MediaProbeResult, "packets" | "frames"> & {
     readonly packets?: Iterable<MediaProbePacket> | undefined;
     readonly frames?: Iterable<MediaProbeFrame> | undefined;
 };
+/** Caller-backed, one-shot record sources. Consume before retiring the input source. */
+export type MediaProbeSourceRecords = Omit<MediaProbeResult, "streams" | "chapters" | "packets" | "frames"> & {
+    /** Retire plugin-owned backing after all requested records, including unselected sections. */
+    readonly close?: () => Promise<void>;
+    readonly streams: Iterable<MediaProbeStream> | AsyncIterable<MediaProbeStream>;
+    readonly chapters: Iterable<MediaProbeResult["chapters"][number]> | AsyncIterable<MediaProbeResult["chapters"][number]>;
+    readonly packets?: Iterable<MediaProbePacket> | AsyncIterable<MediaProbePacket> | undefined;
+    readonly frames?: Iterable<MediaProbeFrame> | AsyncIterable<MediaProbeFrame> | undefined;
+};
 export interface MediaSourceProbeOptions extends ParseMediaOptions {
     readonly signal?: AbortSignal;
     readonly showPackets?: boolean;
@@ -463,6 +472,8 @@ export interface MediaAstPlugin {
         showPackets?: boolean;
         showFrames?: boolean;
     }): MediaProbeResult;
+    /** Lazy caller-backed records; source remains alive through complete enumeration. */
+    probeRecords?(source: MediaProbeSource, options?: MediaSourceProbeOptions): Promise<MediaProbeSourceRecords>;
     /** Optional bounded range path; packet/frame descriptors may be lazy iterables. */
     probeMetadata?(source: MediaProbeSource, options?: MediaSourceProbeOptions): Promise<MediaProbeRecords>;
     /** Optional bounded sequential metadata path; consumes input through EOF. */

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/object-reader.d.ts

@@ -17,7 +17,7 @@ export interface PdfObjectReaderOptions extends Omit<ParseCosRangeOptions, "reso
     /** Aggregate decoded object-stream data and header tape bytes. */
     readonly maxStagingBytes?: number;
     readonly maxObjectStreamMembers?: number;
-    /** Live ancestor-index staging for each indirect length traversal. */
+    /** Live ancestor-index staging for each indirect reference traversal. */
     readonly maxTraversalStagingBytes?: number;
 }
 /** Raw indexed COS access. The source and xref index remain caller-owned.
@@ -31,7 +31,7 @@ export declare class PdfObjectReader {
     private readonly storage;
     private readonly streams;
     private readonly backingFailures;
-    private readonly lengthPaths;
+    private readonly referencePaths;
     private readonly repairedOffsets;
     private readonly options;
     private readonly capacity;
@@ -45,6 +45,7 @@ export declare class PdfObjectReader {
     /** Decode one retained stream under consumer backpressure. The caller owns
      * the source and must keep it open until iteration finishes. */
     decodeStream(objectNumber: number, generationNumber?: number, options?: Pick<PdfStreamDecodeOptions, "stopBeforeImageCodec" | "raw">): AsyncGenerator<Uint8Array, void, void>;
+    private resolveStreamDictionary;
     /** A stream-valued /Length is invalid as a length, but its references still
      * need cycle, admission and backing-error validation. Walk those discarded
      * values in source order instead of retaining one parser and AST per link. */

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/forms.d.ts

@@ -16,5 +16,6 @@ export declare function getDocumentFormFields(doc: ParsedCosDocument): PdfFormFi
 export declare function setDocumentFormField(doc: ParsedCosDocument, fieldName: string, value: string | boolean): void;
 export declare function generateDocumentFormAppearancesSteps(doc: ParsedCosDocument): Generator<void, void, void>;
 export declare function generateDocumentFormAppearances(doc: ParsedCosDocument): void;
+export declare function decodeFormDataEntities(text: string): string;
 export declare function parseFormDataBytes(bytes: Uint8Array): Map<string, string | boolean>;
 export declare function flattenDocumentFormFields(doc: ParsedCosDocument): void;

package/dist/pdf-ast/edit/retained-form-data.d.ts

@@ -0,0 +1,9 @@
+import type { PdfIndexStorage } from "../cos/object-index.js";
+import type { PdfFileSource } from "../source.js";
+import type { RetainedFormUpdate } from "./retained-form-appearances.js";
+/** Consume a retained form-data source and yield final fields in first-seen
+ * order. Input text, FDF tokens, names and overwrite state use caller storage.
+ * Individual field names/values and lexical tokens remain resident. */
+export declare function parseRetainedFormData(source: PdfFileSource, storage: PdfIndexStorage, options?: {
+    readonly signal?: AbortSignal;
+}): AsyncGenerator<RetainedFormUpdate>;

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";
@@ -79,3 +81,4 @@ export { replaceRetainedPdfName } from "./edit/retained-name-replacement.js";
 export { QpdfJsonValues } from "./cos/qpdf-json-values.js";
 export { QpdfJsonDocument, type ApplyQpdfJsonOptions } from "./cos/qpdf-json-document.js";
 export type { RetainedAppendAttachment } from "./edit/retained-append-attachments.js";
+export { parseRetainedFormData } from "./edit/retained-form-data.js";