@syncfusion/ej2-pdf 1.0.23 → 23.1.36

package/src/pdf/core/graphics/pdf-path.d.ts

@@ -0,0 +1,34 @@
+import { PdfPen } from './pdf-graphics';
+import { PdfFillMode } from './../enumerator';
+export declare class _PdfPath {
+    _fillMode: PdfFillMode;
+    _points: Array<number[]>;
+    _pathTypes: _PathPointType[];
+    _pen: PdfPen;
+    _isStart: boolean;
+    _isRoundedRectangle: boolean;
+    constructor();
+    readonly _lastPoint: number[];
+    _addLine(x1: number, y1: number, x2: number, y2: number): void;
+    _addLines(linePoints: Array<number[]>): void;
+    _addPoints(points: number[], type: _PathPointType, start?: number, end?: number): void;
+    _addPoint(points: number[], type: _PathPointType): void;
+    _addArc(x: number, y: number, width: number, height: number, startAngle: number, sweepAngle: number): void;
+    _addRectangle(x: number, y: number, width: number, height: number): void;
+    _addPolygon(points: Array<number[]>): void;
+    _addEllipse(x: number, y: number, width: number, height: number): void;
+    _addBezierPoints(pointsCollection: number[][]): void;
+    _addBezier(x: number, y: number, firstX: number, firstY: number, secondX: number, secondY: number, endX: number, endY: number): void;
+    _closeFigure(index?: number): void;
+    _startFigure(): void;
+    _getBounds(): number[];
+}
+export declare enum _PathPointType {
+    start = 0,
+    line = 1,
+    bezier = 3,
+    pathTypeMask = 7,
+    dashMode = 16,
+    pathMarker = 32,
+    closePath = 128
+}

package/src/pdf/core/graphics/pdf-path.js

