@syncfusion/ej2-pdf-export 20.2.36 → 20.2.38

package/dist/ts/implementation/graphics/fonts/rtl/rtl-text-shape.ts

@@ -1,374 +0,0 @@
-/**
- * ArabicShapeRenderer.ts class for EJ2-PDF
- */
-import { Dictionary} from './../../../collections/dictionary';
-export class ArabicShapeRenderer {
-        //#region Constants
-        private readonly arabicCharTable : string[][] = [['\u0621', '\uFE80'], ['\u0622', '\uFE81', '\uFE82'],
-            ['\u0623', '\uFE83', '\uFE84'],
-            ['\u0624', '\uFE85', '\uFE86'],
-            ['\u0625', '\uFE87', '\uFE88'],
-            ['\u0626', '\uFE89', '\uFE8A', '\uFE8B', '\uFE8C'],
-            ['\u0627', '\uFE8D', '\uFE8E'],
-            ['\u0628', '\uFE8F', '\uFE90', '\uFE91', '\uFE92'],
-            ['\u0629', '\uFE93', '\uFE94'],
-            ['\u062A', '\uFE95', '\uFE96', '\uFE97', '\uFE98'],
-            ['\u062B', '\uFE99', '\uFE9A', '\uFE9B', '\uFE9C'],
-            ['\u062C', '\uFE9D', '\uFE9E', '\uFE9F', '\uFEA0'],
-            ['\u062D', '\uFEA1', '\uFEA2', '\uFEA3', '\uFEA4'],
-            ['\u062E', '\uFEA5', '\uFEA6', '\uFEA7', '\uFEA8'],
-            ['\u062F', '\uFEA9', '\uFEAA'],
-            ['\u0630', '\uFEAB', '\uFEAC'],
-            ['\u0631', '\uFEAD', '\uFEAE'],
-            ['\u0632', '\uFEAF', '\uFEB0'],
-            ['\u0633', '\uFEB1', '\uFEB2', '\uFEB3', '\uFEB4'],
-            ['\u0634', '\uFEB5', '\uFEB6', '\uFEB7', '\uFEB8'],
-            ['\u0635', '\uFEB9', '\uFEBA', '\uFEBB', '\uFEBC'],
-            ['\u0636', '\uFEBD', '\uFEBE', '\uFEBF', '\uFEC0'],
-            ['\u0637', '\uFEC1', '\uFEC2', '\uFEC3', '\uFEC4'],
-            ['\u0638', '\uFEC5', '\uFEC6', '\uFEC7', '\uFEC8'],
-            ['\u0639', '\uFEC9', '\uFECA', '\uFECB', '\uFECC'],
-            ['\u063A', '\uFECD', '\uFECE', '\uFECF', '\uFED0'],
-            ['\u0640', '\u0640', '\u0640', '\u0640', '\u0640'],
-            ['\u0641', '\uFED1', '\uFED2', '\uFED3', '\uFED4'],
-            ['\u0642', '\uFED5', '\uFED6', '\uFED7', '\uFED8'],
-            ['\u0643', '\uFED9', '\uFEDA', '\uFEDB', '\uFEDC'],
-            ['\u0644', '\uFEDD', '\uFEDE', '\uFEDF', '\uFEE0'],
-            ['\u0645', '\uFEE1', '\uFEE2', '\uFEE3', '\uFEE4'],
-            ['\u0646', '\uFEE5', '\uFEE6', '\uFEE7', '\uFEE8'],
-            ['\u0647', '\uFEE9', '\uFEEA', '\uFEEB', '\uFEEC'],
-            ['\u0648', '\uFEED', '\uFEEE'],
-            ['\u0649', '\uFEEF', '\uFEF0', '\uFBE8', '\uFBE9'],
-            ['\u064A', '\uFEF1', '\uFEF2', '\uFEF3', '\uFEF4'],
-            ['\u0671', '\uFB50', '\uFB51'],
-            ['\u0679', '\uFB66', '\uFB67', '\uFB68', '\uFB69'],
-            ['\u067A', '\uFB5E', '\uFB5F', '\uFB60', '\uFB61'],
-            ['\u067B', '\uFB52', '\uFB53', '\uFB54', '\uFB55'],
-            ['\u067E', '\uFB56', '\uFB57', '\uFB58', '\uFB59'],
-            ['\u067F', '\uFB62', '\uFB63', '\uFB64', '\uFB65'],
-            ['\u0680', '\uFB5A', '\uFB5B', '\uFB5C', '\uFB5D'],
-            ['\u0683', '\uFB76', '\uFB77', '\uFB78', '\uFB79'],
-            ['\u0684', '\uFB72', '\uFB73', '\uFB74', '\uFB75'],
-            ['\u0686', '\uFB7A', '\uFB7B', '\uFB7C', '\uFB7D'],
-            ['\u0687', '\uFB7E', '\uFB7F', '\uFB80', '\uFB81'],
-            ['\u0688', '\uFB88', '\uFB89'],
-            ['\u068C', '\uFB84', '\uFB85'],
-            ['\u068D', '\uFB82', '\uFB83'],
-            ['\u068E', '\uFB86', '\uFB87'],
-            ['\u0691', '\uFB8C', '\uFB8D'],
-            ['\u0698', '\uFB8A', '\uFB8B'],
-            ['\u06A4', '\uFB6A', '\uFB6B', '\uFB6C', '\uFB6D'],
-            ['\u06A6', '\uFB6E', '\uFB6F', '\uFB70', '\uFB71'],
-            ['\u06A9', '\uFB8E', '\uFB8F', '\uFB90', '\uFB91'],
-            ['\u06AD', '\uFBD3', '\uFBD4', '\uFBD5', '\uFBD6'],
-            ['\u06AF', '\uFB92', '\uFB93', '\uFB94', '\uFB95'],
-            ['\u06B1', '\uFB9A', '\uFB9B', '\uFB9C', '\uFB9D'],
-            ['\u06B3', '\uFB96', '\uFB97', '\uFB98', '\uFB99'],
-            ['\u06BA', '\uFB9E', '\uFB9F'],
-            ['\u06BB', '\uFBA0', '\uFBA1', '\uFBA2', '\uFBA3'],
-            ['\u06BE', '\uFBAA', '\uFBAB', '\uFBAC', '\uFBAD'],
-            ['\u06C0', '\uFBA4', '\uFBA5'],
-            ['\u06C1', '\uFBA6', '\uFBA7', '\uFBA8', '\uFBA9'],
-            ['\u06C5', '\uFBE0', '\uFBE1'],
-            ['\u06C6', '\uFBD9', '\uFBDA'],
-            ['\u06C7', '\uFBD7', '\uFBD8'],
-            ['\u06C8', '\uFBDB', '\uFBDC'],
-            ['\u06C9', '\uFBE2', '\uFBE3'],
-            ['\u06CB', '\uFBDE', '\uFBDF'],
-            ['\u06CC', '\uFBFC', '\uFBFD', '\uFBFE', '\uFBFF'],
-            ['\u06D0', '\uFBE4', '\uFBE5', '\uFBE6', '\uFBE7'],
-            ['\u06D2', '\uFBAE', '\uFBAF'],
-            ['\u06D3', '\uFBB0', '\uFBB1']
-        ];
-        private readonly alef : string = '\u0627';
-        private readonly alefHamza : string = '\u0623';
-        private readonly alefHamzaBelow : string = '\u0625';
-        private readonly alefMadda : string = '\u0622';
-        private readonly lam : string = '\u0644';
-        private readonly hamza : string = '\u0621';
-        private readonly zeroWidthJoiner : string = '\u200D';
-        private readonly hamzaAbove : string = '\u0654';
-        private readonly hamzaBelow : string = '\u0655';
-        private readonly wawHamza : string = '\u0624';
-        private readonly yehHamza : string = '\u0626';
-        private readonly waw : string = '\u0648';
-        private readonly alefMaksura : string = '\u0649';
-        private readonly yeh : string = '\u064A';
-        private readonly farsiYeh : string = '\u06CC';
-        private readonly shadda : string = '\u0651';
-        private readonly madda : string = '\u0653';
-        private readonly lwa : string = '\uFEFB';
-        private readonly lwawh : string = '\uFEF7';
-        private readonly lwawhb : string = '\uFEF9';
-        private readonly lwawm : string = '\uFEF5';
-        private readonly bwhb : string = '\u06D3';
-        private readonly fathatan : string = '\u064B';
-        private readonly superScriptalef : string = '\u0670';
-        private readonly vowel : number = 0x1;
-       // #endregion
-        //#region Fields
-        private  arabicMapTable : Dictionary<string, string[]>  = new Dictionary<string, string[]>();
-        //#endregion
-        //#region Constructor
-        public constructor() {
-            for (let i : number = 0; i < this.arabicCharTable.length; i++) {
-                this.arabicMapTable.setValue(this.arabicCharTable[i][0], this.arabicCharTable[i]);
-            }
-        }
-        //#endregion
-        //#region implementation
-        private getCharacterShape( input : string, index : number) : string {
-            if ((input >= this.hamza) && (input <= this.bwhb)) {
-                let value : string[] = [];
-                if (this.arabicMapTable.getValue(input)) {
-                    value = this.arabicMapTable.getValue(input);
-                    return value[index + 1];
-                }
-            } else if (input >= this.lwawm && input <= this.lwa) {
-                return (input) as string;
-            }
-            return input;
-        }
-        public shape( text : string, level : number) : string {
-            let builder : string = '';
-            let str2 : string = '';
-            for (let i : number = 0; i < text.length; i++) {
-                let c : string = text[i];
-                if (c >= '؀'  && c <= 'ۿ') {
-                //if(c>= 0x0600.toString() && c<= 0x06FF.toString()) {
-                    str2 = str2 + c;
-                } else {
-                    if (str2.length > 0) {
-                        let st : string = this.doShape(str2.toString(), 0);
-                        builder = builder + st;
-                        str2 = '';
-                    }
-                    builder = builder + c;
-                }
-            }
-            if (str2.length > 0) {
-                let st : string = this.doShape(str2.toString(), 0);
-                builder = builder + st;
-            }
-            return builder.toString();
-        }
-        private doShape(input : string, level: number) : string {
-            let str : string = '';
-            let ligature : number = 0;
-            let len : number = 0;
-            let i : number = 0;
-            let next : string = '';
-            let previous : ArabicShape = new ArabicShape();
-            let present : ArabicShape = new ArabicShape();
-            while (i < input.length) {
-                next = input[i++];
-                ligature = this.ligature(next, present);
-                if (ligature === 0) {
-                    let shapeCount : number = this.getShapeCount(next);
-                    len = (shapeCount === 1) ? 0 : 2;
-                    if (previous.Shapes > 2) {
-                        len += 1;
-                    }
-                    len = len % (present.Shapes);
-                    present.Value = this.getCharacterShape(present.Value, len);
-                    str = this.append(str, previous, level);
-                    previous = present;
-                    present = new ArabicShape();
-                    present.Value = next;
-                    present.Shapes = shapeCount;
-                    present.Ligature++;
-                }
-            }
-            len = (previous.Shapes > 2) ? 1 : 0;
-            len = len % (present.Shapes);
-            present.Value = this.getCharacterShape(present.Value, len);
-            str = this.append(str, previous, level);
-            str = this.append(str, present, level);
-            return str.toString();
-        }
-        private append( builder : string, shape : ArabicShape, level : number) : string {
-            if (shape.Value !== '') {
-                builder = builder + shape.Value;
-                shape.Ligature -= 1;
-                if (shape.Type !== '') {
-                    if ((level &  this.vowel) === 0) {
-                        builder = builder + shape.Type;
-                        shape.Ligature -= 1;
-                    } else {
-                        shape.Ligature -= 1;
-                    }
-                }
-                if (shape.vowel !== '') {
-                    if ((level &  this.vowel) === 0) {
-                        builder = builder + shape.vowel;
-                        shape.Ligature -= 1;
-                    } else {
-                        shape.Ligature -= 1;
-                    }
-                }
-            }
-            return builder;
-        }
-        private ligature(value : string, shape : ArabicShape): number {
-            if (shape.Value !== '') {
-                let result : number = 0;
-                if ((value >=  this.fathatan && value <=  this.hamzaBelow) || value === this.superScriptalef) {
-                    result = 1;
-                    if ((shape.vowel !== '') && (value !==  this.shadda)) {
-                        result = 2;
-                    }
-                    if (value ===  this.shadda) {
-                        if (shape.Type == null) {
-                            shape.Type =  this.shadda;
-                        } else {
-                            return 0;
-                        }
-                    } else if (value ===  this.hamzaBelow) {
-                        if (shape.Value ===  this.alef) {
-                            shape.Value =  this.alefHamzaBelow;
-                            result = 2;
-                        } else if (value ===  this.lwa) {
-                            shape.Value =  this.lwawhb;
-                            result = 2;
-                        } else {
-                            shape.Type =  this.hamzaBelow;
-                        }
-                    } else if (value ===  this.hamzaAbove) {
-                        if (shape.Value ===  this.alef) {
-                            shape.Value =  this.alefHamza;
-                            result = 2;
-                        } else if (shape.Value ===  this.lwa) {
-                            shape.Value =  this.lwawh;
-                            result = 2;
-                        } else if (shape.Value ===  this.waw) {
-                            shape.Value =  this.wawHamza;
-                            result = 2;
-                        } else if (shape.Value ===  this.yeh || shape.Value ===  this.alefMaksura || shape.Value ===  this.farsiYeh) {
-                            shape.Value = this.yehHamza;
-                            result = 2;
-                        } else {
-                            shape.Type =  this.hamzaAbove;
-                        }
-                    } else if (value === this.madda) {
-                        if (shape.Value ===  this.alef) {
-                            shape.Value =  this.alefMadda;
-                            result = 2;
-                        }
-                    } else {
-                        shape.vowel = value;
-                    }
-                    if (result === 1) {
-                        shape.Ligature++;
-                    }
-                    return result;
-                }
-                if (shape.vowel !== '') {
-                     return 0;
-                }
-                if (shape.Value ===  this.lam) {
-                    if (value ===  this.alef) {
-                        shape.Value = this.lwa;
-                        shape.Shapes = 2;
-                        result = 3;
-                    } else if (value === this.alefHamza) {
-                        shape.Value = this.lwawh;
-                        shape.Shapes = 2;
-                        result = 3;
-                    } else if (value === this.alefHamzaBelow) {
-                        shape.Value = this.lwawhb;
-                        shape.Shapes = 2;
-                        result = 3;
-                    } else if (value === this.alefMadda) {
-                        shape.Value = this.lwawm;
-                        shape.Shapes = 2;
-                        result = 3;
-                    }
-                }
-                // else if (shape.Value === '') {
-                //     shape.Value = value;
-                //     shape.Shapes = this.getShapeCount(value);
-                //     result = 1;
-                // }
-                return result;
-            } else {
-                return 0;
-            }
-        }
-        private getShapeCount(shape : string): number {
-            if ((shape >= this.hamza) && (shape <= this.bwhb) && !((shape >= this.fathatan && shape <= this.hamzaBelow)
-                        || shape === this.superScriptalef)) {
-                let c : string[] = [];
-                if (this.arabicMapTable.getValue(shape)) {
-                    c = this.arabicMapTable.getValue(shape);
-                    return c.length - 1;
-                }
-            } else if (shape === this.zeroWidthJoiner) {
-                return 4;
-            }
-            return 1;
-        }
-    }
-        //#endregion
-        //#region Internals
-        export class ArabicShape {
-            //#region Fields
-            private  shapeValue : string = '';
-            private  shapeType : string = '';
-            private  shapeVowel : string = '';
-            private  shapeLigature : number = 0;
-            private  shapeShapes : number = 1;
-            //#endregion
-            //#region Properties 
-            /**
-             * Gets or sets the values.
-             * @private
-             */
-            public get Value() : string {
-                return this.shapeValue;
-            }
-            public set Value(value : string) {
-                this.shapeValue = value;
-            }
-            /**
-             * Gets or sets the values.
-             * @private
-             */
-            public get Type() : string {
-                return this.shapeType;
-            }
-            public set Type(value : string) {
-                this.shapeType = value;
-            }
-            /**
-             * Gets or sets the values.
-             * @private
-             */
-            public get vowel() : string {
-                return this.shapeVowel;
-            }
-            public set vowel(value : string) {
-                this.shapeVowel = value;
-            }
-            /**
-             * Gets or sets the values.
-             * @private
-             */
-            public get Ligature() : number {
-                return this.shapeLigature;
-            }
-            public set Ligature(value : number) {
-                this.shapeLigature = value;
-            }
-            /**
-             * Gets or sets the values.
-             * @private
-             */
-            public get Shapes() : number {
-                return this.shapeShapes;
-            }
-            public set Shapes(value : number) {
-                this.shapeShapes = value;
-            }
-            //#endregion
-    }
-        //#endregion

