@afterswf/playerglobal 0.0.0-stage → 0.2.460

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

@@ -0,0 +1,291 @@
+import { __extends } from "tslib";
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { TextFormat, TextFormatAlign } from '@awayjs/scene';
+import { FontLookUpMode } from '@awayjs/scene';
+import { TextBaseline } from './TextBaseline';
+import { Debug } from '@awayjs/core';
+var noLogs = true;
+var elementFormatIDs = 0;
+var ElementFormat = /** @class */ (function (_super) {
+    __extends(ElementFormat, _super);
+    function ElementFormat(fontDescription, fontSize, color, alpha, textRotation, dominantBaseline, alignmentBaseline, baselineShift, kerning, trackingRight, trackingLeft, locale, breakOpportunity, digitCase, digitWidth, ligatureLevel, typographicCase) {
+        if (fontDescription === void 0) { fontDescription = null; }
+        if (fontSize === void 0) { fontSize = 12; }
+        if (color === void 0) { color = 0; }
+        if (alpha === void 0) { alpha = 1; }
+        if (textRotation === void 0) { textRotation = 'auto'; }
+        if (dominantBaseline === void 0) { dominantBaseline = 'roman'; }
+        if (alignmentBaseline === void 0) { alignmentBaseline = 'useDominantBaseline'; }
+        if (baselineShift === void 0) { baselineShift = 0; }
+        if (kerning === void 0) { kerning = 'on'; }
+        if (trackingRight === void 0) { trackingRight = 0; }
+        if (trackingLeft === void 0) { trackingLeft = 0; }
+        if (locale === void 0) { locale = 'en'; }
+        if (breakOpportunity === void 0) { breakOpportunity = 'auto'; }
+        if (digitCase === void 0) { digitCase = 'default'; }
+        if (digitWidth === void 0) { digitWidth = 'default'; }
+        if (ligatureLevel === void 0) { ligatureLevel = 'common'; }
+        if (typographicCase === void 0) { typographicCase = 'default'; }
+        var _this = _super.call(this) || this;
+        _this._id = elementFormatIDs++;
+        noLogs || console.log('[ElementFormat] ' + _this._id + ' constructor', 'fontDescription', fontDescription, 'fontSize', fontSize, 'color', color, 'alpha', alpha, 'textRotation', textRotation, 'dominantBaseline', dominantBaseline, 'alignmentBaseline', alignmentBaseline, 'baselineShift', baselineShift, 'kerning', kerning, 'trackingRight', trackingRight, 'trackingLeft', trackingLeft, 'locale', locale, 'breakOpportunity', breakOpportunity, 'digitCase', digitCase, 'digitWidth', digitWidth, 'ligatureLevel', ligatureLevel, 'typographicCase', typographicCase);
+        _this._fontDescription = fontDescription;
+        _this._fontSize = +fontSize;
+        _this._color = color >>> 0;
+        _this._alpha = +alpha;
+        _this._textRotation = axCoerceString(textRotation);
+        _this._dominantBaseline = axCoerceString(dominantBaseline);
+        _this._alignmentBaseline = axCoerceString(alignmentBaseline);
+        _this._baselineShift = +baselineShift;
+        _this._kerning = axCoerceString(kerning);
+        _this._trackingRight = +trackingRight;
+        _this._trackingLeft = +trackingLeft;
+        _this._locale = axCoerceString(locale);
+        _this._breakOpportunity = axCoerceString(breakOpportunity);
+        _this._digitCase = axCoerceString(digitCase);
+        _this._digitWidth = axCoerceString(digitWidth);
+        _this._ligatureLevel = axCoerceString(ligatureLevel);
+        _this._typographicCase = axCoerceString(typographicCase);
+        return _this;
+    }
+    ElementFormat.prototype.createAwayTextformat = function () {
+        var _a, _b, _c;
+        var awayTextFormat = new TextFormat();
+        awayTextFormat.size = this._fontSize;
+        awayTextFormat.color = this._color;
+        awayTextFormat.fontLookUpMode = (this._fontDescription ?
+            this._fontDescription.fontLookup : FontLookUpMode.DEVICE);
+        awayTextFormat.font_name = (_a = this._fontDescription) === null || _a === void 0 ? void 0 : _a.fontName;
+        awayTextFormat.italic = ((_b = this._fontDescription) === null || _b === void 0 ? void 0 : _b.fontPosture) == 'italic';
+        awayTextFormat.bold = ((_c = this._fontDescription) === null || _c === void 0 ? void 0 : _c.fontWeight) == 'bold';
+        awayTextFormat.align = TextFormatAlign.LEFT;
+        if (this._baselineShift != 0) {
+            console.warn('baselineshift is not 0', this._baselineShift);
+        }
+        if (this._alignmentBaseline != TextBaseline.USE_DOMINANT_BASELINE) {
+            console.warn('_alignmentBaseline is not USE_DOMINANT_BASELINE', this._alignmentBaseline);
+        }
+        if (this._dominantBaseline != TextBaseline.ROMAN) {
+            console.warn('_dominantBaseline is not ROMAN', this._dominantBaseline);
+        }
+        if (this._trackingRight != 0) {
+            console.warn('_trackingRight is not 0', this._trackingRight);
+        }
+        if (this._trackingLeft != 0) {
+            console.warn('_trackingLeft is not 0', this._trackingLeft);
+        }
+        if (this._alpha != 1) {
+            console.warn('_alpha is not 1', this._alpha);
+        }
+        if (this._digitCase != 'default') {
+            console.warn('_digitCase is not "default"', this._digitCase);
+        }
+        if (this._digitWidth != 'default') {
+            console.warn('_digitWidth is not "default"', this._digitWidth);
+        }
+        if (this._typographicCase != 'default') {
+            console.warn('_typographicCase is not "default"', this._typographicCase);
+        }
+        if (this._ligatureLevel != 'common') {
+            console.warn('_ligatureLevel is not "common"', this._ligatureLevel);
+        }
+        noLogs || console.log('[ElementFormat] ' + this._id + ' createAwayTextformat', awayTextFormat.id, 'fontDescription', this._fontDescription, 'fontSize', this._fontSize, 'color', this._color, 'alpha', this._alpha, 'textRotation', this._textRotation, 'dominantBaseline', this._dominantBaseline, 'alignmentBaseline', this._alignmentBaseline, 'baselineShift', this._baselineShift, 'kerning', this._kerning, 'trackingRight', this._trackingRight, 'trackingLeft', this._trackingLeft, 'locale', this._locale, 'breakOpportunity', this._breakOpportunity, 'digitCase', this._digitCase, 'digitWidth', this._digitWidth, 'ligatureLevel', this._ligatureLevel, 'typographicCase', this._typographicCase);
+        return awayTextFormat;
+    };
+    // AS -> JS Bindings
+    ElementFormat.prototype.getBaseline = function () {
+        if (this._alignmentBaseline == TextBaseline.USE_DOMINANT_BASELINE) {
+            return this._dominantBaseline;
+        }
+        return this._alignmentBaseline;
+    };
+    Object.defineProperty(ElementFormat.prototype, "alignmentBaseline", {
+        get: function () {
+            return this._alignmentBaseline;
+        },
+        set: function (alignmentBaseline) {
+            this._alignmentBaseline = axCoerceString(alignmentBaseline);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "alpha", {
+        get: function () {
+            return this._alpha;
+        },
+        set: function (value) {
+            this._alpha = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "baselineShift", {
+        get: function () {
+            return this._baselineShift;
+        },
+        set: function (value) {
+            this._baselineShift = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "breakOpportunity", {
+        get: function () {
+            return this._breakOpportunity;
+        },
+        set: function (opportunityType) {
+            this._breakOpportunity = axCoerceString(opportunityType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "color", {
+        get: function () {
+            return this._color;
+        },
+        set: function (value /*uint*/) {
+            this._color = value >>> 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "dominantBaseline", {
+        get: function () {
+            return this._dominantBaseline;
+        },
+        set: function (dominantBaseline) {
+            this._dominantBaseline = axCoerceString(dominantBaseline);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "fontDescription", {
+        get: function () {
+            return this._fontDescription;
+        },
+        set: function (value) {
+            this._fontDescription = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "digitCase", {
+        get: function () {
+            return this._digitCase;
+        },
+        set: function (digitCaseType) {
+            this._digitCase = axCoerceString(digitCaseType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "digitWidth", {
+        get: function () {
+            return this._digitWidth;
+        },
+        set: function (digitWidthType) {
+            this._digitWidth = axCoerceString(digitWidthType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "ligatureLevel", {
+        get: function () {
+            return this._ligatureLevel;
+        },
+        set: function (ligatureLevelType) {
+            this._ligatureLevel = axCoerceString(ligatureLevelType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "fontSize", {
+        get: function () {
+            return this._fontSize;
+        },
+        set: function (value) {
+            this._fontSize = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "kerning", {
+        get: function () {
+            return this._kerning;
+        },
+        set: function (value) {
+            this._kerning = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "locale", {
+        get: function () {
+            return this._locale;
+        },
+        set: function (value) {
+            this._locale = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "textRotation", {
+        get: function () {
+            return this._textRotation;
+        },
+        set: function (value) {
+            this._textRotation = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "trackingRight", {
+        get: function () {
+            return this._trackingRight;
+        },
+        set: function (value) {
+            this._trackingRight = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "trackingLeft", {
+        get: function () {
+            return this._trackingLeft;
+        },
+        set: function (value) {
+            this._trackingLeft = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "typographicCase", {
+        get: function () {
+            return this._typographicCase;
+        },
+        set: function (typographicCaseType) {
+            this._typographicCase = axCoerceString(typographicCaseType);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementFormat.prototype, "locked", {
+        get: function () {
+            return this._locked;
+        },
+        set: function (value) {
+            this._locked = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ElementFormat.prototype.getFontMetrics = function () {
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/ElementFormat', 'set getFontMetrics', '');
+        return null;
+    };
+    ElementFormat.forceNativeConstructor = true;
+    ElementFormat.forceNativeMethods = true;
+    return ElementFormat;
+}(ASObject));
+export { ElementFormat };

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

@@ -0,0 +1,31 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class FontDescription extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    private _renderingMode;
+    private _fontLookup;
+    private _fontName;
+    private _fontPosture;
+    private _fontWeight;
+    private _cffHinting;
+    private _locked;
+    constructor(fontName?: string, fontWeight?: string, fontPosture?: string, fontLookup?: string, renderingMode?: string, cffHinting?: string);
+    clone: () => FontDescription;
+    static isFontCompatible(fontName: string, fontWeight: string, fontPosture: string): boolean;
+    static isDeviceFontCompatible(fontName: string, fontWeight: string, fontPosture: string): boolean;
+    get renderingMode(): string;
+    set renderingMode(value: string);
+    get fontLookup(): string;
+    set fontLookup(value: string);
+    get fontName(): string;
+    set fontName(value: string);
+    get fontPosture(): string;
+    set fontPosture(value: string);
+    get fontWeight(): string;
+    set fontWeight(value: string);
+    get cffHinting(): string;
+    set cffHinting(value: string);
+    get locked(): boolean;
+    set locked(value: boolean);
+}
+//# sourceMappingURL=FontDescription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontDescription.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/FontDescription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAGxD,qBAAa,eAAgB,SAAQ,QAAQ;IAE5C,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;IAE1C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAU;gBAGxB,QAAQ,GAAE,MAAiB,EAC3B,UAAU,GAAE,MAAiB,EAC7B,WAAW,GAAE,MAAiB,EAC9B,UAAU,GAAE,MAAiB,EAC7B,aAAa,GAAE,MAAc,EAC7B,UAAU,GAAE,MAAyB;IAY/B,KAAK,EAAE,MAAM,eAAe,CAAC;WAGtB,gBAAgB,CAC7B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAAG,OAAO;WAShB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IASxG,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED,IAAW,aAAa,CAAC,KAAK,EAAE,MAAM,EAErC;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,EAElC;IAED,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,MAAM,EAEnC;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,EAElC;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,EAElC;IAED,IAAW,MAAM,IAAI,OAAO,CAE3B;IAED,IAAW,MAAM,CAAC,KAAK,EAAE,OAAO,EAE/B;CACD"}

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

@@ -0,0 +1,113 @@
+import { __extends } from "tslib";
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+var FontDescription = /** @class */ (function (_super) {
+    __extends(FontDescription, _super);
+    function FontDescription(fontName, fontWeight, fontPosture, fontLookup, renderingMode, cffHinting) {
+        if (fontName === void 0) { fontName = '_serif'; }
+        if (fontWeight === void 0) { fontWeight = 'normal'; }
+        if (fontPosture === void 0) { fontPosture = 'normal'; }
+        if (fontLookup === void 0) { fontLookup = 'device'; }
+        if (renderingMode === void 0) { renderingMode = 'cff'; }
+        if (cffHinting === void 0) { cffHinting = 'horizontalStem'; }
+        var _this = _super.call(this) || this;
+        _this._fontName = axCoerceString(fontName);
+        _this._fontWeight = axCoerceString(fontWeight);
+        _this._fontPosture = axCoerceString(fontPosture);
+        _this._fontLookup = axCoerceString(fontLookup);
+        _this._renderingMode = axCoerceString(renderingMode);
+        _this._cffHinting = axCoerceString(cffHinting);
+        return _this;
+    }
+    // AS -> JS Bindings
+    FontDescription.isFontCompatible = function (fontName, fontWeight, fontPosture) {
+        fontName = axCoerceString(fontName);
+        fontWeight = axCoerceString(fontWeight);
+        fontPosture = axCoerceString(fontPosture);
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/FontDescription', 'static isFontCompatible', '');
+        return null;
+    };
+    FontDescription.isDeviceFontCompatible = function (fontName, fontWeight, fontPosture) {
+        fontName = axCoerceString(fontName);
+        fontWeight = axCoerceString(fontWeight);
+        fontPosture = axCoerceString(fontPosture);
+        // @todo
+        Debug.throwPIR('playerglobals/text/engine/FontDescription', 'static isDeviceFontCompatible', '');
+        return null;
+    };
+    Object.defineProperty(FontDescription.prototype, "renderingMode", {
+        get: function () {
+            return this._renderingMode;
+        },
+        set: function (value) {
+            this._renderingMode = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "fontLookup", {
+        get: function () {
+            return this._fontLookup;
+        },
+        set: function (value) {
+            this._fontLookup = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "fontName", {
+        get: function () {
+            return this._fontName;
+        },
+        set: function (value) {
+            this._fontName = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "fontPosture", {
+        get: function () {
+            return this._fontPosture;
+        },
+        set: function (value) {
+            this._fontPosture = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "fontWeight", {
+        get: function () {
+            return this._fontWeight;
+        },
+        set: function (value) {
+            this._fontWeight = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "cffHinting", {
+        get: function () {
+            return this._cffHinting;
+        },
+        set: function (value) {
+            this._cffHinting = axCoerceString(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FontDescription.prototype, "locked", {
+        get: function () {
+            return this._locked;
+        },
+        set: function (value) {
+            this._locked = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FontDescription.forceNativeConstructor = true;
+    FontDescription.forceNativeMethods = true;
+    return FontDescription;
+}(ASObject));
+export { FontDescription };

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

@@ -0,0 +1,9 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class FontLookup extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor();
+    static DEVICE: string;
+    static EMBEDDED_CFF: string;
+}
+//# sourceMappingURL=FontLookup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontLookup.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/FontLookup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,qBAAa,UAAW,SAAQ,QAAQ;IAEvC,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;;IAO1C,OAAc,MAAM,EAAE,MAAM,CAAY;IACxC,OAAc,YAAY,EAAE,MAAM,CAAiB;CAInD"}

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

@@ -0,0 +1,15 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var FontLookup = /** @class */ (function (_super) {
+    __extends(FontLookup, _super);
+    function FontLookup() {
+        return _super.call(this) || this;
+    }
+    FontLookup.forceNativeConstructor = true;
+    FontLookup.forceNativeMethods = true;
+    // JS -> AS Bindings
+    FontLookup.DEVICE = 'device';
+    FontLookup.EMBEDDED_CFF = 'embeddedCFF';
+    return FontLookup;
+}(ASObject));
+export { FontLookup };

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

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+import { Rectangle } from '../../geom/Rectangle';
+export declare class FontMetrics extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor(emBox: Rectangle, strikethroughOffset: number, strikethroughThickness: number, underlineOffset: number, underlineThickness: number, subscriptOffset: number, subscriptScale: number, superscriptOffset: number, superscriptScale: number, lineGap?: number);
+    emBox: Rectangle;
+    strikethroughOffset: number;
+    strikethroughThickness: number;
+    underlineOffset: number;
+    underlineThickness: number;
+    subscriptOffset: number;
+    subscriptScale: number;
+    superscriptOffset: number;
+    superscriptScale: number;
+    lineGap: number;
+}
+//# sourceMappingURL=FontMetrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontMetrics.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/FontMetrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,qBAAa,WAAY,SAAQ,QAAQ;IAExC,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;gBAGzC,KAAK,EAAE,SAAS,EAChB,mBAAmB,EAAE,MAAM,EAC3B,sBAAsB,EAAE,MAAM,EAC9B,eAAe,EAAE,MAAM,EACvB,kBAAkB,EAAE,MAAM,EAC1B,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU;IAgBvC,KAAK,EAAE,SAAS,CAAC;IACjB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CAIvB"}

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

@@ -0,0 +1,24 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var FontMetrics = /** @class */ (function (_super) {
+    __extends(FontMetrics, _super);
+    function FontMetrics(emBox, strikethroughOffset, strikethroughThickness, underlineOffset, underlineThickness, subscriptOffset, subscriptScale, superscriptOffset, superscriptScale, lineGap) {
+        if (lineGap === void 0) { lineGap = 0; }
+        var _this = _super.call(this) || this;
+        _this.emBox = emBox;
+        _this.strikethroughOffset = +strikethroughOffset;
+        _this.strikethroughThickness = +strikethroughThickness;
+        _this.underlineOffset = +underlineOffset;
+        _this.underlineThickness = +underlineThickness;
+        _this.subscriptOffset = +subscriptOffset;
+        _this.subscriptScale = +subscriptScale;
+        _this.superscriptOffset = +superscriptOffset;
+        _this.superscriptScale = +superscriptScale;
+        _this.lineGap = +lineGap;
+        return _this;
+    }
+    FontMetrics.forceNativeConstructor = true;
+    FontMetrics.forceNativeMethods = true;
+    return FontMetrics;
+}(ASObject));
+export { FontMetrics };

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

@@ -0,0 +1,9 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class FontPosture extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor();
+    static NORMAL: string;
+    static ITALIC: string;
+}
+//# sourceMappingURL=FontPosture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontPosture.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/FontPosture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,qBAAa,WAAY,SAAQ,QAAQ;IAExC,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;;IAO1C,OAAc,MAAM,EAAE,MAAM,CAAY;IACxC,OAAc,MAAM,EAAE,MAAM,CAAY;CAIxC"}

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

@@ -0,0 +1,15 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var FontPosture = /** @class */ (function (_super) {
+    __extends(FontPosture, _super);
+    function FontPosture() {
+        return _super.call(this) || this;
+    }
+    FontPosture.forceNativeConstructor = true;
+    FontPosture.forceNativeMethods = true;
+    // JS -> AS Bindings
+    FontPosture.NORMAL = 'normal';
+    FontPosture.ITALIC = 'italic';
+    return FontPosture;
+}(ASObject));
+export { FontPosture };

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

@@ -0,0 +1,9 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class FontWeight extends ASObject {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor();
+    static NORMAL: string;
+    static BOLD: string;
+}
+//# sourceMappingURL=FontWeight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontWeight.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/FontWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,qBAAa,UAAW,SAAQ,QAAQ;IAEvC,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;;IAO1C,OAAc,MAAM,EAAE,MAAM,CAAY;IACxC,OAAc,IAAI,EAAE,MAAM,CAAU;CAIpC"}

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

@@ -0,0 +1,15 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var FontWeight = /** @class */ (function (_super) {
+    __extends(FontWeight, _super);
+    function FontWeight() {
+        return _super.call(this) || this;
+    }
+    FontWeight.forceNativeConstructor = true;
+    FontWeight.forceNativeMethods = true;
+    // JS -> AS Bindings
+    FontWeight.NORMAL = 'normal';
+    FontWeight.BOLD = 'bold';
+    return FontWeight;
+}(ASObject));
+export { FontWeight };

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

@@ -0,0 +1,16 @@
+import { DisplayObject } from '../../display/DisplayObject';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+export declare class GraphicElement extends ContentElement {
+    static forceNativeConstructor: boolean;
+    static forceNativeMethods: boolean;
+    constructor(graphic?: DisplayObject, elementWidth?: number, elementHeight?: number, elementFormat?: ElementFormat, eventMirror?: EventDispatcher, textRotation?: string);
+    get graphic(): DisplayObject;
+    set graphic(value: DisplayObject);
+    get elementHeight(): number;
+    set elementHeight(value: number);
+    get elementWidth(): number;
+    set elementWidth(value: number);
+}
+//# sourceMappingURL=GraphicElement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GraphicElement.d.ts","sourceRoot":"","sources":["../../../../lib/text/engine/GraphicElement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,qBAAa,cAAe,SAAQ,cAAc;IAEjD,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAQ;IAC9C,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAQ;gBAGzC,OAAO,GAAE,aAAoB,EAC7B,YAAY,GAAE,MAAW,EACzB,aAAa,GAAE,MAAW,EAC1B,aAAa,GAAE,aAAoB,EACnC,WAAW,GAAE,eAAsB,EACnC,YAAY,GAAE,MAAkB;IAiBjC,IAAW,OAAO,IAAI,aAAa,CAIlC;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,aAAa,EAGtC;IAED,IAAW,aAAa,IAAI,MAAM,CAIjC;IAED,IAAW,aAAa,CAAC,KAAK,EAAE,MAAM,EAGrC;IAED,IAAW,YAAY,IAAI,MAAM,CAIhC;IAED,IAAW,YAAY,CAAC,KAAK,EAAE,MAAM,EAIpC;CACD"}