@syncfusion/ej2-pdf 1.0.23 → 23.1.36

package/src/pdf/core/annotations/index.d.ts

@@ -0,0 +1,4 @@
+export * from './annotation-collection';
+export * from './annotation';
+export * from './pdf-appearance';
+export * from './pdf-paddings';

package/src/pdf/core/annotations/index.js

@@ -0,0 +1,4 @@
+export * from './annotation-collection';
+export * from './annotation';
+export * from './pdf-appearance';
+export * from './pdf-paddings';

package/src/pdf/core/annotations/pdf-appearance.d.ts

@@ -0,0 +1,102 @@
+import { PdfTemplate } from './../graphics/pdf-template';
+import { PdfAnnotation } from './annotation';
+/**
+ * `PdfAppearance` class represents the appearance of the annotation.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Get the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new rubber stamp annotation
+ * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+ * // Get the appearance of the annotation
+ * let appearance: PdfAppearance = annotation.appearance;
+ * // Create new image object by using JPEG image data as Base64 string format
+ * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+ * // Draw the image as the custom appearance for the annotation
+ * appearance.normal.graphics.drawImage(image, 0, 0, 100, 50);
+ * // Add annotation to the page
+ * page.annotations.add(annotation);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare class PdfAppearance {
+    _annotations: PdfAnnotation;
+    _bounds: number[];
+    private _crossReference;
+    private _templateNormal;
+    private _dictionary;
+    /**
+     * Initializes a new instance of the `PdfAppearance` class.
+     *
+     * @param {PdfAnnotation} annot - The annotation.
+     * @param {number[]} bounds - The bounds.
+     * @private
+     */
+    constructor(annot: PdfAnnotation, bounds: number[]);
+    /**
+     * Get the normal appearance of the annotation.
+     *
+     * @returns {PdfTemplate} Returns the normal appearance of the annotation.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Get the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new rubber stamp annotation
+     * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+     * // Get the appearance of the annotation
+     * let appearance: PdfAppearance = annotation.appearance;
+     * // Access the normal template of the appearance
+     * let template: PdfTemplate = appearance.normal;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * // Draw the image as the custom appearance for the annotation
+     * template.graphics.drawImage(image, 0, 0, 100, 50);
+     * // Add annotation to the page
+     * page.annotations.add(annotation);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    /**
+    * Set the normal appearance of the annotation.
+    *
+    * @param {PdfTemplate} value The normal appearance of the annotation.
+    * ```typescript
+    * // Load an existing PDF document
+    * let document: PdfDocument = new PdfDocument(data, password);
+    * // Get the first page
+    * let page: PdfPage = document.getPage(0) as PdfPage;
+    * // Create a new rubber stamp annotation
+    * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+    * // Get the appearance of the annotation
+    * let appearance: PdfAppearance = annotation.appearance;
+    * // Access the normal template of the appearance
+    * let template: PdfTemplate = appearance.normal;
+    * // Create new image object by using JPEG image data as Base64 string format
+    * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+    * // Draw the image as the custom appearance for the annotation
+    * template.graphics.drawImage(image, 0, 0, 100, 50);
+    * // Add annotation to the page
+    * page.annotations.add(annotation);
+    * // Add a new rubber stamp annotation to the page
+    * const annotation2: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 200, 100, 50);
+    * // Set the normal appearance of the annotation
+    * annotation2.appearance.normal = annotation.appearance.normal;
+    * // Add annotation to the page
+    * page.annotations.add(annotation2);
+    * // Save the document
+    * document.save('output.pdf');
+    * // Destroy the document
+    * document.destroy();
+    * ```
+    */
+    normal: PdfTemplate;
+    _initialize(): void;
+}

package/src/pdf/core/annotations/pdf-appearance.js