package/dist/ts/implementation/graphics/fonts/rtl-renderer.ts

@@ -1,255 +0,0 @@
-/**
- * RTL-Renderer.ts class for EJ2-PDF
- */
-import { PdfStringFormat } from './pdf-string-format';
-import { PdfTrueTypeFont}  from './pdf-true-type-font';
-import { UnicodeTrueTypeFont } from './unicode-true-type-font';
-import { TtfReader} from './ttf-reader';
-import { PdfString} from './../../primitives/pdf-string';
-import { ArabicShapeRenderer} from './rtl/rtl-text-shape';
-import { PdfTextDirection} from './../enum';
-import { Bidi} from './rtl/rtl-bidirectional';
-import { TtfGlyphInfo } from './ttf-glyph-info';
-/**
- * `Metrics` of the font.
- * @private
- */
-export class RtlRenderer {
-//region Constants
-        /// Open bracket symbol.
-        /// </summary>
-        private readonly openBracket : string = '(';
-        /// <summary>
-        /// Close bracket symbol.
-        /// </summary>
-        private readonly closeBracket : string = ')';
-        //#region Constructors
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RtlRenderer"/> class.
-        /// </summary>
-        // public constructor() {
-        // }
-        //#region Public Methods
-        /// <summary>
-        /// Layouts text. Changes blocks position in the RTL text.
-        /// Ligates the text if needed.
-        /// </summary>
-        /// <param name="line">Line of the text.</param>
-        /// <param name="font">Font to be used for string printing.</param>
-        /// <param name="rtl">Font alignment.</param>
-        /// <param name="wordSpace">Indicates whether Word Spacing used or not.</param>
-        /// <returns>Layout string.</returns>
-        public layout(line : string,  font : PdfTrueTypeFont, rtl : boolean, wordSpace : boolean,  format : PdfStringFormat) : string[] {
-            if (line == null) {
-                throw new Error('ArgumentNullException : line');
-            }
-            if (font == null) {
-                throw new Error('ArgumentNullException : font');
-            }
-            let result : string[] = [];
-            if (font.Unicode) {
-                result = this.customLayout(line, rtl, format , font , wordSpace);
-            } else {
-                result = [];
-                result[0] = line;
-            }
-            return result;
-        }
-        /// <summary>
-        /// Layouts a string and splits it by the words and using correct lay outing.
-        /// </summary>
-        /// <param name="line">Text line.</param>
-        /// <param name="font">Font object.</param>
-        /// <param name="rtl">Indicates whether RTL should be applied.</param>
-        /// <param name="wordSpace">Indicates whether word spacing is used.</param>
-        /// <returns>Array of words if converted, null otherwise.</returns>
-        public splitLayout( line : string, font : PdfTrueTypeFont, rtl : boolean, wordSpace : boolean, format : PdfStringFormat): string[] {
-            if (line == null) {
-                throw new Error('ArgumentNullException : line');
-            }
-            if (font == null) {
-                throw new Error('ArgumentNullException : font');
-            }
-            let words : string[] = [];
-            let system : boolean = false;
-            if (!system || words == null) {
-                words = this.customSplitLayout(line, font, rtl, wordSpace, format);
-            }
-            return words;
-        }
-//#endregion
-//#region Implementation
-            // private isEnglish( word : string) : boolean
-            // {
-            //     let c : string = (word.length > 0) ? word[0] : '';
-            //     return (c >= '0' && c < 'ÿ');
-            // }
-            // private keepOrder( words : string, startIndex : number, count: number, result : string[], resultIndex : number) : void
-            // {
-            //     for (let i : number = 0, ri = resultIndex - count + 1; i < count; ++i, ++ri) {
-            //         result[ri] = words[i + startIndex];
-            //     }
-            // }
-        /// <summary>
-        /// Uses system API to layout the text.
-        /// </summary>
-        /// <param name="line">Line of the text to be layouted.</param>
-        /// <param name="font">Font which is used for text printing.</param>
-        /// <param name="rtl">Indicates whether we use RTL or RTL lay outing of the text container.</param>
-        /// <returns>Layout string.</returns>
-        /* tslint:disable-next-line:max-line-length */
-        public getGlyphIndex( line : string, font : PdfTrueTypeFont, rtl : boolean, /*out*/ glyphs : Uint16Array, custom ?: boolean | null) : { success : boolean, glyphs : Uint16Array } {
-                let success : boolean = true;
-                let fail : boolean = false;
-                if (line == null) {
-                    throw new Error('ArgumentNullException : line');
-                }
-                if (font == null) {
-                    throw new Error('ArgumentNullException : font');
-                }
-                glyphs = null;
-                if (line.length === 0) {
-                    return { success : fail, glyphs : glyphs };
-                }
-                let renderer : ArabicShapeRenderer = new ArabicShapeRenderer();
-                let text : string = renderer.shape(line, 0);
-                let internalFont : UnicodeTrueTypeFont = font.fontInternal as UnicodeTrueTypeFont;
-                let ttfReader : TtfReader = internalFont.ttfReader;
-                glyphs = new Uint16Array(text.length);
-                let i : number = 0;
-                for (let k : number = 0, len : number = text.length; k < len; k++) {
-                    let ch : string = text[k];
-                    let glyphInfo : TtfGlyphInfo = ttfReader.getGlyph(ch);
-                    if ( glyphInfo !== null && typeof glyphInfo !== 'undefined' ) {
-                        glyphs[i++] = (glyphInfo).index as number;
-                    }
-                }
-                return { success : success, glyphs : glyphs };
-        }
-        /// <summary>
-        /// Uses manual algorithm for text lay outing.
-        /// </summary>
-        /// <param name="line">Line of the text to be layouted.</param>
-        /// <param name="font">Font which is used for text printing.</param>
-        /// <param name="rtl">Indicates whether we use RTL or RTL lay outing of the text container.</param>
-        /// <param name="wordSpace">If true - word spacing is used.</param>
-        /// <returns>layout string array.</returns>
-        public customLayout(line : string, rtl : boolean, format : PdfStringFormat) : string
-        public customLayout(line : string, rtl : boolean, format : PdfStringFormat, font : PdfTrueTypeFont, wordSpace : boolean): string[]
-        /* tslint:disable-next-line:max-line-length */
-        public customLayout(line : string, rtl : boolean, format : PdfStringFormat, font ?: PdfTrueTypeFont, wordSpace ?: boolean): string[] | string {
-            if (wordSpace === null || typeof wordSpace === 'undefined' ) {
-                if (line == null) {
-                    throw new Error('ArgumentNullException : line');
-                }
-                let result : string = null;
-                //bidirectional order.
-                if (format !== null && typeof format !== 'undefined' && format.textDirection !== PdfTextDirection.None) {
-                    let bidi : Bidi = new Bidi();
-                    result = bidi.getLogicalToVisualString(line, rtl);
-                }
-                return result;
-            } else {
-                if (line == null) {
-                    throw new Error('ArgumentNullException : line');
-                }
-                if (font == null) {
-                    throw new Error('ArgumentNullException : font');
-                }
-                let layouted : string = null;
-                if (format !== null && typeof format !== 'undefined' && format.textDirection !== PdfTextDirection.None) {
-                    let renderer : ArabicShapeRenderer = new ArabicShapeRenderer();
-                    let txt : string = renderer.shape(line, 0);
-                    layouted = this.customLayout(txt, rtl, format);
-                }
-                // else {
-                //     layouted = this.customLayout(line, rtl, format);
-                // }
-                // We have unicode font, but from the file.        
-                let result : string[] = [];
-                // Split the text by words if word spacing is not default.
-                if (wordSpace) {
-                    let words : string[] = layouted.split('');
-                    let count : number = words.length;
-                    for (let i : number = 0; i < count; i++) {
-                        words[i] = this.addChars(font, words[i]);
-                    }
-                    result = words;
-                } else {
-                    result = [];
-                    result[0] = this.addChars(font, layouted);
-                }
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Add information about used glyphs to the font.
-        /// </summary>
-        /// <param name="font">Font used for text rendering.</param>
-        /// <param name="glyphs">Array of used glyphs.</param>
-        /// <returns>String in the form to be written to the file.</returns>
-        public addChars( font : PdfTrueTypeFont,  glyphs : string) : string {
-                let line : string = glyphs;
-                if (font == null) {
-                    throw new Error('ArgumentNullException : font');
-                }
-                if (line == null) {
-                    throw new Error('ArgumentNullException : line');
-                }
-                let text : string = line;
-                let internalFont : UnicodeTrueTypeFont = font.fontInternal as UnicodeTrueTypeFont;
-                let ttfReader : TtfReader = internalFont.ttfReader;
-                font.setSymbols(text);
-                // Reconvert string according to unicode standard.
-                text = ttfReader.convertString(text);
-                let bytes : number[] = PdfString.toUnicodeArray(text, false);
-                text = PdfString.byteToString(bytes);
-                return text;
-            // else {
-            //     if (font == null) {
-            //         throw new Error('ArgumentNullException : font');
-            //     }
-            //     if (glyphs == null) {
-            //         throw new Error('ArgumentNullException : glyphs');
-            //     }
-            //     // Mark the chars as used.
-            //     let text : string = '';
-            //     font.setSymbols(glyphs);
-            //     // Create string from the glyphs.
-            //     
-            //     let chars : string[] = [];
-            //     for (let i : number = 0; i < glyphs.length; i++) {
-            //         chars[i] = glyphs[i].toString();
-            //     }
-            //     for (let j : number = 0 ; j < chars.length; j++) {
-            //         text = text + chars[j];
-            //     }
-            //     let bytes : number[] = PdfString.toUnicodeArray(text, false);
-            //     text = PdfString.byteToString(bytes);
-            //     return text;
-            // }
-        }
-
-        /// <summary>
-        /// Layouts a string and splits it by the words by using custom lay outing.
-        /// </summary>
-        /// <param name="line">Text line.</param>
-        /// <param name="font">Font object.</param>
-        /// <param name="rtl">Indicates whether RTL should be applied.</param>
-        /// <param name="wordSpace">Indicates whether word spacing is used.</param>
-        /// <returns>Array of words if converted, null otherwise.</returns>
-        /* tslint:disable-next-line:max-line-length */
-        public customSplitLayout(line : string, font : PdfTrueTypeFont, rtl : boolean, wordSpace : boolean, format : PdfStringFormat) : string[] {
-            if (line == null) {
-                throw new Error('ArgumentNullException : line');
-            }
-            if (font == null) {
-                throw new Error('ArgumentNullException : font');
-            }
-            let reversedLine : string  = this.customLayout(line, rtl, format);
-            let words : string[]  = reversedLine.split('');
-            return words;
-        }
-//#endregion
-    }