@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/text/engine/TextBlock.js

@@ -0,0 +1,500 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { TextFormat } from '@awayjs/scene';
+import { TextBaseline } from './TextBaseline';
+import { TextLineCreationResult } from './TextLineCreationResult';
+var noLogs = true;
+var textBlockIDs = 0;
+var textLinePool = [];
+var TextBlock = /** @class */ (function (_super) {
+    __extends(TextBlock, _super);
+    function TextBlock(content, tabStops, textJustifier, lineRotation, baselineZero, bidiLevel, applyNonLinearFontScaling, baselineFontDescription, baselineFontSize) {
+        if (content === void 0) { content = null; }
+        if (tabStops === void 0) { tabStops = null; }
+        if (textJustifier === void 0) { textJustifier = null; }
+        if (lineRotation === void 0) { lineRotation = 'rotate0'; }
+        if (baselineZero === void 0) { baselineZero = 'roman'; }
+        if (bidiLevel === void 0) { bidiLevel = 0; }
+        if (applyNonLinearFontScaling === void 0) { applyNonLinearFontScaling = true; }
+        if (baselineFontDescription === void 0) { baselineFontDescription = null; }
+        if (baselineFontSize === void 0) { baselineFontSize = 12; }
+        var _this = _super.call(this) || this;
+        _this._id = textBlockIDs++;
+        noLogs || console.log('[TextBlock]  ' + _this._id + '   - new textblock ', content, tabStops, textJustifier, lineRotation, baselineZero, bidiLevel, applyNonLinearFontScaling, baselineFontDescription, baselineFontSize);
+        _this._content = content;
+        if (content) {
+            _this._content.setTextBlock(_this);
+        }
+        _this._tabStops = tabStops;
+        _this._textJustifier = textJustifier;
+        _this._lineRotation = lineRotation;
+        _this._baselineZero = baselineZero;
+        _this._bidiLevel = bidiLevel;
+        _this._applyNonLinearFontScaling = applyNonLinearFontScaling;
+        _this._baselineFontDescription = baselineFontDescription;
+        _this._baselineFontSize = baselineFontSize;
+        _this._textLines = [];
+        _this._creationResult = null;
+        return _this;
+    }
+    TextBlock.prototype.setTextDataDirty = function () {
+        this._textData = null;
+    };
+    TextBlock.prototype._convertContentToTextData = function () {
+        if (this._textData) {
+            return this._textData;
+        }
+        this._textData = {
+            text: '',
+            formats: [],
+            elementFormats: [],
+            formatIndices: [],
+            processedIdx: 0,
+            creationResult: null,
+            spaces: {},
+            lineBreaks: {},
+            charWidths: []
+        };
+        this.resolveGroupElements(this._content);
+        if (this._textData.formatIndices[this._textData.formatIndices.length - 1] != this._textData.text.length)
+            this._textData.formatIndices.push(this._textData.text.length);
+        var formats = this._textData.formats;
+        var formatsIndicies = this._textData.formatIndices;
+        /*if (this._textData.text.charCodeAt(this._textData.text.length - 1) == 8233) {
+            this._textData.text = this._textData.text.substring(0, this._textData.text.length - 1);
+        }*/
+        var text = this._textData.text;
+        this._content.rawText = text;
+        var spaces = this._textData.spaces;
+        var lineBreaks = this._textData.lineBreaks;
+        var charWidths = this._textData.charWidths;
+        var c = 0;
+        var form_len = formats.length;
+        for (var f = 0; f < form_len; f++) {
+            var tf = formats[f];
+            tf.font_table.initFontSize(tf.size);
+            var lastChar = formatsIndicies[f];
+            for (c; c <= lastChar; c++) {
+                var char_code = text.charCodeAt(c);
+                var isLineBreak = char_code === 10 /* CHAR_CODES.LF */ || char_code === 8233;
+                if (isLineBreak) {
+                    lineBreaks[c] = 1;
+                    charWidths[charWidths.length] = 0;
+                }
+                else {
+                    charWidths[charWidths.length] = tf.font_table.getCharWidth(char_code.toString());
+                    var isSpace = char_code == 9 /* CHAR_CODES.TAB */ || char_code == 32 /* CHAR_CODES.SPACE */;
+                    if (isSpace) {
+                        spaces[c] = true;
+                    }
+                }
+            }
+        }
+    };
+    TextBlock.prototype.resolveGroupElements = function (content) {
+        if (content.axClassName == 'flash.text.engine.TextElement') {
+            var text = content.text;
+            var elementFormat = content.elementFormat;
+            var tf = void 0;
+            if (elementFormat)
+                tf = elementFormat.createAwayTextformat();
+            else {
+                tf = new TextFormat();
+            }
+            this._textData.text += text ? text : '';
+            this._textData.formats.push(tf);
+            this._textData.elementFormats.push(elementFormat);
+            this._textData.formatIndices.push(this._textData.text.length);
+        }
+        if (content.axClassName == 'flash.text.engine.GroupElement') {
+            var group = content;
+            //noLogs || console.log('resolve GroupElement', group.elementCount);
+            for (var i = 0; i < group.elementCount; i++) {
+                this.resolveGroupElements(group.getElementAt(i));
+            }
+        }
+    };
+    TextBlock.prototype.createTextLine = function (previousLine, width, lineOffset, fitSomething) {
+        if (!this._textData) {
+            this._textLines = [];
+            this._convertContentToTextData();
+        }
+        if (this._tabStops && this._tabStops.buffer.length > 0) {
+            console.warn('this._tabStops is not []', this._tabStops);
+        }
+        if (this._textJustifier && this._textJustifier.lineJustification != 'unjustified') {
+            console.warn('lineJustification is not unjustified', this._textJustifier.lineJustification);
+        }
+        if (this._textJustifier && this._textJustifier.letterSpacing != 0) {
+            console.warn('letterSpacing is not 0', this._textJustifier.letterSpacing);
+        }
+        if (this._baselineZero != TextBaseline.ROMAN) {
+            console.warn('_baselineZero is not "roman"', this._baselineZero);
+        }
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - text', this._textData.text);
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - createTextLine', '\n		width', width, '\n		previousLine', previousLine, '\n		lineOffset', lineOffset, '\n		fitSomething', fitSomething, '\n		processedIdx', this._textData.processedIdx);
+        var text = this._textData.text;
+        var processedIdx = this._textData.processedIdx;
+        if (processedIdx > text.length) {
+            this._creationResult = TextLineCreationResult.COMPLETE;
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - all textlines already complete', processedIdx, text.length);
+            return null;
+        }
+        var formats = this._textData.formats;
+        var elementFormats = this._textData.elementFormats;
+        var formatsIndicies = this._textData.formatIndices;
+        var spaces = this._textData.spaces;
+        var lineBreaks = this._textData.lineBreaks;
+        var charWidths = this._textData.charWidths;
+        var form_len = formats.length;
+        var c = processedIdx;
+        var newText = '';
+        var newWord = '';
+        var newCharCnt = 0;
+        var newFormats = [];
+        var newElementFormats = [];
+        var newFormatindices = [];
+        var result = TextLineCreationResult.EMERGENCY; // is valid if its a linebreak or at least one word that fits
+        var textWidth = 0;
+        var defaultFormat;
+        var defaultElementFormat;
+        loop1: for (var f = 0; f < form_len; f++) {
+            if (processedIdx > formatsIndicies[f]) {
+                continue;
+            }
+            var format = formats[f];
+            defaultFormat = format;
+            newFormats[newFormats.length] = format;
+            newElementFormats[newElementFormats.length] = elementFormats[f];
+            defaultElementFormat = elementFormats[f];
+            newFormatindices[newFormatindices.length] = 0;
+            var lastChar = formatsIndicies[f];
+            for (c; c <= lastChar; c++) {
+                if (lineBreaks[c] === 1) {
+                    noLogs || console.log('lineBreaks', result, c, text[c]);
+                    newText += newWord;
+                    newCharCnt += newWord.length + 1;
+                    result = TextLineCreationResult.SUCCESS;
+                    this._textData.processedIdx = c;
+                    // remove the linebreak marker so we not stuck in infinite loop
+                    lineBreaks[c] = 2;
+                    break loop1;
+                }
+                if (spaces[c]) {
+                    noLogs || console.log('space', result, c, text[c], newWord);
+                    result = TextLineCreationResult.SUCCESS;
+                    newText += newWord;
+                    newCharCnt += newWord.length;
+                    newWord = '';
+                    this._textData.processedIdx = c;
+                }
+                if (newWord.length == 1 &&
+                    (newWord.charCodeAt(0) == 32 /* CHAR_CODES.SPACE */ || newWord.charCodeAt(0) == 9 /* CHAR_CODES.TAB */)) {
+                    result = TextLineCreationResult.SUCCESS;
+                    newText += newWord;
+                    newCharCnt += newWord.length;
+                    newWord = '';
+                    this._textData.processedIdx = c;
+                }
+                textWidth += charWidths[c];
+                if (textWidth > width - 2) {
+                    noLogs || console.log('text is to wide', 'textWidth', textWidth, 'width', width, newText, result, text[c], newWord);
+                    if (result == TextLineCreationResult.SUCCESS) {
+                        break loop1;
+                    }
+                    newText += newWord;
+                    newCharCnt += newWord.length;
+                    this._textData.processedIdx = c;
+                    break loop1;
+                }
+                if (c == text.length) {
+                    newText += newWord;
+                    newCharCnt += newWord.length;
+                    this._textData.processedIdx = c + 1;
+                    break loop1;
+                }
+                if (!lineBreaks[c]) {
+                    newWord += text[c];
+                }
+                else {
+                    newWord += text[c];
+                    processedIdx++;
+                }
+            }
+            newFormatindices[newFormatindices.length - 1] = newText.length + newWord.length - 1;
+        }
+        newFormatindices[newFormatindices.length - 1] = newText.length;
+        if (this._textData.processedIdx >= text.length) {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - all text processed', this._textData.processedIdx, text.length);
+            this._textData.processedIdx++;
+            result = TextLineCreationResult.COMPLETE;
+        }
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - textline prepared', this._textData.processedIdx, "\"".concat(newText, "\""));
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - all text length', text.length, 'newCharCnt', newCharCnt, 'processedIdx', processedIdx);
+        //this._textData.processedIdx = text.length + 1;
+        if (newFormats.length == 0) {
+            newFormats[0] = defaultFormat;
+            newElementFormats[0] = defaultElementFormat;
+        }
+        var textLine;
+        for (var c_1 = 0; c_1 < textLinePool.length; c_1++) {
+            if (!textLinePool[c_1].parent && textLinePool[c_1].free) {
+                textLine = textLinePool[c_1];
+                break;
+            }
+        }
+        if (textLine) {
+            textLine.setPreviousLine(null);
+            textLine.setNextLine(null);
+            textLine['$BguserData'] = null;
+            textLine.free = false;
+            textLine.reUseTextLine(previousLine, width, lineOffset, fitSomething, newText, newFormats, newFormatindices, processedIdx, newCharCnt, newElementFormats);
+        }
+        else {
+            textLine = new this.sec.flash.text.engine.TextLine(previousLine, width, lineOffset, fitSomething, newText, newFormats, newFormatindices, processedIdx, newCharCnt, newElementFormats);
+        }
+        this._creationResult = result;
+        textLine.setTextBlock(this);
+        this._textLines.push(textLine);
+        return textLine;
+    };
+    TextBlock.prototype.recreateTextLine = function (textLine, previousLine, width, lineOffset, fitSomething) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'recreateTextLine', '');
+        return new this.sec.flash.text.engine.TextLine();
+    };
+    Object.defineProperty(TextBlock.prototype, "textLineCreationResult", {
+        get: function () {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - textLineCreationResult', this._creationResult);
+            return this._creationResult;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "applyNonLinearFontScaling", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get applyNonLinearFontScaling', '');
+            return this._applyNonLinearFontScaling;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set applyNonLinearFontScaling', '');
+            this._applyNonLinearFontScaling = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "baselineFontDescription", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get baselineFontDescription', '');
+            return this._baselineFontDescription;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set baselineFontDescription', '');
+            this._baselineFontDescription = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "baselineFontSize", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get baselineFontSize', '');
+            return this._baselineFontSize;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set baselineFontSize', '');
+            this._baselineFontSize = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "baselineZero", {
+        get: function () {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - get baselineZero', this._baselineZero);
+            return this._baselineZero;
+        },
+        set: function (value) {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - set baselineZero', value);
+            this._baselineZero = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "content", {
+        get: function () {
+            //console.warn('[TextBlock]  ' + this._id + '   - get content not implemented');
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - get content', this._content);
+            return this._content;
+        },
+        set: function (value) {
+            //console.warn('[TextBlock]  ' + this._id + '   - set content not implemented');
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - set content', value);
+            this._textData = null;
+            if (this._content)
+                this._content.setTextBlock(null);
+            this._content = value;
+            if (this._content)
+                this._content.setTextBlock(this);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "bidiLevel", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get bidiLevel', '');
+            return this._bidiLevel;
+        },
+        set: function (value /*int*/) {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set bidiLevel', '');
+            this._bidiLevel = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "firstInvalidLine", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/text/engine/TextBlock', 'firstInvalidLine', '');
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "firstLine", {
+        get: function () {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - get firstLine', this._textLines.length > 0 ? this._textLines[0] : null);
+            return this._textLines.length > 0 ? this._textLines[0] : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "lastLine", {
+        get: function () {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - get lastLine', this._textLines.length > 0 ? this._textLines[this._textLines.length - 1] : null);
+            return this._textLines.length > 0 ? this._textLines[this._textLines.length - 1] : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextBlock.prototype, "lineRotation", {
+        get: function () {
+            return this._lineRotation;
+        },
+        set: function (value) {
+            this._lineRotation = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextBlock.prototype.findNextAtomBoundary = function (afterCharIndex /*int*/) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findNextAtomBoundary', '');
+        return null;
+    };
+    TextBlock.prototype.findPreviousAtomBoundary = function (beforeCharIndex /*int*/) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findPreviousAtomBoundary', '');
+        return null;
+    };
+    TextBlock.prototype.findNextWordBoundary = function (afterCharIndex /*int*/) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findNextWordBoundary', '');
+        return null;
+    };
+    TextBlock.prototype.findPreviousWordBoundary = function (beforeCharIndex /*int*/) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findPreviousWordBoundary', '');
+        return null;
+    };
+    TextBlock.prototype.getTextLineAtCharIndex = function (charIndex /*int*/) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'getTextLineAtCharIndex', '');
+        return null;
+    };
+    TextBlock.prototype.releaseLineCreationData = function () {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'releaseLineCreationData', '');
+    };
+    TextBlock.prototype.releaseLines = function (firstLine, lastLine) {
+        //console.warn('[TextBlock]  ' + this._id + '   - releaseLines not implemented');
+        if (this._textLines.length == 0)
+            return;
+        if (firstLine == this._textLines[0] && lastLine == this._textLines[this._textLines.length - 1]) {
+            if (textLinePool.length < 100) {
+                for (var i = 0; i < this._textLines.length; i++) {
+                    this._textLines[i].free = true;
+                    if (textLinePool.indexOf(this._textLines[i]) <= 0)
+                        textLinePool.push(this._textLines[i]);
+                }
+            }
+            this._textLines.length = 0;
+            return;
+        }
+        while (firstLine) {
+            var idx = this._textLines.indexOf(firstLine);
+            if (idx >= 0) {
+                this._textLines.splice(idx, 1);
+            }
+            firstLine.free = true;
+            if (textLinePool.indexOf(firstLine) <= 0)
+                textLinePool.push(firstLine);
+            if (firstLine != lastLine)
+                firstLine = firstLine.nextLine;
+            else
+                firstLine = null;
+        }
+    };
+    TextBlock.prototype.dump = function () {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'dump', '');
+        return null;
+    };
+    TextBlock.prototype.DoCreateTextLine = function (previousLine, width, lineOffset, fitSomething, reuseLine) {
+        if (lineOffset === void 0) { lineOffset = 0; }
+        if (fitSomething === void 0) { fitSomething = false; }
+        if (reuseLine === void 0) { reuseLine = null; }
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextBlock', 'DoCreateTextLine', '');
+        return null;
+    };
+    TextBlock.prototype.getTabStops = function () {
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - getTabStops', this._tabStops);
+        return this._tabStops;
+    };
+    TextBlock.prototype.setTabStops = function (value /*ASVector<flash.text.engine.TabStop>*/) {
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - setTabStops not implemented', value);
+        this._tabStops = value;
+    };
+    TextBlock.prototype.getTextJustifier = function () {
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - getTextJustifier', this._textJustifier);
+        return this._textJustifier;
+    };
+    TextBlock.prototype.setTextJustifier = function (value) {
+        noLogs || console.log('[TextBlock]  ' + this._id + '   - setTextJustifier', value);
+        this._textJustifier = value;
+    };
+    Object.defineProperty(TextBlock.prototype, "userData", {
+        get: function () {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - get userData', this._userData);
+            return this._userData;
+        },
+        set: function (value) {
+            noLogs || console.log('[TextBlock]  ' + this._id + '   - set userData', value);
+            this._userData = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextBlock.forceNativeConstructor = true;
+    TextBlock.forceNativeMethods = true;
+    return TextBlock;
+}(ASObject));
+export { TextBlock };

package/dist/lib/text/engine/TextElement.d.ts

@@ -0,0 +1,12 @@
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+export declare class TextElement extends ContentElement {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor(text?: string, elementFormat?: ElementFormat, eventMirror?: EventDispatcher, textRotation?: string);
+    set text(value: string);
+    get text(): string;
+    replaceText(beginIndex: number, endIndex: number, newText: string): void;
+}
+//# sourceMappingURL=TextElement.d.ts.map

package/dist/lib/text/engine/TextElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextElement.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/TextElement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,qBAAa,WAAY,SAAQ,cAAc;IAE9C,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;gBAGzC,IAAI,GAAE,MAAa,EACnB,aAAa,GAAE,aAAoB,EACnC,WAAW,GAAE,eAAsB,EACnC,YAAY,GAAE,MAAkB;IAYjC,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAK5B;IAED,IAAW,IAAI,IAAI,MAAM,CAGxB;IAEM,WAAW,CAAC,UAAU,EAAE,MAAM,EAAU,QAAQ,EAAE,MAAM,EAAU,OAAO,EAAE,MAAM,GAAG,IAAI;CAU/F"}

package/dist/lib/text/engine/TextElement.js

@@ -0,0 +1,45 @@
+import { __extends } from "tslib";
+import { ContentElement } from './ContentElement';
+var noLogs = true;
+var TextElement = /** @class */ (function (_super) {
+    __extends(TextElement, _super);
+    function TextElement(text, elementFormat, eventMirror, textRotation) {
+        if (text === void 0) { text = null; }
+        if (elementFormat === void 0) { elementFormat = null; }
+        if (eventMirror === void 0) { eventMirror = null; }
+        if (textRotation === void 0) { textRotation = 'rotate0'; }
+        var _this = _super.call(this, elementFormat, eventMirror, textRotation) || this;
+        _this._text = text;
+        _this._rawText = text;
+        noLogs || console.log('[TextElement] ' + _this._id + ' constructor', 'text', text);
+        return _this;
+    }
+    Object.defineProperty(TextElement.prototype, "text", {
+        get: function () {
+            noLogs || console.log('[TextElement] ' + this._id + ' get text', this._text);
+            return this._text;
+        },
+        // JS -> AS Bindings
+        // AS -> JS Bindings
+        // _text: string;
+        set: function (value) {
+            noLogs || console.log('[TextElement] ' + this._id + ' set text', value);
+            this._text = value;
+            if (this._textBlock)
+                this._textBlock.setTextDataDirty();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextElement.prototype.replaceText = function (beginIndex /*int*/, endIndex /*int*/, newText) {
+        noLogs || console.log('[TextElement] ' + this._id + ' replaceText', 'beginIndex', beginIndex, 'endIndex', endIndex, 'newText', newText);
+        this._rawText = this._text.slice(0, beginIndex) + newText + this._text.slice(endIndex, this._text.length - 1);
+        this._text = this._rawText;
+        if (this._textBlock)
+            this._textBlock.setTextDataDirty();
+    };
+    TextElement.forceNativeConstructor = true;
+    TextElement.forceNativeMethods = true;
+    return TextElement;
+}(ContentElement));
+export { TextElement };

package/dist/lib/text/engine/TextJustifier.d.ts

@@ -0,0 +1,15 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class TextJustifier extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    private _locale;
+    private _lineJustification;
+    constructor(locale: string, lineJustification: string);
+    static getJustifierForLocale(locale: string): TextJustifier;
+    clone(): TextJustifier;
+    get locale(): string;
+    get lineJustification(): string;
+    set lineJustification(value: string);
+    setLocale(value: string): void;
+}
+//# sourceMappingURL=TextJustifier.d.ts.map

package/dist/lib/text/engine/TextJustifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextJustifier.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/TextJustifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAGxD,qBAAa,aAAc,SAAQ,QAAQ;IAE1C,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;IAE1C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,kBAAkB,CAAS;gBAEvB,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;WAMvC,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa;IAO3D,KAAK,IAAI,aAAa;IAM7B,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED,IAAW,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAEzC;IAEM,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAGrC"}

package/dist/lib/text/engine/TextJustifier.js

@@ -0,0 +1,46 @@
+import { __extends } from "tslib";
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+var TextJustifier = /** @class */ (function (_super) {
+    __extends(TextJustifier, _super);
+    function TextJustifier(locale, lineJustification) {
+        var _this = _super.call(this) || this;
+        _this._locale = axCoerceString(locale);
+        _this._lineJustification = axCoerceString(lineJustification);
+        return _this;
+    }
+    TextJustifier.getJustifierForLocale = function (locale) {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextJustifier', 'getJustifierForLocale', '');
+        return null;
+    };
+    TextJustifier.prototype.clone = function () {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/TextJustifier', 'clone', '');
+        return null;
+    };
+    Object.defineProperty(TextJustifier.prototype, "locale", {
+        get: function () {
+            return this._locale;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextJustifier.prototype, "lineJustification", {
+        get: function () {
+            return this._lineJustification;
+        },
+        set: function (value) {
+            this._lineJustification = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextJustifier.prototype.setLocale = function (value) {
+        this._locale = axCoerceString(value);
+    };
+    TextJustifier.forceNativeConstructor = true;
+    TextJustifier.forceNativeMethods = true;
+    return TextJustifier;
+}(ASObject));
+export { TextJustifier };