@@ -0,0 +1,124 @@
+import { _PdfDictionary } from './../pdf-primitives';
+import { PdfTemplate } from './../graphics/pdf-template';
+/**
+ * `PdfAppearance` class represents the appearance of the annotation.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Get the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new rubber stamp annotation
+ * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+ * // Get the appearance of the annotation
+ * let appearance: PdfAppearance = annotation.appearance;
+ * // Create new image object by using JPEG image data as Base64 string format
+ * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+ * // Draw the image as the custom appearance for the annotation
+ * appearance.normal.graphics.drawImage(image, 0, 0, 100, 50);
+ * // Add annotation to the page
+ * page.annotations.add(annotation);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfAppearance = /** @class */ (function () {
+    /**
+     * Initializes a new instance of the `PdfAppearance` class.
+     *
+     * @param {PdfAnnotation} annot - The annotation.
+     * @param {number[]} bounds - The bounds.
+     * @private
+     */
+    function PdfAppearance(annot, bounds) {
+        this._dictionary = new _PdfDictionary();
+        this._annotations = annot;
+        this._crossReference = annot._crossReference;
+        if (typeof bounds !== 'undefined') {
+            this._bounds = bounds;
+        }
+        this._initialize();
+    }
+    Object.defineProperty(PdfAppearance.prototype, "normal", {
+        /**
+         * Get the normal appearance of the annotation.
+         *
+         * @returns {PdfTemplate} Returns the normal appearance of the annotation.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Get the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new rubber stamp annotation
+         * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+         * // Get the appearance of the annotation
+         * let appearance: PdfAppearance = annotation.appearance;
+         * // Access the normal template of the appearance
+         * let template: PdfTemplate = appearance.normal;
+         * // Create new image object by using JPEG image data as Base64 string format
+         * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+         * // Draw the image as the custom appearance for the annotation
+         * template.graphics.drawImage(image, 0, 0, 100, 50);
+         * // Add annotation to the page
+         * page.annotations.add(annotation);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (!this._templateNormal && this._dictionary.has('AP')) {
+                this._templateNormal = this._dictionary.get('N');
+            }
+            return this._templateNormal;
+        },
+        /**
+         * Set the normal appearance of the annotation.
+         *
+         * @param {PdfTemplate} value The normal appearance of the annotation.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Get the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new rubber stamp annotation
+         * const annotation: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 100, 100, 50);
+         * // Get the appearance of the annotation
+         * let appearance: PdfAppearance = annotation.appearance;
+         * // Access the normal template of the appearance
+         * let template: PdfTemplate = appearance.normal;
+         * // Create new image object by using JPEG image data as Base64 string format
+         * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+         * // Draw the image as the custom appearance for the annotation
+         * template.graphics.drawImage(image, 0, 0, 100, 50);
+         * // Add annotation to the page
+         * page.annotations.add(annotation);
+         * // Add a new rubber stamp annotation to the page
+         * const annotation2: PdfRubberStampAnnotation = new PdfRubberStampAnnotation(50, 200, 100, 50);
+         * // Set the normal appearance of the annotation
+         * annotation2.appearance.normal = annotation.appearance.normal;
+         * // Add annotation to the page
+         * page.annotations.add(annotation2);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            if (value) {
+                this._templateNormal = value;
+                this._dictionary.set('N', this._templateNormal);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PdfAppearance.prototype._initialize = function () {
+        this.normal = new PdfTemplate(this._bounds, this._crossReference);
+    };
+    return PdfAppearance;
+}());
+export { PdfAppearance };

package/src/pdf/core/annotations/pdf-paddings.d.ts

@@ -0,0 +1,8 @@
+export declare class _PdfPaddings {
+    _left: number;
+    _right: number;
+    _top: number;
+    _bottom: number;
+    constructor();
+    constructor(left: number, top: number, right: number, bottom: number);
+}

package/src/pdf/core/annotations/pdf-paddings.js

@@ -0,0 +1,22 @@
+var _PdfPaddings = /** @class */ (function () {
+    function _PdfPaddings(left, top, right, bottom) {
+        this._left = 0;
+        this._right = 0;
+        this._top = 0;
+        this._bottom = 0;
+        if (typeof left === 'undefined') {
+            this._left = 0.5;
+            this._right = 0.5;
+            this._top = 0.5;
+            this._bottom = 0.5;
+        }
+        else {
+            this._left = left;
+            this._right = right;
+            this._top = top;
+            this._bottom = bottom;
+        }
+    }
+    return _PdfPaddings;
+}());
+export { _PdfPaddings };

package/src/pdf/core/base-stream.d.ts

@@ -0,0 +1,86 @@
+import { _PdfDictionary, _PdfReference } from './pdf-primitives';
+export declare abstract class _PdfBaseStream {
+    offset: number;
+    dictionary: _PdfDictionary;
+    reference: _PdfReference;
+    _isCompress: boolean;
+    getByte(): number;
+    getBytes(length?: number): Uint8Array;
+    readonly length: number;
+    readonly isEmpty: boolean;
+    readonly isDataLoaded: boolean;
+    peekByte(): number;
+    peekBytes(length: number): Uint8Array;
+    getUnsignedInteger16(): number;
+    getInt32(): number;
+    getByteRange(begin: number, end: number): Uint8Array;
+    makeSubStream(start: number, length: number, dictionary: _PdfDictionary): _PdfBaseStream;
+    readBlock(): void;
+    reset(): void;
+    moveStart(): void;
+    getString(isHex?: boolean): string;
+    skip(n?: number): void;
+    getBaseStreams(): _PdfBaseStream[];
+}
+export declare class _PdfStream extends _PdfBaseStream {
+    constructor(arrayBuffer: number[] | Uint8Array | ArrayBuffer, dictionary?: _PdfDictionary, start?: number, length?: number);
+    bytes: Uint8Array;
+    start: number;
+    isImageStream: boolean;
+    end: number;
+    dataStream2: string[];
+    /**
+     * Gets the position of the stream.
+     *
+     * @returns {number} offset position.
+     */
+    /**
+    * Sets the position of the stream.
+    *
+    * @param {number} value offset position.
+    */
+    position: number;
+    /**
+     * Gets the length of the stream (Read only).
+     *
+     * @returns {number} length.
+     */
+    readonly length: number;
+    /**
+     * Gets a value indicating whether the stream is empty (Read only).
+     *
+     * @returns {boolean} stream empty or not.
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Gets the data of the stream.
+     *
+     * @returns {string[]} data of the stream.
+     */
+    /**
+    * Sets the data of the stream.
+    *
+    * @param {string[]} value data.
+    */
+    data: string[];
+    getByte(): number;
+    getBytes(length?: number): Uint8Array;
+    getByteRange(begin: number, end: number): Uint8Array;
+    reset(): void;
+    moveStart(): void;
+    makeSubStream(start: number, length: number, dictionary?: _PdfDictionary): _PdfStream;
+    readBlock(): void;
+    _clearStream(): void;
+    _write(text: string): void;
+    _writeBytes(data: number[]): void;
+}
+export declare class _PdfContentStream extends _PdfBaseStream {
+    _bytes: number[];
+    readonly length: number;
+    constructor(bytes: number[]);
+    write(data: string | number[]): void;
+    getString(isHex?: boolean): string;
+}
+export declare class _PdfNullStream extends _PdfStream {
+    constructor();
+}

package/src/pdf/core/base-stream.js

@@ -0,0 +1,332 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { _PdfDictionary } from './pdf-primitives';
+import { _byteArrayToHexString } from './utils';
+var _PdfBaseStream = /** @class */ (function () {
+    function _PdfBaseStream() {
+        this._isCompress = true;
+    }
+    _PdfBaseStream.prototype.getByte = function () {
+        return null;
+    };
+    _PdfBaseStream.prototype.getBytes = function (length) {
+        return null;
+    };
+    Object.defineProperty(_PdfBaseStream.prototype, "length", {
+        get: function () {
+            throw new Error('Abstract getter `length` accessed');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(_PdfBaseStream.prototype, "isEmpty", {
+        get: function () {
+            throw new Error('Abstract getter `isEmpty` accessed');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(_PdfBaseStream.prototype, "isDataLoaded", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfBaseStream.prototype.peekByte = function () {
+        var peekedByte = this.getByte();
+        if (peekedByte !== -1) {
+            this.offset--;
+        }
+        return peekedByte;
+    };
+    _PdfBaseStream.prototype.peekBytes = function (length) {
+        var bytes = this.getBytes(length);
+        this.offset -= bytes.length;
+        return bytes;
+    };
+    _PdfBaseStream.prototype.getUnsignedInteger16 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        if (b0 === -1 || b1 === -1) {
+            return -1;
+        }
+        return (b0 << 8) + b1;
+    };
+    _PdfBaseStream.prototype.getInt32 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        var b2 = this.getByte();
+        var b3 = this.getByte();
+        return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+    };
+    _PdfBaseStream.prototype.getByteRange = function (begin, end) {
+        return null;
+    };
+    _PdfBaseStream.prototype.makeSubStream = function (start, length, dictionary) {
+        return null;
+    };
+    _PdfBaseStream.prototype.readBlock = function () {
+        return null;
+    };
+    _PdfBaseStream.prototype.reset = function () {
+        return null;
+    };
+    _PdfBaseStream.prototype.moveStart = function () {
+        return null;
+    };
+    _PdfBaseStream.prototype.getString = function (isHex) {
+        if (isHex === void 0) { isHex = false; }
+        var bytes = this.getBytes();
+        if (typeof bytes === 'undefined' || bytes === null || typeof bytes.length === 'undefined') {
+            throw new Error('Invalid argument for bytesToString');
+        }
+        if (isHex) {
+            return _byteArrayToHexString(bytes);
+        }
+        else {
+            var len = bytes.length;
+            var max = 8192;
+            if (len < max) {
+                return String.fromCharCode.apply(null, bytes);
+            }
+            var stringBuffer = [];
+            for (var i = 0; i < len; i += max) {
+                stringBuffer.push(String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + max, len))));
+            }
+            return stringBuffer.join('');
+        }
+    };
+    _PdfBaseStream.prototype.skip = function (n) {
+        this.offset += n || 1;
+    };
+    _PdfBaseStream.prototype.getBaseStreams = function () {
+        return null;
+    };
+    return _PdfBaseStream;
+}());
+export { _PdfBaseStream };
+var _PdfStream = /** @class */ (function (_super) {
+    __extends(_PdfStream, _super);
+    function _PdfStream(arrayBuffer, dictionary, start, length) {
+        var _this = _super.call(this) || this;
+        _this.isImageStream = false;
+        _this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
+        if (typeof start !== 'undefined') {
+            _this.start = start;
+        }
+        else {
+            _this.start = 0;
+        }
+        _this.position = _this.start;
+        _this.end = start + length || _this.bytes.length;
+        _this.dictionary = dictionary;
+        return _this;
+    }
+    Object.defineProperty(_PdfStream.prototype, "position", {
+        /**
+         * Gets the position of the stream.
+         *
+         * @returns {number} offset position.
+         */
+        get: function () {
+            return this.offset;
+        },
+        /**
+         * Sets the position of the stream.
+         *
+         * @param {number} value offset position.
+         */
+        set: function (value) {
+            this.offset = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(_PdfStream.prototype, "length", {
+        /**
+         * Gets the length of the stream (Read only).
+         *
+         * @returns {number} length.
+         */
+        get: function () {
+            return this.end - this.start;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(_PdfStream.prototype, "isEmpty", {
+        /**
+         * Gets a value indicating whether the stream is empty (Read only).
+         *
+         * @returns {boolean} stream empty or not.
+         */
+        get: function () {
+            return this.length === 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(_PdfStream.prototype, "data", {
+        /**
+         * Gets the data of the stream.
+         *
+         * @returns {string[]} data of the stream.
+         */
+        get: function () {
+            return this.dataStream2;
+        },
+        /**
+         * Sets the data of the stream.
+         *
+         * @param {string[]} value data.
+         */
+        set: function (value) {
+            this.dataStream2 = [];
+            this.dataStream2 = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfStream.prototype.getByte = function () {
+        if (this.position >= this.end) {
+            return -1;
+        }
+        return this.bytes[this.position++];
+    };
+    _PdfStream.prototype.getBytes = function (length) {
+        var bytes = this.bytes;
+        var position = this.position;
+        var strEnd = this.end;
+        if (!length) {
+            return bytes.subarray(position, strEnd);
+        }
+        var end = position + length;
+        if (end > strEnd) {
+            end = strEnd;
+        }
+        this.position = end;
+        return bytes.subarray(position, end);
+    };
+    _PdfStream.prototype.getByteRange = function (begin, end) {
+        if (begin < 0) {
+            begin = 0;
+        }
+        if (end > this.end) {
+            end = this.end;
+        }
+        return this.bytes.subarray(begin, end);
+    };
+    _PdfStream.prototype.reset = function () {
+        this.position = this.start;
+    };
+    _PdfStream.prototype.moveStart = function () {
+        this.start = this.position;
+    };
+    _PdfStream.prototype.makeSubStream = function (start, length, dictionary) {
+        if (dictionary === void 0) { dictionary = null; }
+        return new _PdfStream(this.bytes.buffer, dictionary, start, length);
+    };
+    _PdfStream.prototype.readBlock = function () {
+        throw new Error('Abstract method `readBlock` called');
+    };
+    _PdfStream.prototype._clearStream = function () {
+        if (this.dictionary !== null && typeof this.dictionary !== 'undefined' && this.dictionary.has('Filter')) {
+            delete this.dictionary._map.Filter;
+        }
+        this._isCompress = true;
+        this.dictionary._updated = true;
+    };
+    _PdfStream.prototype._write = function (text) {
+        this.bytes = new Uint8Array(text.length);
+        for (var i = 0; i < text.length; i++) {
+            this.bytes[Number.parseInt(i.toString(), 10)] = text.charCodeAt(i);
+        }
+        this.end = this.bytes.length;
+        this.dictionary._updated = true;
+    };
+    _PdfStream.prototype._writeBytes = function (data) {
+        var text = '';
+        for (var i = 0; i < data.length; i++) {
+            text = text + String.fromCharCode(data[Number.parseInt(i.toString(), 10)]);
+        }
+        this.bytes = new Uint8Array(data);
+        this.end = this.bytes.length;
+        this.dictionary._updated = true;
+    };
+    return _PdfStream;
+}(_PdfBaseStream));
+export { _PdfStream };
+var _PdfContentStream = /** @class */ (function (_super) {
+    __extends(_PdfContentStream, _super);
+    function _PdfContentStream(bytes) {
+        var _this = _super.call(this) || this;
+        _this._bytes = bytes;
+        _this.dictionary = new _PdfDictionary();
+        _this.dictionary._updated = true;
+        return _this;
+    }
+    Object.defineProperty(_PdfContentStream.prototype, "length", {
+        get: function () {
+            return this._bytes.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfContentStream.prototype.write = function (data) {
+        if (typeof data === 'string') {
+            for (var i = 0; i < data.length; i++) {
+                this._bytes.push(data.charCodeAt(i));
+            }
+        }
+        else {
+            for (var i = 0; i < data.length; i++) {
+                this._bytes.push(data[Number.parseInt(i.toString(), 10)]);
+            }
+        }
+        this.dictionary._updated = true;
+    };
+    _PdfContentStream.prototype.getString = function (isHex) {
+        if (isHex === void 0) { isHex = false; }
+        var bytes = new Uint8Array(this._bytes);
+        if (typeof bytes === 'undefined' || bytes === null || typeof bytes.length === 'undefined') {
+            throw new Error('Invalid argument for bytesToString');
+        }
+        if (isHex) {
+            return _byteArrayToHexString(bytes);
+        }
+        else {
+            var len = bytes.length;
+            var max = 8192;
+            if (len < max) {
+                return String.fromCharCode.apply(null, bytes);
+            }
+            var stringBuffer = [];
+            for (var i = 0; i < len; i += max) {
+                stringBuffer.push(String.fromCharCode.apply(null, bytes.subarray(i, Math.min(i + max, len))));
+            }
+            return stringBuffer.join('');
+        }
+    };
+    return _PdfContentStream;
+}(_PdfBaseStream));
+export { _PdfContentStream };
+var _PdfNullStream = /** @class */ (function (_super) {
+    __extends(_PdfNullStream, _super);
+    function _PdfNullStream() {
+        return _super.call(this, new Uint8Array(0)) || this;
+    }
+    return _PdfNullStream;
+}(_PdfStream));
+export { _PdfNullStream };