@@ -0,0 +1,177 @@
+import { _getBezierArc } from './../utils';
+import { PdfFillMode } from './../enumerator';
+var _PdfPath = /** @class */ (function () {
+    function _PdfPath() {
+        this._isRoundedRectangle = false;
+        this._fillMode = PdfFillMode.winding;
+        this._points = [];
+        this._pathTypes = [];
+        this._isStart = true;
+    }
+    Object.defineProperty(_PdfPath.prototype, "_lastPoint", {
+        get: function () {
+            var value = [0, 0];
+            var count = this._points.length;
+            if (this._points.length > 0) {
+                value[0] = this._points[(count - 1)][0];
+                value[1] = this._points[(count - 1)][0];
+            }
+            return value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfPath.prototype._addLine = function (x1, y1, x2, y2) {
+        this._addPoints([x1, y1, x2, y2], _PathPointType.line);
+    };
+    _PdfPath.prototype._addLines = function (linePoints) {
+        var start = linePoints[0];
+        if (linePoints.length === 1) {
+            this._addPoint(linePoints[0], _PathPointType.line);
+        }
+        else {
+            for (var i = 1; i < linePoints.length; i++) {
+                var last = linePoints[Number.parseInt(i.toString(), 10)];
+                this._addLine(start[0], start[1], last[0], last[1]);
+                start = last;
+            }
+        }
+    };
+    _PdfPath.prototype._addPoints = function (points, type, start, end) {
+        var startIndex = (typeof start !== 'undefined') ? start : 0;
+        var endIndex = (typeof end !== 'undefined') ? end : points.length;
+        for (var i = startIndex; i < endIndex; i++) {
+            var point = [points[Number.parseInt(i.toString(), 10)], points[i + 1]];
+            if (i === startIndex) {
+                if (this._points.length === 0 || this._isStart) {
+                    this._addPoint(point, _PathPointType.start);
+                    this._isStart = false;
+                }
+                else if (this._isRoundedRectangle && (point[0] !== this._lastPoint[0] || point[1] !== this._lastPoint[1])) {
+                    this._addPoint(point, _PathPointType.line);
+                }
+                else if (point[0] !== this._lastPoint[0] && point[1] !== this._lastPoint[1]) {
+                    this._addPoint(point, _PathPointType.line);
+                }
+            }
+            else {
+                this._addPoint(point, type);
+            }
+            i++;
+        }
+    };
+    _PdfPath.prototype._addPoint = function (points, type) {
+        this._points.push(points);
+        this._pathTypes.push(type);
+    };
+    _PdfPath.prototype._addArc = function (x, y, width, height, startAngle, sweepAngle) {
+        var points = _getBezierArc(x, y, x + width, y + height, startAngle, sweepAngle);
+        for (var i = 0; i < points.length; ++i) {
+            var list = [points[Number.parseInt(i.toString(), 10)],
+                points[++i],
+                points[++i],
+                points[++i],
+                points[++i],
+                points[++i],
+                points[++i],
+                points[++i]];
+            this._addPoints(list, _PathPointType.bezier);
+        }
+    };
+    _PdfPath.prototype._addRectangle = function (x, y, width, height) {
+        this._startFigure();
+        this._addPoints([x, y, x + width, y, x + width, y + height, x, y + height], _PathPointType.line);
+        this._closeFigure();
+    };
+    _PdfPath.prototype._addPolygon = function (points) {
+        var newPoints = [];
+        points.forEach(function (element) {
+            newPoints.push(element[0], element[1]);
+        });
+        this._startFigure();
+        this._addPoints(newPoints, _PathPointType.line);
+        this._closeFigure();
+    };
+    _PdfPath.prototype._addEllipse = function (x, y, width, height) {
+        this._startFigure();
+        this._addArc(x, y, width, height, 0, 360);
+        this._closeFigure();
+    };
+    _PdfPath.prototype._addBezierPoints = function (pointsCollection) {
+        if (pointsCollection.length < 4) {
+            throw Error('Incorrect size of array points');
+        }
+        var bound = 3;
+        var index = 0;
+        var start = pointsCollection[Number.parseInt(index.toString(), 10)];
+        index++;
+        while ((index + bound) <= pointsCollection.length) {
+            var inner1 = pointsCollection[Number.parseInt(index.toString(), 10)];
+            index++;
+            var inner2 = pointsCollection[Number.parseInt(index.toString(), 10)];
+            index++;
+            var end = pointsCollection[Number.parseInt(index.toString(), 10)];
+            index++;
+            this._addBezier(start[0], start[1], inner1[0], inner1[1], inner2[0], inner2[1], end[0], end[1]);
+            start = end;
+        }
+    };
+    _PdfPath.prototype._addBezier = function (x, y, firstX, firstY, secondX, secondY, endX, endY) {
+        var points = [];
+        points.push(x);
+        points.push(y);
+        points.push(firstX);
+        points.push(firstY);
+        points.push(secondX);
+        points.push(secondY);
+        points.push(endX);
+        points.push(endY);
+        this._addPoints(points, _PathPointType.bezier);
+    };
+    _PdfPath.prototype._closeFigure = function (index) {
+        if (typeof index !== 'undefined') {
+            var type = this._pathTypes[Number.parseInt(index.toString(), 10)];
+            type |= _PathPointType.closePath;
+            this._pathTypes[Number.parseInt(index.toString(), 10)] = type;
+        }
+        else {
+            if (this._points.length > 0) {
+                this._closeFigure(this._points.length - 1);
+            }
+            this._startFigure();
+        }
+    };
+    _PdfPath.prototype._startFigure = function () {
+        this._isStart = true;
+    };
+    _PdfPath.prototype._getBounds = function () {
+        var bounds = [0, 0, 0, 0];
+        if (this._points.length > 0) {
+            var xmin = this._points[0][0];
+            var xmax = this._points[0][0];
+            var ymin = this._points[0][1];
+            var ymax = this._points[0][1];
+            for (var i = 1; i < this._points.length; ++i) {
+                var point = this._points[Number.parseInt(i.toString(), 10)];
+                xmin = Math.min(point[0], xmin);
+                xmax = Math.max(point[0], xmax);
+                ymin = Math.min(point[1], ymin);
+                ymax = Math.max(point[1], ymax);
+            }
+            bounds = [xmin, ymin, xmax - xmin, ymax - ymin];
+        }
+        return bounds;
+    };
+    return _PdfPath;
+}());
+export { _PdfPath };
+export var _PathPointType;
+(function (_PathPointType) {
+    _PathPointType[_PathPointType["start"] = 0] = "start";
+    _PathPointType[_PathPointType["line"] = 1] = "line";
+    _PathPointType[_PathPointType["bezier"] = 3] = "bezier";
+    _PathPointType[_PathPointType["pathTypeMask"] = 7] = "pathTypeMask";
+    _PathPointType[_PathPointType["dashMode"] = 16] = "dashMode";
+    _PathPointType[_PathPointType["pathMarker"] = 32] = "pathMarker";
+    _PathPointType[_PathPointType["closePath"] = 128] = "closePath";
+})(_PathPointType || (_PathPointType = {}));

package/src/pdf/core/graphics/pdf-stream-writer.d.ts

@@ -0,0 +1,56 @@
+import { _PdfContentStream } from './../base-stream';
+import { _PdfTransformationMatrix } from './pdf-graphics';
+import { _PdfName } from './../pdf-primitives';
+export declare class _PdfStreamWriter {
+    _stream: _PdfContentStream;
+    _newLine: string;
+    _whiteSpace: string;
+    constructor(stream: _PdfContentStream);
+    _writeOperator(value: string): void;
+    _saveGraphicsState(): void;
+    _restoreGraphicsState(): void;
+    _writeComment(comment: string): void;
+    _setGraphicsState(value: _PdfName): void;
+    _modifyCtm(matrix: _PdfTransformationMatrix): void;
+    _modifyTM(matrix: _PdfTransformationMatrix): void;
+    _setColorSpace(value: string, forStroking: boolean): void;
+    _setColor(color: number[], forStroking: boolean): void;
+    _appendRectangle(x: number, y: number, width: number, height: number): void;
+    _writePoint(x: number, y: number): void;
+    _clipPath(isEvenOdd: boolean): void;
+    _fillPath(isEvenOdd: boolean): void;
+    _closeFillPath(isEvenOdd: boolean): void;
+    _strokePath(): void;
+    _closeStrokePath(): void;
+    _fillStrokePath(isEvenOdd: boolean): void;
+    _closeFillStrokePath(isEvenOdd: boolean): void;
+    _endPath(): void;
+    _setFont(name: string, size: number): void;
+    _setTextScaling(textScaling: number): void;
+    _closePath(): void;
+    _startNextLine(): void;
+    _startNextLine(x: number, y: number): void;
+    _showText(text: string): void;
+    _write(string: string): void;
+    _writeText(text: string): void;
+    _beginText(): void;
+    _endText(): void;
+    _beginPath(x: number, y: number): void;
+    _appendLineSegment(x: number, y: number): void;
+    _appendBezierSegment(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+    _setTextRenderingMode(renderingMode: number): void;
+    _setCharacterSpacing(charSpacing: number): void;
+    _setWordSpacing(wordSpacing: number): void;
+    _showNextLineText(text: string): void;
+    _showNextLineText(text: string, unicode: boolean): void;
+    _setLineDashPattern(pattern: number[], patternOffset: number): void;
+    _setMiterLimit(miterLimit: number): void;
+    _setLineWidth(width: number): void;
+    _setLineCap(lineCapStyle: number): void;
+    _setLineJoin(lineJoinStyle: number): void;
+    _executeObject(name: _PdfName): void;
+    _beginMarkupSequence(name: string): void;
+    _endMarkupSequence(): void;
+    _clear(): void;
+    _escapeSymbols(value: string): number[];
+}

package/src/pdf/core/graphics/pdf-stream-writer.js

@@ -0,0 +1,231 @@
+import { _escapePdfName } from './../utils';
+var _PdfStreamWriter = /** @class */ (function () {
+    function _PdfStreamWriter(stream) {
+        this._newLine = '\r\n';
+        this._whiteSpace = ' ';
+        this._stream = stream;
+    }
+    _PdfStreamWriter.prototype._writeOperator = function (value) {
+        this._stream.write(value);
+        this._stream.write(this._newLine);
+    };
+    _PdfStreamWriter.prototype._saveGraphicsState = function () {
+        this._writeOperator('q');
+    };
+    _PdfStreamWriter.prototype._restoreGraphicsState = function () {
+        this._writeOperator('Q');
+    };
+    _PdfStreamWriter.prototype._writeComment = function (comment) {
+        if (comment && comment.length > 0) {
+            this._writeOperator('% ' + comment);
+        }
+    };
+    _PdfStreamWriter.prototype._setGraphicsState = function (value) {
+        this._stream.write("/" + _escapePdfName(value.name) + " ");
+        this._writeOperator('gs');
+    };
+    _PdfStreamWriter.prototype._modifyCtm = function (matrix) {
+        this._stream.write(matrix._toString() + " ");
+        this._writeOperator('cm');
+    };
+    _PdfStreamWriter.prototype._modifyTM = function (matrix) {
+        this._stream.write(matrix._toString() + " ");
+        this._writeOperator('Tm');
+    };
+    _PdfStreamWriter.prototype._setColorSpace = function (value, forStroking) {
+        this._stream.write("/" + value + " ");
+        this._writeOperator(forStroking ? 'CS' : 'cs');
+    };
+    _PdfStreamWriter.prototype._setColor = function (color, forStroking) {
+        this._stream.write((color[0] / 255).toFixed(3) + " " + (color[1] / 255).toFixed(3) + " " + (color[2] / 255).toFixed(3) + " ");
+        this._writeOperator(forStroking ? 'RG' : 'rg');
+    };
+    _PdfStreamWriter.prototype._appendRectangle = function (x, y, width, height) {
+        this._writePoint(x, y);
+        this._writePoint(width, height);
+        this._writeOperator('re');
+    };
+    _PdfStreamWriter.prototype._writePoint = function (x, y) {
+        this._stream.write(x.toFixed(3) + " " + (-y).toFixed(3) + " ");
+    };
+    _PdfStreamWriter.prototype._clipPath = function (isEvenOdd) {
+        this._stream.write((isEvenOdd ? 'W*' : 'W') + " n" + this._newLine);
+    };
+    _PdfStreamWriter.prototype._fillPath = function (isEvenOdd) {
+        this._writeOperator(isEvenOdd ? 'f*' : 'f');
+    };
+    _PdfStreamWriter.prototype._closeFillPath = function (isEvenOdd) {
+        this._writeOperator('h');
+        this._fillPath(isEvenOdd);
+    };
+    _PdfStreamWriter.prototype._strokePath = function () {
+        this._writeOperator('S');
+    };
+    _PdfStreamWriter.prototype._closeStrokePath = function () {
+        this._writeOperator('s');
+    };
+    _PdfStreamWriter.prototype._fillStrokePath = function (isEvenOdd) {
+        this._writeOperator(isEvenOdd ? 'B*' : 'B');
+    };
+    _PdfStreamWriter.prototype._closeFillStrokePath = function (isEvenOdd) {
+        this._writeOperator(isEvenOdd ? 'b*' : 'b');
+    };
+    _PdfStreamWriter.prototype._endPath = function () {
+        this._writeOperator('n');
+    };
+    _PdfStreamWriter.prototype._setFont = function (name, size) {
+        this._stream.write("/" + name + " " + size.toFixed(3) + " ");
+        this._writeOperator('Tf');
+    };
+    _PdfStreamWriter.prototype._setTextScaling = function (textScaling) {
+        this._stream.write(textScaling.toFixed(3) + " ");
+        this._writeOperator('Tz');
+    };
+    _PdfStreamWriter.prototype._closePath = function () {
+        this._writeOperator('h');
+    };
+    _PdfStreamWriter.prototype._startNextLine = function (x, y) {
+        if (typeof x === 'undefined') {
+            this._writeOperator('T*');
+        }
+        else {
+            this._writePoint(x, y);
+            this._writeOperator('Td');
+        }
+    };
+    _PdfStreamWriter.prototype._showText = function (text) {
+        this._writeText(text);
+        this._writeOperator('Tj');
+    };
+    _PdfStreamWriter.prototype._write = function (string) {
+        var builder = '';
+        builder += string;
+        builder += '\r\n';
+        this._writeOperator(builder);
+    };
+    _PdfStreamWriter.prototype._writeText = function (text) {
+        var result = '';
+        var data = this._escapeSymbols(text);
+        for (var i = 0; i < data.length; i++) {
+            result += String.fromCharCode(data[i]); // eslint-disable-line
+        }
+        result = '(' + result + ')';
+        this._stream.write(result);
+    };
+    _PdfStreamWriter.prototype._beginText = function () {
+        this._writeOperator('BT');
+    };
+    _PdfStreamWriter.prototype._endText = function () {
+        this._writeOperator('ET');
+    };
+    _PdfStreamWriter.prototype._beginPath = function (x, y) {
+        this._writePoint(x, y);
+        this._writeOperator('m');
+    };
+    _PdfStreamWriter.prototype._appendLineSegment = function (x, y) {
+        this._writePoint(x, y);
+        this._writeOperator('l');
+    };
+    _PdfStreamWriter.prototype._appendBezierSegment = function (x1, y1, x2, y2, x3, y3) {
+        this._writePoint(x1, y1);
+        this._writePoint(x2, y2);
+        this._writePoint(x3, y3);
+        this._writeOperator('c');
+    };
+    _PdfStreamWriter.prototype._setTextRenderingMode = function (renderingMode) {
+        this._stream.write(renderingMode.toString() + " ");
+        this._writeOperator('Tr');
+    };
+    _PdfStreamWriter.prototype._setCharacterSpacing = function (charSpacing) {
+        this._stream.write(charSpacing.toFixed(3) + " ");
+        this._writeOperator('Tc');
+    };
+    _PdfStreamWriter.prototype._setWordSpacing = function (wordSpacing) {
+        this._stream.write(wordSpacing.toFixed(3) + " ");
+        this._writeOperator('Tw');
+    };
+    _PdfStreamWriter.prototype._showNextLineText = function (text, unicode) {
+        if (unicode !== null && typeof unicode !== 'undefined' && unicode) {
+            this._writeText(text);
+            this._writeOperator('\'');
+        }
+        else {
+            this._stream.write(text);
+            this._writeOperator('\'');
+        }
+    };
+    _PdfStreamWriter.prototype._setLineDashPattern = function (pattern, patternOffset) {
+        var tempPattern = '[';
+        if (pattern.length > 1) {
+            for (var index = 0; index < pattern.length; index++) {
+                if (index === pattern.length - 1) {
+                    tempPattern += pattern[index].toString(); // eslint-disable-line
+                }
+                else {
+                    tempPattern += pattern[index].toString() + ' '; // eslint-disable-line
+                }
+            }
+        }
+        tempPattern += '] ';
+        tempPattern += patternOffset.toString();
+        tempPattern += ' d';
+        this._writeOperator(tempPattern);
+    };
+    _PdfStreamWriter.prototype._setMiterLimit = function (miterLimit) {
+        this._stream.write(miterLimit.toFixed(3) + " ");
+        this._writeOperator('M');
+    };
+    _PdfStreamWriter.prototype._setLineWidth = function (width) {
+        this._stream.write(width.toFixed(3) + " ");
+        this._writeOperator('w');
+    };
+    _PdfStreamWriter.prototype._setLineCap = function (lineCapStyle) {
+        this._stream.write(lineCapStyle + " ");
+        this._writeOperator('J');
+    };
+    _PdfStreamWriter.prototype._setLineJoin = function (lineJoinStyle) {
+        this._stream.write(lineJoinStyle + " ");
+        this._writeOperator('j');
+    };
+    _PdfStreamWriter.prototype._executeObject = function (name) {
+        this._stream.write("/" + name.name + " ");
+        this._writeOperator('Do');
+    };
+    _PdfStreamWriter.prototype._beginMarkupSequence = function (name) {
+        this._stream.write("/" + name + " ");
+        this._writeOperator('BMC');
+    };
+    _PdfStreamWriter.prototype._endMarkupSequence = function () {
+        this._writeOperator('EMC');
+    };
+    _PdfStreamWriter.prototype._clear = function () {
+        this._stream._bytes = [];
+    };
+    _PdfStreamWriter.prototype._escapeSymbols = function (value) {
+        var data = [];
+        for (var i = 0; i < value.length; i++) {
+            var currentData = value.charCodeAt(i);
+            switch (currentData) {
+                case 40:
+                case 41:
+                    data.push(92);
+                    data.push(currentData);
+                    break;
+                case 13:
+                    data.push(92);
+                    data.push(114);
+                    break;
+                case 92:
+                    data.push(92);
+                    data.push(currentData);
+                    break;
+                default:
+                    data.push(currentData);
+                    break;
+            }
+        }
+        return data;
+    };
+    return _PdfStreamWriter;
+}());
+export { _PdfStreamWriter };

package/src/pdf/core/graphics/pdf-template.d.ts

@@ -0,0 +1,79 @@
+import { _PdfBaseStream } from './../base-stream';
+import { PdfGraphics } from './pdf-graphics';
+import { _PdfCrossReference } from './../pdf-cross-reference';
+/**
+ * `PdfTemplate` class represents the template of the PDF.
+ * ```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 normal appearance of the annotation
+ * let normalAppearance: PdfTemplate = annotation.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
+ * normalAppearance.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 PdfTemplate {
+    _content: any;
+    _size: number[];
+    _writeTransformation: boolean;
+    _isReadOnly: boolean;
+    _isAnnotationTemplate: boolean;
+    _needScale: boolean;
+    _g: PdfGraphics;
+    _crossReference: _PdfCrossReference;
+    /**
+     * Initializes a new instance of the `PdfTemplate` class.
+     *
+     * @param {_PdfBaseStream} appearance - The appearance stream.
+     * @param {_PdfCrossReference} crossReference - The cross reference object.
+     * @private
+     */
+    constructor(appearance: _PdfBaseStream, crossReference: _PdfCrossReference);
+    /**
+     * Initializes a new instance of the `PdfTemplate` class.
+     *
+     * @param {number[]} bounds - The bounds.
+     * @param {_PdfCrossReference} crossReference - The cross reference object.
+     * @private
+     */
+    constructor(bounds: number[], crossReference: _PdfCrossReference);
+    /**
+     * Get the graphics of the PDF template.
+     *
+     * @returns {PdfGraphics} The graphics object of the PDF template.
+     * ```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);
+     * // Access the graphics of the normal appearance
+     * let graphics: PdfGraphics = annotation.appearance.normal.graphics;
+     * // 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
+     * 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();
+     * ```
+     */
+    readonly graphics: PdfGraphics;
+    _initialize(): void;
+}

package/src/pdf/core/graphics/pdf-template.js

@@ -0,0 +1,100 @@
+import { _PdfName } from './../pdf-primitives';
+import { _PdfBaseStream, _PdfContentStream } from './../base-stream';
+import { PdfGraphics } from './pdf-graphics';
+import { _toRectangle } from './../utils';
+/**
+ * `PdfTemplate` class represents the template of the PDF.
+ * ```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 normal appearance of the annotation
+ * let normalAppearance: PdfTemplate = annotation.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
+ * normalAppearance.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 PdfTemplate = /** @class */ (function () {
+    function PdfTemplate(value, crossReference) {
+        this._crossReference = crossReference;
+        if (value instanceof _PdfBaseStream) {
+            this._content = value;
+            if (!this._content.dictionary.has('Type') || !this._content.dictionary.has('Subtype')) {
+                this._initialize();
+            }
+            var bounds = this._content.dictionary.getArray('BBox');
+            if (bounds && bounds.length > 3) {
+                var rect = _toRectangle(bounds);
+                this._size = [rect.width, rect.height];
+            }
+            this._isReadOnly = true;
+        }
+        else {
+            this._size = [value[2], value[3]];
+            this._content = new _PdfContentStream([]);
+            this._content.dictionary._crossReference = this._crossReference;
+            this._initialize();
+            this._content.dictionary.set('BBox', [value[0], value[1], value[0] + value[2], value[1] + value[3]]);
+        }
+        this._writeTransformation = true;
+    }
+    Object.defineProperty(PdfTemplate.prototype, "graphics", {
+        /**
+         * Get the graphics of the PDF template.
+         *
+         * @returns {PdfGraphics} The graphics object of the PDF template.
+         * ```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);
+         * // Access the graphics of the normal appearance
+         * let graphics: PdfGraphics = annotation.appearance.normal.graphics;
+         * // 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
+         * 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._isReadOnly) {
+                return null;
+            }
+            if (typeof this._g === 'undefined') {
+                this._g = new PdfGraphics(this._size, this._content, this._crossReference, this);
+                if (this._writeTransformation) {
+                    this._g._initializeCoordinates();
+                }
+                this._g._isTemplateGraphics = true;
+            }
+            return this._g;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PdfTemplate.prototype._initialize = function () {
+        this._content.dictionary.set('Type', _PdfName.get('XObject'));
+        this._content.dictionary.set('Subtype', _PdfName.get('Form'));
+    };
+    return PdfTemplate;
+}());
+export { PdfTemplate };