@syncfusion/ej2-pdf 1.0.23 → 23.1.36

package/src/pdf/core/fonts/ttf-table.d.ts

@@ -0,0 +1,132 @@
+import { _TrueTypeNameRecord } from './ttf-reader';
+export declare class _TrueTypeTableInfo {
+    _offset: number;
+    _length: number;
+    _checksum: number;
+    readonly _empty: boolean;
+}
+export declare class _TrueTypeOS2Table {
+    _version: number;
+    _xAvgCharWidth: number;
+    _usWeightClass: number;
+    _usWidthClass: number;
+    _fsType: number;
+    _ySubscriptXSize: number;
+    _ySubscriptYSize: number;
+    _ySubscriptXOffset: number;
+    _ySubscriptYOffset: number;
+    _ySuperscriptXSize: number;
+    _ySuperscriptYSize: number;
+    _ySuperscriptXOffset: number;
+    _ySuperscriptYOffset: number;
+    _yStrikeoutSize: number;
+    _yStrikeoutPosition: number;
+    _sFamilyClass: number;
+    _panose: number[];
+    _ulUnicodeRange1: number;
+    _ulUnicodeRange2: number;
+    _ulUnicodeRange3: number;
+    _ulUnicodeRange4: number;
+    _vendorIdentifier: number[];
+    _fsSelection: number;
+    _usFirstCharIndex: number;
+    _usLastCharIndex: number;
+    _sTypoAscender: number;
+    _sTypoDescender: number;
+    _sTypoLineGap: number;
+    _usWinAscent: number;
+    _usWinDescent: number;
+    _ulCodePageRange1: number;
+    _ulCodePageRange2: number;
+    _sxHeight: number;
+    _sCapHeight: number;
+    _usDefaultChar: number;
+    _usBreakChar: number;
+    _usMaxContext: number;
+}
+export declare class _TrueTypePostTable {
+    _formatType: number;
+    _italicAngle: number;
+    _underlinePosition: number;
+    _underlineThickness: number;
+    _isFixedPitch: number;
+    _minType42: number;
+    _maxType42: number;
+    _minType1: number;
+    _maxType1: number;
+}
+export declare class _TrueTypeNameTable {
+    _formatSelector: number;
+    _recordsCount: number;
+    _offset: number;
+    _nameRecords: _TrueTypeNameRecord[];
+}
+export declare class _TrueTypeMicrosoftCmapSubTable {
+    _format: number;
+    _length: number;
+    _version: number;
+    _segCountX2: number;
+    _searchRange: number;
+    _entrySelector: number;
+    _rangeShift: number;
+    _endCount: number[];
+    _reservedPad: number;
+    _startCount: number[];
+    _idDelta: number[];
+    _idRangeOffset: number[];
+    _glyphID: number[];
+}
+export declare class _TrueTypeHorizontalHeaderTable {
+    _version: number;
+    _ascender: number;
+    _advanceWidthMax: number;
+    _descender: number;
+    _numberOfHMetrics: number;
+    _lineGap: number;
+    _minLeftSideBearing: number;
+    _minRightSideBearing: number;
+    _xMaxExtent: number;
+    _caretSlopeRise: number;
+    _caretSlopeRun: number;
+    _metricDataFormat: number;
+}
+export declare class _TrueTypeHeadTable {
+    _modified: number;
+    _created: number;
+    _magicNumber: number;
+    _checkSumAdjustment: number;
+    _fontRevision: number;
+    _version: number;
+    _xMin: number;
+    _yMin: number;
+    _unitsPerEm: number;
+    _yMax: number;
+    _xMax: number;
+    _macStyle: number;
+    _flags: number;
+    _lowestReadableSize: number;
+    _fontDirectionHint: number;
+    _indexToLocalFormat: number;
+    _glyphDataFormat: number;
+}
+export declare class _TrueTypeCmapTable {
+    _version: number;
+    _tablesCount: number;
+}
+export declare class _TrueTypeCmapSubTable {
+    _platformID: number;
+    _encodingID: number;
+    _offset: number;
+}
+export declare class _TrueTypeAppleCmapSubTable {
+    _format: number;
+    _length: number;
+    _version: number;
+}
+export declare class _TrueTypeTrimmedCmapSubTable {
+    _format: number;
+    _length: number;
+    _version: number;
+    _firstCode: number;
+    _entryCount: number;
+}

