@lexmata/micropdf 0.4.0

package/dist/buffer.d.ts

@@ -0,0 +1,572 @@
+/**
+ * Buffer - Dynamic byte array wrapper for PDF data manipulation
+ *
+ * This module provides a flexible buffer implementation for working with binary PDF data.
+ * Buffers are used throughout the library for reading, writing, and manipulating
+ * PDF content, streams, and binary resources.
+ *
+ * This implementation mirrors the Rust `fitz::buffer::Buffer` for 100% API compatibility
+ * and wraps Node.js Buffer for efficient memory management.
+ *
+ * @module buffer
+ * @example
+ * ```typescript
+ * import { Buffer } from 'micropdf';
+ *
+ * // Create from string
+ * const buf = Buffer.fromString('Hello, PDF!');
+ *
+ * // Append data
+ * buf.append(Buffer.fromString(' More text.'));
+ *
+ * // Get as string
+ * console.log(buf.toString()); // "Hello, PDF! More text."
+ *
+ * // Get raw bytes
+ * const bytes = buf.toUint8Array();
+ *
+ * // Get size
+ * console.log(buf.length); // 24
+ * ```
+ */
+import { type BufferLike, isBufferLike } from './types.js';
+export { BufferLike, isBufferLike };
+/**
+ * A dynamic byte buffer for PDF data manipulation.
+ *
+ * Buffer provides efficient storage and manipulation of binary data. It's used
+ * throughout the library for PDF streams, content, images, and other binary resources.
+ *
+ * **Key Features:**
+ * - Dynamic resizing as data is appended
+ * - Zero-copy conversion to/from Node.js Buffer
+ * - String encoding/decoding support
+ * - Slice and copy operations
+ * - Compatible with standard Node.js Buffer operations
+ *
+ * Mirrors the Rust `Buffer` implementation with `bytes` crate semantics.
+ *
+ * @class Buffer
+ * @example
+ * ```typescript
+ * // Create empty buffer
+ * const buf1 = Buffer.create();
+ *
+ * // Create from string
+ * const buf2 = Buffer.fromString('Hello');
+ *
+ * // Create from bytes
+ * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+ * const buf3 = Buffer.fromUint8Array(bytes);
+ *
+ * // Append data
+ * buf1.append(buf2);
+ * buf1.append(Buffer.fromString(' World!'));
+ *
+ * // Extract data
+ * console.log(buf1.toString()); // "Hello World!"
+ * console.log(buf1.length); // 12
+ *
+ * // Slice
+ * const hello = buf1.slice(0, 5);
+ * console.log(hello.toString()); // "Hello"
+ *
+ * // Clear
+ * buf1.clear();
+ * console.log(buf1.length); // 0
+ * ```
+ */
+export declare class Buffer {
+    /**
+     * The underlying Node.js Buffer containing the data.
+     * @private
+     * @type {globalThis.Buffer}
+     */
+    private _data;
+    /**
+     * Creates a new Buffer instance.
+     *
+     * **Note**: Use static factory methods instead of calling this constructor directly.
+     *
+     * @private
+     * @param {globalThis.Buffer} data - The underlying Node.js Buffer
+     */
+    private constructor();
+    /**
+     * Creates a new empty buffer with optional initial capacity.
+     *
+     * The capacity parameter is a hint for initial memory allocation. The buffer
+     * will automatically grow as needed when data is appended.
+     *
+     * @static
+     * @param {number} [capacity=0] - Initial capacity in bytes (optional)
+     * @returns {Buffer} A new empty buffer
+     * @example
+     * ```typescript
+     * // Create empty buffer
+     * const buf1 = Buffer.create();
+     *
+     * // Create with initial capacity
+     * const buf2 = Buffer.create(1024); // Reserve 1KB
+     * ```
+     */
+    static create(capacity?: number): Buffer;
+    /**
+     * Creates a buffer from a Node.js Buffer (zero-copy).
+     *
+     * This operation wraps the existing Buffer without copying data, making it
+     * very efficient. Modifications to the original Buffer will be visible in
+     * the MicroPDF Buffer and vice versa.
+     *
+     * @static
+     * @param {globalThis.Buffer} data - The Node.js Buffer to wrap
+     * @returns {Buffer} A new Buffer wrapping the provided data
+     * @example
+     * ```typescript
+     * const nodeBuffer = Buffer.from('Hello');
+     * const pdfBuffer = Buffer.fromBuffer(nodeBuffer);
+     * console.log(pdfBuffer.toString()); // "Hello"
+     * ```
+     */
+    static fromBuffer(data: globalThis.Buffer): Buffer;
+    /**
+     * Creates a buffer from a Uint8Array.
+     *
+     * The data is copied into a new Node.js Buffer.
+     *
+     * @static
+     * @param {Uint8Array} data - The byte array to copy
+     * @returns {Buffer} A new Buffer containing the data
+     * @example
+     * ```typescript
+     * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+     * const buf = Buffer.fromUint8Array(bytes);
+     * console.log(buf.toString()); // "Hello"
+     * ```
+     */
+    static fromUint8Array(data: Uint8Array): Buffer;
+    /**
+     * Creates a buffer from an ArrayBuffer.
+     *
+     * Useful for working with binary data from various Web APIs and file operations.
+     *
+     * @static
+     * @param {ArrayBuffer} data - The ArrayBuffer to convert
+     * @returns {Buffer} A new Buffer containing the data
+     * @example
+     * ```typescript
+     * const arrayBuffer = new ArrayBuffer(5);
+     * const view = new Uint8Array(arrayBuffer);
+     * view.set([72, 101, 108, 108, 111]);
+     * const buf = Buffer.fromArrayBuffer(arrayBuffer);
+     * console.log(buf.toString()); // "Hello"
+     * ```
+     */
+    static fromArrayBuffer(data: ArrayBuffer): Buffer;
+    /**
+     * Creates a buffer from a string with specified encoding.
+     *
+     * Supports all standard Node.js buffer encodings including UTF-8, ASCII,
+     * Base64, Hex, and more.
+     *
+     * @static
+     * @param {string} str - The string to encode
+     * @param {BufferEncoding} [encoding='utf-8'] - The character encoding to use
+     * @returns {Buffer} A new Buffer containing the encoded string
+     * @example
+     * ```typescript
+     * // UTF-8 (default)
+     * const buf1 = Buffer.fromString('Hello');
+     *
+     * // ASCII
+     * const buf2 = Buffer.fromString('Hello', 'ascii');
+     *
+     * // Base64
+     * const buf3 = Buffer.fromString('SGVsbG8=', 'base64');
+     * console.log(buf3.toString()); // "Hello"
+     *
+     * // Hex
+     * const buf4 = Buffer.fromString('48656c6c6f', 'hex');
+     * console.log(buf4.toString()); // "Hello"
+     * ```
+     */
+    static fromString(str: string, encoding?: BufferEncoding): Buffer;
+    /**
+     * Create a buffer from base64-encoded data
+     */
+    static fromBase64(data: string): Buffer;
+    /**
+     * Create a buffer from hex-encoded data
+     */
+    static fromHex(data: string): Buffer;
+    /**
+     * Create a buffer from various input types
+     */
+    static from(data: BufferLike): Buffer;
+    /**
+     * Get the length of the buffer in bytes
+     */
+    get length(): number;
+    /**
+     * Check if the buffer is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get the buffer capacity
+     */
+    get capacity(): number;
+    /**
+     * Get the buffer data as a Node.js Buffer
+     */
+    toNodeBuffer(): globalThis.Buffer;
+    /**
+     * Get the buffer data as a Uint8Array (copy)
+     *
+     * Creates a new Uint8Array with a copy of the buffer data.
+     * Use `toUint8ArrayView()` for a zero-copy view if you don't need to modify it.
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get a zero-copy Uint8Array view of the buffer data
+     *
+     * WARNING: This returns a view, not a copy. Modifying the view will
+     * modify the original buffer. The view becomes invalid if the buffer
+     * is modified (append, resize, etc.) or freed.
+     *
+     * Use this for read-only operations where performance matters.
+     */
+    toUint8ArrayView(): Uint8Array;
+    /**
+     * Get the buffer data as an ArrayBuffer
+     */
+    toArrayBuffer(): ArrayBuffer;
+    /**
+     * Get the buffer data as a string
+     *
+     * For UTF-8 encoding with buffers larger than 1KB, uses TextDecoder
+     * which is more efficient than Node's toString() for large strings.
+     */
+    toString(encoding?: BufferEncoding): string;
+    /**
+     * Get the buffer data as base64-encoded string
+     */
+    toBase64(): string;
+    /**
+     * Get the buffer data as hex-encoded string
+     */
+    toHex(): string;
+    /**
+     * Get the buffer data as a number array
+     */
+    toArray(): number[];
+    /**
+     * Resize the buffer to the specified size
+     */
+    resize(newLength: number): this;
+    /**
+     * Clear all data from the buffer
+     */
+    clear(): this;
+    /**
+     * Append data to the buffer
+     */
+    append(data: BufferLike): this;
+    /**
+     * Append a single byte to the buffer
+     */
+    appendByte(byte: number): this;
+    /**
+     * Append a string to the buffer (UTF-8 encoded)
+     */
+    appendString(str: string, encoding?: BufferEncoding): this;
+    /**
+     * Append a 16-bit integer in little-endian format
+     */
+    appendInt16LE(value: number): this;
+    /**
+     * Append a 32-bit integer in little-endian format
+     */
+    appendInt32LE(value: number): this;
+    /**
+     * Append a 16-bit integer in big-endian format
+     */
+    appendInt16BE(value: number): this;
+    /**
+     * Append a 32-bit integer in big-endian format
+     */
+    appendInt32BE(value: number): this;
+    /**
+     * Append a 16-bit unsigned integer in little-endian format
+     */
+    appendUInt16LE(value: number): this;
+    /**
+     * Append a 32-bit unsigned integer in little-endian format
+     */
+    appendUInt32LE(value: number): this;
+    /**
+     * Append a 16-bit unsigned integer in big-endian format
+     */
+    appendUInt16BE(value: number): this;
+    /**
+     * Append a 32-bit unsigned integer in big-endian format
+     */
+    appendUInt32BE(value: number): this;
+    /**
+     * Append a float in little-endian format
+     */
+    appendFloatLE(value: number): this;
+    /**
+     * Append a float in big-endian format
+     */
+    appendFloatBE(value: number): this;
+    /**
+     * Append a double in little-endian format
+     */
+    appendDoubleLE(value: number): this;
+    /**
+     * Append a double in big-endian format
+     */
+    appendDoubleBE(value: number): this;
+    /**
+     * Get a slice of the buffer
+     */
+    slice(start: number, end?: number): Buffer;
+    /**
+     * Split the buffer at the given index
+     */
+    splitAt(mid: number): [Buffer, Buffer];
+    /**
+     * Get a byte at the specified index
+     */
+    at(index: number): number | undefined;
+    /**
+     * Set a byte at the specified index
+     */
+    set(index: number, value: number): this;
+    /**
+     * Read a 16-bit unsigned integer at offset (big-endian)
+     */
+    readUInt16BE(offset: number): number;
+    /**
+     * Read a 32-bit unsigned integer at offset (big-endian)
+     */
+    readUInt32BE(offset: number): number;
+    /**
+     * Read a 16-bit unsigned integer at offset (little-endian)
+     */
+    readUInt16LE(offset: number): number;
+    /**
+     * Read a 32-bit unsigned integer at offset (little-endian)
+     */
+    readUInt32LE(offset: number): number;
+    /**
+     * Read a 16-bit signed integer at offset (big-endian)
+     */
+    readInt16BE(offset: number): number;
+    /**
+     * Read a 32-bit signed integer at offset (big-endian)
+     */
+    readInt32BE(offset: number): number;
+    /**
+     * Read a 16-bit signed integer at offset (little-endian)
+     */
+    readInt16LE(offset: number): number;
+    /**
+     * Read a 32-bit signed integer at offset (little-endian)
+     */
+    readInt32LE(offset: number): number;
+    /**
+     * Read a float at offset (big-endian)
+     */
+    readFloatBE(offset: number): number;
+    /**
+     * Read a float at offset (little-endian)
+     */
+    readFloatLE(offset: number): number;
+    /**
+     * Read a double at offset (big-endian)
+     */
+    readDoubleBE(offset: number): number;
+    /**
+     * Read a double at offset (little-endian)
+     */
+    readDoubleLE(offset: number): number;
+    /**
+     * Compute MD5 digest of buffer contents
+     */
+    md5Digest(): Uint8Array;
+    /**
+     * Compute SHA-256 digest of buffer contents
+     */
+    sha256Digest(): Uint8Array;
+    /**
+     * Check equality with another buffer
+     */
+    equals(other: Buffer | BufferLike): boolean;
+    /**
+     * Compare with another buffer
+     * Returns -1, 0, or 1
+     */
+    compare(other: Buffer | BufferLike): number;
+    /**
+     * Find index of a byte or pattern
+     */
+    indexOf(value: number | BufferLike, start?: number): number;
+    /**
+     * Check if buffer includes a byte or pattern
+     */
+    includes(value: number | BufferLike, start?: number): boolean;
+    /**
+     * Iterate over bytes
+     */
+    [Symbol.iterator](): Iterator<number>;
+    /**
+     * Get entries iterator
+     */
+    entries(): IterableIterator<[number, number]>;
+    /**
+     * Get keys iterator
+     */
+    keys(): IterableIterator<number>;
+    /**
+     * Get values iterator
+     */
+    values(): IterableIterator<number>;
+    /**
+     * Create a copy of the buffer
+     */
+    clone(): Buffer;
+}
+/**
+ * A reader for consuming buffer contents
+ */
+export declare class BufferReader {
+    private readonly data;
+    private position;
+    constructor(buffer: Buffer | BufferLike);
+    /**
+     * Get the current read position
+     */
+    get pos(): number;
+    /**
+     * Get the number of bytes remaining
+     */
+    get remaining(): number;
+    /**
+     * Check if we've reached the end
+     */
+    get isEof(): boolean;
+    /**
+     * Peek at the next byte without consuming it
+     */
+    peek(): number | null;
+    /**
+     * Read a single byte
+     */
+    readByte(): number | null;
+    /**
+     * Read bytes into a buffer
+     */
+    read(length: number): Uint8Array;
+    /**
+     * Read exactly n bytes, or throw if not enough data
+     */
+    readExact(length: number): Uint8Array;
+    /**
+     * Read a 16-bit unsigned integer (big-endian)
+     */
+    readUInt16BE(): number;
+    /**
+     * Read a 32-bit unsigned integer (big-endian)
+     */
+    readUInt32BE(): number;
+    /**
+     * Read a 16-bit unsigned integer (little-endian)
+     */
+    readUInt16LE(): number;
+    /**
+     * Read a 32-bit unsigned integer (little-endian)
+     */
+    readUInt32LE(): number;
+    /**
+     * Read a 24-bit unsigned integer (big-endian)
+     */
+    readUInt24BE(): number;
+    /**
+     * Seek to a position
+     */
+    seek(pos: number): this;
+    /**
+     * Skip n bytes
+     */
+    skip(n: number): this;
+    /**
+     * Read a line (up to and including newline)
+     */
+    readLine(): Uint8Array | null;
+    /**
+     * Read a line as string
+     */
+    readLineString(encoding?: BufferEncoding): string | null;
+}
+/**
+ * A writer that accumulates data into a buffer
+ */
+export declare class BufferWriter {
+    private data;
+    private position;
+    constructor(capacity?: number);
+    /**
+     * Get the current length
+     */
+    get length(): number;
+    /**
+     * Check if empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Ensure capacity
+     */
+    private ensureCapacity;
+    /**
+     * Write bytes
+     */
+    write(data: BufferLike): this;
+    /**
+     * Write a single byte
+     */
+    writeByte(value: number): this;
+    /**
+     * Write a 16-bit unsigned integer (big-endian)
+     */
+    writeUInt16BE(value: number): this;
+    /**
+     * Write a 32-bit unsigned integer (big-endian)
+     */
+    writeUInt32BE(value: number): this;
+    /**
+     * Write a 16-bit unsigned integer (little-endian)
+     */
+    writeUInt16LE(value: number): this;
+    /**
+     * Write a 32-bit unsigned integer (little-endian)
+     */
+    writeUInt32LE(value: number): this;
+    /**
+     * Write a string
+     */
+    writeString(str: string, encoding?: BufferEncoding): this;
+    /**
+     * Get the accumulated data as a slice
+     */
+    toSlice(): Uint8Array;
+    /**
+     * Convert to Buffer
+     */
+    toBuffer(): Buffer;
+    /**
+     * Clear the writer
+     */
+    clear(): this;
+}
+//# sourceMappingURL=buffer.d.ts.map

package/dist/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../src/buffer.ts"],"names":[],"mappings":"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"}