package/src/pdf/core/fonts/ttf-table.js

@@ -0,0 +1,74 @@
+var _TrueTypeTableInfo = /** @class */ (function () {
+    function _TrueTypeTableInfo() {
+    }
+    Object.defineProperty(_TrueTypeTableInfo.prototype, "_empty", {
+        get: function () {
+            var empty = (this._offset === this._length && this._length === this._checksum && this._checksum === 0);
+            return empty;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return _TrueTypeTableInfo;
+}());
+export { _TrueTypeTableInfo };
+var _TrueTypeOS2Table = /** @class */ (function () {
+    function _TrueTypeOS2Table() {
+    }
+    return _TrueTypeOS2Table;
+}());
+export { _TrueTypeOS2Table };
+var _TrueTypePostTable = /** @class */ (function () {
+    function _TrueTypePostTable() {
+    }
+    return _TrueTypePostTable;
+}());
+export { _TrueTypePostTable };
+var _TrueTypeNameTable = /** @class */ (function () {
+    function _TrueTypeNameTable() {
+    }
+    return _TrueTypeNameTable;
+}());
+export { _TrueTypeNameTable };
+var _TrueTypeMicrosoftCmapSubTable = /** @class */ (function () {
+    function _TrueTypeMicrosoftCmapSubTable() {
+    }
+    return _TrueTypeMicrosoftCmapSubTable;
+}());
+export { _TrueTypeMicrosoftCmapSubTable };
+var _TrueTypeHorizontalHeaderTable = /** @class */ (function () {
+    function _TrueTypeHorizontalHeaderTable() {
+    }
+    return _TrueTypeHorizontalHeaderTable;
+}());
+export { _TrueTypeHorizontalHeaderTable };
+var _TrueTypeHeadTable = /** @class */ (function () {
+    function _TrueTypeHeadTable() {
+    }
+    return _TrueTypeHeadTable;
+}());
+export { _TrueTypeHeadTable };
+var _TrueTypeCmapTable = /** @class */ (function () {
+    function _TrueTypeCmapTable() {
+    }
+    return _TrueTypeCmapTable;
+}());
+export { _TrueTypeCmapTable };
+var _TrueTypeCmapSubTable = /** @class */ (function () {
+    function _TrueTypeCmapSubTable() {
+    }
+    return _TrueTypeCmapSubTable;
+}());
+export { _TrueTypeCmapSubTable };
+var _TrueTypeAppleCmapSubTable = /** @class */ (function () {
+    function _TrueTypeAppleCmapSubTable() {
+    }
+    return _TrueTypeAppleCmapSubTable;
+}());
+export { _TrueTypeAppleCmapSubTable };
+var _TrueTypeTrimmedCmapSubTable = /** @class */ (function () {
+    function _TrueTypeTrimmedCmapSubTable() {
+    }
+    return _TrueTypeTrimmedCmapSubTable;
+}());
+export { _TrueTypeTrimmedCmapSubTable };

package/src/pdf/core/fonts/unicode-true-type-font.d.ts

@@ -0,0 +1,50 @@
+import { _TrueTypeReader, _TrueTypeMetrics } from './ttf-reader';
+import { _PdfDictionary, Dictionary } from './../pdf-primitives';
+import { _PdfFontMetrics } from './pdf-font-metrics';
+import { _PdfStream } from './../base-stream';
+export declare class _UnicodeTrueTypeFont {
+    readonly _nameString: string;
+    _subsetName: string;
+    _fontSize: number;
+    _fontString: string;
+    _fontData: Uint8Array;
+    _ttfReader: _TrueTypeReader;
+    _ttfMetrics: _TrueTypeMetrics;
+    _isEmbed: boolean;
+    _fontDictionary: _PdfDictionary;
+    _descendantFont: _PdfDictionary;
+    _fontDescriptor: _PdfDictionary;
+    _metrics: _PdfFontMetrics;
+    _usedChars: Dictionary<string, string>;
+    _isEmbedFont: boolean;
+    _cmap: _PdfStream;
+    _fontProgram: _PdfStream;
+    _cmapPrefix: string;
+    _cmapEndCodeSpaceRange: string;
+    _cmapBeginRange: string;
+    _cmapEndRange: string;
+    _cmapSuffix: string;
+    constructor(base64String: string, size: number);
+    _beginSave(): void;
+    _descendantFontBeginSave(): void;
+    _fontDictionaryBeginSave(): void;
+    _Initialize(): void;
+    _createInternals(): void;
+    _getInternals(): _PdfDictionary;
+    _initializeMetrics(): void;
+    _getFontName(): string;
+    _createDescendantFont(): void;
+    _createFontDescriptor(): _PdfDictionary;
+    _generateFontProgram(): void;
+    _getBoundBox(): number[];
+    _cmapBeginSave(): void;
+    _fontProgramBeginSave(): void;
+    _toHexString(n: number, isCaseChange: boolean): string;
+    _generateCmap(): void;
+    _createFontDictionary(): void;
+    _createSystemInfo(): _PdfDictionary;
+    _getDescriptorFlags(): number;
+    _getCharacterWidth(charCode: string): number;
+    _setSymbols(text: string): void;
+    _getDescendantWidth(): Array<any>;
+}

package/src/pdf/core/fonts/unicode-true-type-font.js

@@ -0,0 +1,289 @@
+import { _TrueTypeReader } from './ttf-reader';
+import { _PdfDictionary, _PdfName, Dictionary } from './../pdf-primitives';
+import { _PdfFontMetrics } from './pdf-font-metrics';
+import { _StandardWidthTable } from './pdf-font-metrics';
+import { _FontDescriptorFlag } from '../enumerator';
+import { _decode } from '../utils';
+import { _PdfStream } from './../base-stream';
+var _UnicodeTrueTypeFont = /** @class */ (function () {
+    function _UnicodeTrueTypeFont(base64String, size) {
+        this._nameString = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        this._isEmbedFont = false;
+        this._cmapPrefix = '/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap' + '\r\n' + '/CIDSystemInfo << /Registry (Adobe)/Ordering (UCS)/Supplement 0>> def\n/CMapName ' + '/Adobe-Identity-UCS def\n/CMapType 2 def\n1 beginCodeSpacerange' + '\r\n';
+        this._cmapEndCodeSpaceRange = 'endCodeSpacerange' + '\r\n';
+        this._cmapBeginRange = 'beginbfrange' + '\r\n';
+        this._cmapEndRange = 'endbfrange' + '\r\n';
+        this._cmapSuffix = 'endbfrange\nendcmap\nCMapName currentdict ' + '/CMap defineresource pop\nend end' + '\r\n';
+        if (base64String === null || typeof base64String === 'undefined') {
+            throw new Error('ArgumentNullException:base64String');
+        }
+        this._fontSize = size;
+        this._fontString = base64String;
+        this._Initialize();
+    }
+    _UnicodeTrueTypeFont.prototype._beginSave = function () {
+        this._descendantFontBeginSave();
+        this._cmapBeginSave();
+        this._fontDictionaryBeginSave();
+        this._fontProgramBeginSave();
+        if (this._fontDescriptor) {
+            this._fontDescriptor.update('FontFile2', this._fontProgram);
+            this._fontDescriptor._updated = true;
+            this._fontDescriptor._isFont = true;
+        }
+    };
+    _UnicodeTrueTypeFont.prototype._descendantFontBeginSave = function () {
+        if (this._usedChars !== null && typeof this._usedChars !== 'undefined' && this._usedChars._size() > 0) {
+            var width = this._getDescendantWidth(); // eslint-disable-line
+            if (width !== null) {
+                this._descendantFont.set('W', width);
+            }
+        }
+    };
+    _UnicodeTrueTypeFont.prototype._fontDictionaryBeginSave = function () {
+        if (this._usedChars !== null && typeof this._usedChars !== 'undefined' && this._usedChars._size() > 0) {
+            this._fontDictionary.update('ToUnicode', this._cmap);
+        }
+    };
+    _UnicodeTrueTypeFont.prototype._Initialize = function () {
+        var byteArray = _decode(this._fontString);
+        this._fontData = byteArray;
+        this._ttfReader = new _TrueTypeReader(this._fontData);
+        this._ttfMetrics = this._ttfReader._metrics;
+    };
+    _UnicodeTrueTypeFont.prototype._createInternals = function () {
+        this._fontDictionary = new _PdfDictionary();
+        this._descendantFont = new _PdfDictionary();
+        this._metrics = new _PdfFontMetrics();
+        this._ttfReader._createInternals();
+        this._usedChars = null;
+        var data = []; // eslint-disable-line
+        this._fontProgram = new _PdfStream(data, new _PdfDictionary());
+        this._cmap = new _PdfStream(data, new _PdfDictionary());
+        this._ttfMetrics = this._ttfReader._metrics;
+        this._initializeMetrics();
+        this._subsetName = this._getFontName();
+        this._createDescendantFont();
+        this._createFontDictionary();
+    };
+    _UnicodeTrueTypeFont.prototype._getInternals = function () {
+        return this._fontDictionary;
+    };
+    _UnicodeTrueTypeFont.prototype._initializeMetrics = function () {
+        var ttfMetrics = this._ttfReader._metrics;
+        this._metrics._ascent = ttfMetrics._macAscent;
+        this._metrics._descent = ttfMetrics._macDescent;
+        this._metrics._height = ttfMetrics._macAscent - ttfMetrics._macDescent + ttfMetrics._lineGap;
+        this._metrics._name = ttfMetrics._fontFamily;
+        this._metrics._postScriptName = ttfMetrics._postScriptName;
+        this._metrics._size = this._fontSize;
+        this._metrics._widthTable = new _StandardWidthTable(ttfMetrics._widthTable);
+        this._metrics._lineGap = ttfMetrics._lineGap;
+        this._metrics._subScriptSizeFactor = ttfMetrics._subScriptSizeFactor;
+        this._metrics._superscriptSizeFactor = ttfMetrics._superscriptSizeFactor;
+        this._metrics._isBold = ttfMetrics._isBold;
+    };
+    _UnicodeTrueTypeFont.prototype._getFontName = function () {
+        var builder = '';
+        for (var i = 0; i < 6; i++) {
+            var index = Math.floor(Math.random() * (25 - 0 + 1)) + 0;
+            builder += this._nameString[Number.parseInt(index.toString(), 10)];
+        }
+        builder += '+';
+        builder += this._ttfReader._metrics._postScriptName;
+        return builder.toString();
+    };
+    _UnicodeTrueTypeFont.prototype._createDescendantFont = function () {
+        this._descendantFont = new _PdfDictionary();
+        this._descendantFont._updated = true;
+        this._descendantFont.set('Type', new _PdfName('Font'));
+        this._descendantFont.set('Subtype', new _PdfName('CIDFontType2'));
+        this._descendantFont.set('BaseFont', new _PdfName(this._subsetName));
+        this._descendantFont.set('CIDToGIDMap', new _PdfName('Identity'));
+        this._descendantFont.set('DW', 1000);
+        this._fontDescriptor = this._createFontDescriptor();
+        this._descendantFont.set('FontDescriptor', this._fontDescriptor);
+        var systemInfo = this._createSystemInfo();
+        this._descendantFont.set('CIDSystemInfo', systemInfo);
+        this._descendantFont._isFont = true;
+    };
+    _UnicodeTrueTypeFont.prototype._createFontDescriptor = function () {
+        var descriptor = new _PdfDictionary();
+        var metrics = this._ttfReader._metrics;
+        descriptor.set('Type', new _PdfName('FontDescriptor'));
+        descriptor.set('FontName', new _PdfName(this._subsetName));
+        descriptor.set('Flags', this._getDescriptorFlags());
+        descriptor.set('FontBBox', this._getBoundBox());
+        descriptor.set('MissingWidth', metrics._widthTable[32]);
+        descriptor.set('StemV', metrics._stemV);
+        descriptor.set('ItalicAngle', metrics._italicAngle);
+        descriptor.set('CapHeight', metrics._capHeight);
+        descriptor.set('Ascent', metrics._winAscent);
+        descriptor.set('Descent', metrics._winDescent);
+        descriptor.set('Leading', metrics._leading);
+        descriptor.set('AvgWidth', metrics._widthTable[32]);
+        descriptor.set('MaxWidth', metrics._widthTable[32]);
+        descriptor.set('XHeight', 0);
+        descriptor.set('StemH', 0);
+        descriptor._updated = true;
+        return descriptor;
+    };
+    _UnicodeTrueTypeFont.prototype._generateFontProgram = function () {
+        var fontProgram = [];
+        this._usedChars = (this._usedChars === null || typeof this._usedChars === 'undefined') ? new Dictionary()
+            : this._usedChars;
+        this._ttfReader._setOffset(0);
+        fontProgram = this._ttfReader._readFontProgram(this._usedChars);
+        this._fontProgram._clearStream();
+        this._fontProgram._writeBytes(fontProgram);
+    };
+    _UnicodeTrueTypeFont.prototype._getBoundBox = function () {
+        var rect = this._ttfReader._metrics._fontBox;
+        var width = Math.abs(rect[2] - rect[0]);
+        var height = Math.abs(rect[1] - rect[3]);
+        var rectangle = [rect[0], rect[3], width, height];
+        return rectangle;
+    };
+    _UnicodeTrueTypeFont.prototype._cmapBeginSave = function () {
+        this._generateCmap();
+    };
+    _UnicodeTrueTypeFont.prototype._fontProgramBeginSave = function () {
+        this._generateFontProgram();
+    };
+    _UnicodeTrueTypeFont.prototype._toHexString = function (n, isCaseChange) {
+        var s = n.toString(16);
+        if (isCaseChange) {
+            s = s.toUpperCase();
+        }
+        return '<0000'.substring(0, 5 - s.length) + s + '>';
+    };
+    _UnicodeTrueTypeFont.prototype._generateCmap = function () {
+        if (this._usedChars !== null && typeof this._usedChars !== 'undefined' && this._usedChars._size() > 0) {
+            var glyphChars = this._ttfReader._getGlyphChars(this._usedChars);
+            if (glyphChars._size() > 0) {
+                var keys = glyphChars.keys().sort();
+                var first = keys[0];
+                var last = keys[keys.length - 1];
+                var middlePart = this._toHexString(first, false) + this._toHexString(last, false) + '\r\n';
+                var builder = '';
+                builder += this._cmapPrefix;
+                builder += middlePart;
+                builder += this._cmapEndCodeSpaceRange;
+                var nextRange = 0;
+                for (var i = 0; i < keys.length; i++) {
+                    if (nextRange === 0) {
+                        if (i !== 0) {
+                            builder += this._cmapEndRange;
+                        }
+                        nextRange = Math.min(100, keys.length - i);
+                        builder += nextRange;
+                        builder += ' ';
+                        builder += this._cmapBeginRange;
+                    }
+                    nextRange -= 1;
+                    var key = keys[Number.parseInt(i.toString(), 10)];
+                    builder += this._toHexString(key, true) + this._toHexString(key, true);
+                    builder += this._toHexString(glyphChars.getValue(key), true) + '\n';
+                }
+                builder += this._cmapSuffix;
+                this._cmap._clearStream();
+                this._cmap._write(builder);
+            }
+        }
+    };
+    _UnicodeTrueTypeFont.prototype._createFontDictionary = function () {
+        this._fontDictionary._updated = true;
+        this._fontDictionary.set('Type', _PdfName.get('Font'));
+        this._fontDictionary.set('Subtype', _PdfName.get('Type0'));
+        this._fontDictionary.set('BaseFont', new _PdfName(this._subsetName));
+        this._fontDictionary.set('Encoding', _PdfName.get('Identity-H'));
+        this._fontDictionary.set('DescendantFonts', this._descendantFont);
+        this._fontDictionary._isFont = true;
+        this._fontDictionary._currentObj = this;
+    };
+    _UnicodeTrueTypeFont.prototype._createSystemInfo = function () {
+        var systemInfo = new _PdfDictionary();
+        systemInfo._updated = true;
+        systemInfo.set('Registry', 'Adobe');
+        systemInfo.set('Ordering', 'Identity');
+        systemInfo.set('Supplement', 0);
+        return systemInfo;
+    };
+    _UnicodeTrueTypeFont.prototype._getDescriptorFlags = function () {
+        var flags = 0;
+        var metrics = this._ttfReader._metrics;
+        if (metrics._isFixedPitch) {
+            flags |= _FontDescriptorFlag.fixedPitch;
+        }
+        if (metrics._isSymbol) {
+            flags |= _FontDescriptorFlag.symbolic;
+        }
+        else {
+            flags |= _FontDescriptorFlag.nonSymbolic;
+        }
+        if (metrics._isItalic) {
+            flags |= _FontDescriptorFlag.italic;
+        }
+        if (metrics._isBold) {
+            flags |= _FontDescriptorFlag.forceBold;
+        }
+        return flags;
+    };
+    _UnicodeTrueTypeFont.prototype._getCharacterWidth = function (charCode) {
+        var codeWidth = this._ttfReader._getCharacterWidth(charCode);
+        return codeWidth;
+    };
+    _UnicodeTrueTypeFont.prototype._setSymbols = function (text) {
+        if (text !== null && typeof text !== 'undefined') {
+            if (this._usedChars === null || typeof this._usedChars === 'undefined') {
+                this._usedChars = new Dictionary();
+            }
+            for (var i = 0; i < text.length; i++) {
+                var ch = text[Number.parseInt(i.toString(), 10)];
+                this._usedChars.setValue(ch, String.fromCharCode(0));
+            }
+        }
+    };
+    _UnicodeTrueTypeFont.prototype._getDescendantWidth = function () {
+        var array = new Array(); // eslint-disable-line
+        if (this._usedChars !== null && typeof this._usedChars !== 'undefined' && this._usedChars._size() > 0) {
+            var glyphInfo = [];
+            var keys = this._usedChars.keys();
+            for (var i = 0; i < keys.length; i++) {
+                var chLen = keys[Number.parseInt(i.toString(), 10)];
+                var glyph = this._ttfReader._getGlyph(chLen);
+                glyphInfo.push(glyph);
+            }
+            glyphInfo.sort(function (a, b) { return a._index - b._index; });
+            var firstGlyphIndex = 0;
+            var lastGlyphIndex = 0;
+            var firstGlyphIndexWasSet = false;
+            var widthDetails = new Array(); // eslint-disable-line
+            for (var i = 0; i < glyphInfo.length; i++) {
+                var glyph = glyphInfo[Number.parseInt(i.toString(), 10)];
+                if (!firstGlyphIndexWasSet) {
+                    firstGlyphIndexWasSet = true;
+                    firstGlyphIndex = glyph._index;
+                    lastGlyphIndex = glyph._index - 1;
+                }
+                if ((lastGlyphIndex + 1 !== glyph._index || (i + 1 === glyphInfo.length)) && glyphInfo.length > 1) {
+                    array.push(Number(firstGlyphIndex));
+                    if (i !== 0) {
+                        array.push(widthDetails);
+                    }
+                    firstGlyphIndex = glyph._index;
+                    widthDetails = new Array(); // eslint-disable-line
+                }
+                widthDetails.push(Number(glyph._width));
+                if ((i + 1) === glyphInfo.length) {
+                    array.push(Number(firstGlyphIndex));
+                    array.push(widthDetails);
+                }
+                lastGlyphIndex = glyph._index;
+            }
+        }
+        return array;
+    };
+    return _UnicodeTrueTypeFont;
+}());
+export { _UnicodeTrueTypeFont };