@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/Graphics.d.ts

@@ -0,0 +1,94 @@
+import { Graphics as AwayGraphics } from '@awayjs/graphics';
+import { ASObject, Float64Vector, Int32Vector } from '@awayfl/avm2';
+import { IAssetAdapter } from '@awayjs/core';
+import { ASArray, GenericVector, AXClass } from '@awayfl/avm2';
+import { BitmapData } from './BitmapData';
+import { LoaderInfo } from './LoaderInfo';
+import { Matrix } from '../geom/Matrix';
+export declare class Graphics extends ASObject implements IAssetAdapter {
+    static axClass: typeof Graphics & AXClass;
+    static currentAwayGraphics: AwayGraphics;
+    static classInitializer: any;
+    private _adaptee;
+    /**
+     * True once clear() has given this wrapper its own private AwayGraphics.
+     * Reset whenever the wrapper is retargeted to another AwayGraphics.
+     */
+    private _ownsAdaptee;
+    constructor(adaptee?: AwayGraphics);
+    /**
+     * Point this wrapper at a (possibly different) AwayGraphics. Called by the
+     * owning Shape/Sprite when its AwayJS graphics object changes, so the AS3
+     * Graphics instance stays the same for the lifetime of its display object.
+     *
+     * Note: this wrapper never stores a reference to its owning display object.
+     * Timeline shape symbols share one AwayGraphics between all instances, and
+     * that AwayGraphics lives as long as the symbol; anything reachable from it
+     * (including its adapter) must not reach back into a display list.
+     */
+    _setAdaptee(adaptee: AwayGraphics): void;
+    dispose(): void;
+    get adaptee(): AwayGraphics;
+    static FromData(data: any, loaderInfo: LoaderInfo): Graphics;
+    clear(): void;
+    /**
+     * Copy-on-write: clear() on one instance must not wipe an AwayGraphics that
+     * is also used by other instances (timeline shape symbols share one
+     * AwayGraphics per symbol and keep it in the timeline graphics pool).
+     * Give the owning display object a fresh, private AwayGraphics instead and
+     * leave the shared original intact.
+     */
+    private _detachSharedGraphics;
+    private _takePrivateAdaptee;
+    /**
+     * Sets a solid color and opacity as the fill for subsequent drawing commands.
+     *
+     * @see
+     * http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/Graphics.html#beginFill%28%29
+     * @param color
+     * @param alpha While any Number is a valid input, the value is clamped to [0,1] and then scaled
+     * to an integer in the interval [0,0xff].
+     */
+    beginFill(color: number, alpha?: number): void;
+    beginGradientFill(type: string, colors: ASArray, alphas: ASArray, ratios: ASArray, matrix?: Matrix, spreadMethod?: string, interpolationMethod?: string, focalPointRatio?: number): void;
+    beginBitmapFill(bitmap: BitmapData, matrix?: Matrix, repeat?: boolean, smooth?: boolean): void;
+    endFill(): void;
+    lineStyle(thickness: number, color?: number, alpha?: number, pixelHinting?: boolean, scaleMode?: string, caps?: string, joints?: string, miterLimit?: number): void;
+    lineGradientStyle(type: string, colors: ASArray, alphas: ASArray, ratios: ASArray, matrix?: Matrix, spreadMethod?: string, interpolationMethod?: string, focalPointRatio?: number): void;
+    lineBitmapStyle(bitmap: BitmapData, matrix?: Matrix, repeat?: boolean, smooth?: boolean): void;
+    drawRect(x: number, y: number, width: number, height: number): void;
+    drawRoundRect(x: number, y: number, width: number, height: number, ellipseWidth: number, ellipseHeight: number): void;
+    drawRoundRectComplex(x: number, y: number, width: number, height: number, topLeftRadius: number, topRightRadius: number, bottomLeftRadius: number, bottomRightRadius: number): void;
+    drawCircle(x: number, y: number, radius: number): void;
+    /**
+     * Here x and y are the top-left coordinates of the bounding box of the
+     * ellipse not the center as is the case for circles.
+     */
+    drawEllipse(x: number, y: number, width: number, height: number): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    curveTo(controlX: number, controlY: number, anchorX: number, anchorY: number): void;
+    cubicCurveTo(controlX1: number, controlY1: number, controlX2: number, controlY2: number, anchorX: number, anchorY: number): void;
+    copyFrom(sourceGraphics: Graphics): void;
+    drawPath(commands: Int32Vector, data: Float64Vector, winding?: string): void;
+    drawTriangles(vertices: Float64Vector, indices?: Int32Vector, uvtData?: Int32Vector, culling?: string): void;
+    drawGraphicsData(graphicsData: GenericVector): void;
+    readGraphicsData(recurse?: boolean): GenericVector;
+    private _drawGraphicsDataItem;
+    private _applyStroke;
+    private _collectGraphicsData;
+    /**
+     * Resolve the AS3 display object that owns this wrapper at call time from
+     * the AwayGraphics owner set (held weakly by AwayGraphics). The owner is
+     * the one whose AS3 adapter exposes this exact wrapper as its graphics,
+     * which stays exact when several timeline instances share one AwayGraphics.
+     */
+    private _findOwner;
+    private _concatenatedMatrix;
+    private _toAS3GraphicsData;
+    private _strokeFill;
+    private _transformPairs;
+    private _toInt32Vector;
+    private _toFloat64Vector;
+}
+//# sourceMappingURL=Graphics.d.ts.map

package/dist/lib/display/Graphics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Graphics.d.ts","sourceRoot":"","sources":["../../../lib/display/Graphics.ts"],"names":[],"mappings":"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"}

package/dist/lib/display/Graphics.js

@@ -0,0 +1,473 @@
+import { __extends } from "tslib";
+import { Graphics as AwayGraphics, GraphicsPath as AwayGraphicsPath, GraphicsStrokeStyle, GraphicsFillStyle, GraphicsEndFill as AwayGraphicsEndFill, SolidFillStyle, GradientFillStyle, BitmapFillStyle, CapsStyle as AwayCapsStyle, JointStyle as AwayJointStyle, } from '@awayjs/graphics';
+import { ASObject } from '@awayfl/avm2';
+import { Debug, Matrix as AwayMatrix } from '@awayjs/core';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+// AS3 caps and joints are strings, which @awayjs/graphics takes as numbers
+var CAPS_STYLES = {
+    none: AwayCapsStyle.NONE,
+    round: AwayCapsStyle.ROUND,
+    square: AwayCapsStyle.SQUARE
+};
+var JOINT_STYLES = {
+    round: AwayJointStyle.ROUND,
+    bevel: AwayJointStyle.BEVEL,
+    miter: AwayJointStyle.MITER
+};
+function styleName(styles, value) {
+    for (var name_1 in styles) {
+        if (styles[name_1] === value)
+            return name_1;
+    }
+    return 'round';
+}
+var Graphics = /** @class */ (function (_super) {
+    __extends(Graphics, _super);
+    function Graphics(adaptee) {
+        if (adaptee === void 0) { adaptee = null; }
+        var _this = _super.call(this) || this;
+        /**
+         * True once clear() has given this wrapper its own private AwayGraphics.
+         * Reset whenever the wrapper is retargeted to another AwayGraphics.
+         */
+        _this._ownsAdaptee = false;
+        _this._setAdaptee(adaptee);
+        return _this;
+    }
+    /**
+     * Point this wrapper at a (possibly different) AwayGraphics. Called by the
+     * owning Shape/Sprite when its AwayJS graphics object changes, so the AS3
+     * Graphics instance stays the same for the lifetime of its display object.
+     *
+     * Note: this wrapper never stores a reference to its owning display object.
+     * Timeline shape symbols share one AwayGraphics between all instances, and
+     * that AwayGraphics lives as long as the symbol; anything reachable from it
+     * (including its adapter) must not reach back into a display list.
+     */
+    Graphics.prototype._setAdaptee = function (adaptee) {
+        var next = adaptee || new AwayGraphics();
+        var prev = this._adaptee;
+        if (prev === next)
+            return;
+        if (prev && prev._adapter === this)
+            prev.adapter = null;
+        this._adaptee = next;
+        this._ownsAdaptee = false;
+        next.adapter = this;
+    };
+    Graphics.prototype.dispose = function () {
+    };
+    Object.defineProperty(Graphics.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Graphics.FromData = function (data, loaderInfo) {
+        var graphics = new this.sec.flash.display.Graphics();
+        return graphics;
+    };
+    /*
+    public getGraphicsData(): ShapeData {
+        return this._graphicsData;
+    }
+
+    public getUsedTextures(): BitmapData[] {
+        return this._textures;
+    }*/
+    Graphics.prototype.clear = function () {
+        this._detachSharedGraphics();
+        this.adaptee.clear();
+    };
+    /**
+     * Copy-on-write: clear() on one instance must not wipe an AwayGraphics that
+     * is also used by other instances (timeline shape symbols share one
+     * AwayGraphics per symbol and keep it in the timeline graphics pool).
+     * Give the owning display object a fresh, private AwayGraphics instead and
+     * leave the shared original intact.
+     */
+    Graphics.prototype._detachSharedGraphics = function () {
+        var current = this._adaptee;
+        // An owned graphics can still pick up shared shapes and a
+        // sourceGraphics fallback through copyFrom(), so detach it again then.
+        if (!current || (this._ownsAdaptee && !current.sourceGraphics))
+            return;
+        var owners = 0;
+        current.forEachOwner(function () { owners++; });
+        var owner = this._findOwner();
+        var awayOwner = owner ? owner.adaptee : null;
+        if (!awayOwner) {
+            // Orphaned wrapper: never clear an AwayGraphics that something
+            // else still displays or that shares shapes with a copy source,
+            // otherwise clear in place.
+            if (owners > 0 || current.sourceGraphics)
+                this._takePrivateAdaptee(new AwayGraphics());
+            return;
+        }
+        // MovieClip graphics are per instance (copyTo clones are caught by
+        // sourceGraphics). An AwayJS Sprite owner may be a timeline shape holding
+        // the symbol's shared AwayGraphics even with a single owner, so it is
+        // detached once on its first clear(). Script-created Shape/Sprite also
+        // use an AwayJS Sprite adaptee, so they pay one extra AwayGraphics here.
+        var shared = owners > 1
+            || !!current.sourceGraphics
+            || !awayOwner.isAsset(AwayMovieClip);
+        if (!shared)
+            return;
+        var fresh = new AwayGraphics();
+        // The owner's graphics setter calls updateGraphics() on the AS3 owner,
+        // which retargets this same wrapper to the fresh graphics.
+        awayOwner.graphics = fresh;
+        this._takePrivateAdaptee(fresh);
+    };
+    Graphics.prototype._takePrivateAdaptee = function (fresh) {
+        this._setAdaptee(fresh);
+        this._ownsAdaptee = true;
+    };
+    /**
+     * Sets a solid color and opacity as the fill for subsequent drawing commands.
+     *
+     * @see
+     * http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/Graphics.html#beginFill%28%29
+     * @param color
+     * @param alpha While any Number is a valid input, the value is clamped to [0,1] and then scaled
+     * to an integer in the interval [0,0xff].
+     */
+    Graphics.prototype.beginFill = function (color /*uint*/, alpha) {
+        if (alpha === void 0) { alpha = 1; }
+        if (alpha < 0)
+            alpha = 0;
+        if (alpha > 1)
+            alpha = 1;
+        this.adaptee.beginFill(color, alpha);
+    };
+    Graphics.prototype.beginGradientFill = function (type, colors, alphas, ratios, matrix, spreadMethod, interpolationMethod, focalPointRatio) {
+        if (matrix === void 0) { matrix = null; }
+        if (spreadMethod === void 0) { spreadMethod = 'pad'; }
+        if (interpolationMethod === void 0) { interpolationMethod = 'rgb'; }
+        if (focalPointRatio === void 0) { focalPointRatio = 0; }
+        this.adaptee.beginGradientFill(type, colors.value, alphas.value, ratios.value, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, spreadMethod, interpolationMethod, focalPointRatio);
+    };
+    Graphics.prototype.beginBitmapFill = function (bitmap, matrix, repeat, smooth) {
+        if (matrix === void 0) { matrix = null; }
+        if (repeat === void 0) { repeat = true; }
+        if (smooth === void 0) { smooth = false; }
+        this.adaptee.beginBitmapFill(bitmap.adaptee, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, repeat, smooth);
+    };
+    Graphics.prototype.endFill = function () {
+        this.adaptee.endFill();
+    };
+    //    beginShaderFill(shader: flash.display.Shader, matrix: flash.geom.Matrix = null): void {
+    //      //shader = shader; matrix = matrix;
+    //      release || notImplemented("public flash.display.Graphics::beginShaderFill"); return;
+    //    }
+    Graphics.prototype.lineStyle = function (thickness, color, alpha, pixelHinting, scaleMode, caps, joints, miterLimit) {
+        var _a, _b;
+        if (color === void 0) { color = 0; }
+        if (alpha === void 0) { alpha = 1; }
+        if (pixelHinting === void 0) { pixelHinting = false; }
+        if (scaleMode === void 0) { scaleMode = 'normal'; }
+        if (caps === void 0) { caps = null; }
+        if (joints === void 0) { joints = null; }
+        if (miterLimit === void 0) { miterLimit = 3; }
+        // Flash clamps alpha to [0, 1] (AS2-era content commonly passes 0-100)
+        if (alpha < 0)
+            alpha = 0;
+        if (alpha > 1)
+            alpha = 1;
+        this.adaptee.lineStyle(thickness, color, alpha, pixelHinting, scaleMode, 
+        // Flash uses round caps and joints when they're not given
+        (_a = CAPS_STYLES[caps]) !== null && _a !== void 0 ? _a : AwayCapsStyle.ROUND, (_b = JOINT_STYLES[joints]) !== null && _b !== void 0 ? _b : AwayJointStyle.ROUND, 
+        // and rounds miter limits outside [1, 255]
+        Math.min(255, Math.max(1, miterLimit)));
+    };
+    Graphics.prototype.lineGradientStyle = function (type, colors, alphas, ratios, matrix, spreadMethod, interpolationMethod, focalPointRatio) {
+        if (matrix === void 0) { matrix = null; }
+        if (spreadMethod === void 0) { spreadMethod = 'pad'; }
+        if (interpolationMethod === void 0) { interpolationMethod = 'rgb'; }
+        if (focalPointRatio === void 0) { focalPointRatio = 0; }
+        this.adaptee.lineGradientStyle(type, colors.value, alphas.value, ratios.value, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, spreadMethod, interpolationMethod, focalPointRatio);
+    };
+    Graphics.prototype.lineBitmapStyle = function (bitmap, matrix, repeat, smooth) {
+        if (matrix === void 0) { matrix = null; }
+        if (repeat === void 0) { repeat = true; }
+        if (smooth === void 0) { smooth = false; }
+        this.adaptee.lineBitmapStyle(bitmap.adaptee, matrix === null || matrix === void 0 ? void 0 : matrix.adaptee, repeat, smooth);
+    };
+    Graphics.prototype.drawRect = function (x, y, width, height) {
+        this.adaptee.drawRect(x, y, width, height);
+    };
+    Graphics.prototype.drawRoundRect = function (x, y, width, height, ellipseWidth, ellipseHeight) {
+        this.adaptee.drawRoundRect(x, y, width, height, ellipseWidth, ellipseHeight);
+    };
+    Graphics.prototype.drawRoundRectComplex = function (x, y, width, height, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius) {
+        this.adaptee.drawRoundRectComplex(x, y, width, height, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius);
+    };
+    Graphics.prototype.drawCircle = function (x, y, radius) {
+        this.adaptee.drawCircle(x, y, radius);
+    };
+    /**
+     * Here x and y are the top-left coordinates of the bounding box of the
+     * ellipse not the center as is the case for circles.
+     */
+    Graphics.prototype.drawEllipse = function (x, y, width, height) {
+        this.adaptee.drawEllipse(x, y, width, height);
+    };
+    Graphics.prototype.moveTo = function (x, y) {
+        this.adaptee.moveTo(x, y);
+    };
+    Graphics.prototype.lineTo = function (x, y) {
+        this.adaptee.lineTo(x, y);
+    };
+    Graphics.prototype.curveTo = function (controlX, controlY, anchorX, anchorY) {
+        this.adaptee.curveTo(controlX, controlY, anchorX, anchorY);
+    };
+    Graphics.prototype.cubicCurveTo = function (controlX1, controlY1, controlX2, controlY2, anchorX, anchorY) {
+        this.adaptee.cubicCurveTo(controlX1, controlY1, controlX2, controlY2, anchorX, anchorY);
+    };
+    Graphics.prototype.copyFrom = function (sourceGraphics) {
+        this.adaptee.copyFrom(sourceGraphics.adaptee);
+    };
+    Graphics.prototype.drawPath = function (commands, data, winding) {
+        if (winding === void 0) { winding = 'evenOdd'; }
+        var cmdArr = commands._view();
+        var dataArr = data._view();
+        if (!cmdArr.length || !dataArr.length)
+            return;
+        //@ts-ignore
+        this.adaptee.drawPath(cmdArr, dataArr, winding);
+    };
+    Graphics.prototype.drawTriangles = function (vertices, indices, uvtData, culling) {
+        if (indices === void 0) { indices = null; }
+        if (uvtData === void 0) { uvtData = null; }
+        if (culling === void 0) { culling = 'none'; }
+        // @todo
+        Debug.throwPIR('playerglobals/display/Graphics', 'drawTriangles', '');
+    };
+    Graphics.prototype.drawGraphicsData = function (graphicsData) {
+        if (!graphicsData)
+            return;
+        var len = graphicsData.length | 0;
+        for (var i = 0; i < len; i++) {
+            var item = graphicsData.axGetNumericProperty(i);
+            if (item)
+                this._drawGraphicsDataItem(item);
+        }
+    };
+    Graphics.prototype.readGraphicsData = function (recurse) {
+        if (recurse === void 0) { recurse = true; }
+        var result = new this.sec.ObjectVector();
+        var owner = this._findOwner();
+        this._collectGraphicsData(result, this.adaptee, owner, !!recurse, true);
+        return result;
+    };
+    Graphics.prototype._drawGraphicsDataItem = function (item) {
+        if (!item)
+            return;
+        var display = this.sec.flash.display;
+        if (display.GraphicsSolidFill.axIsType(item)) {
+            this.beginFill(item.color, item.alpha);
+            return;
+        }
+        if (display.GraphicsGradientFill.axIsType(item)) {
+            this.beginGradientFill(item.type, item.colors, item.alphas, item.ratios, item.matrix, item.spreadMethod, item.interpolationMethod, item.focalPointRatio);
+            return;
+        }
+        if (display.GraphicsBitmapFill.axIsType(item)) {
+            this.beginBitmapFill(item.bitmapData, item.matrix, item.repeat, item.smooth);
+            return;
+        }
+        if (display.GraphicsEndFill.axIsType(item)) {
+            this.endFill();
+            return;
+        }
+        if (display.GraphicsStroke.axIsType(item)) {
+            this._applyStroke(item);
+            return;
+        }
+        if (display.GraphicsPath.axIsType(item)) {
+            this.drawPath(item.commands, item.data, item.winding);
+            return;
+        }
+        if (display.GraphicsTrianglePath.axIsType(item)) {
+            // AIR readGraphicsData skips triangles; drawTriangles is not implemented.
+            return;
+        }
+        // Engine IGraphicsData (has data_type) can be forwarded directly.
+        if (item.data_type && this.adaptee)
+            this.adaptee.drawGraphicsData([item]);
+    };
+    Graphics.prototype._applyStroke = function (stroke) {
+        var fill = stroke.fill;
+        var color = 0;
+        var alpha = 1;
+        var display = this.sec.flash.display;
+        if (display.GraphicsSolidFill.axIsType(fill)) {
+            color = fill.color;
+            alpha = fill.alpha;
+        }
+        this.lineStyle(stroke.thickness, color, alpha, stroke.pixelHinting, stroke.scaleMode, stroke.caps, stroke.joints, stroke.miterLimit);
+        if (display.GraphicsGradientFill.axIsType(fill)) {
+            this.lineGradientStyle(fill.type, fill.colors, fill.alphas, fill.ratios, fill.matrix, fill.spreadMethod, fill.interpolationMethod, fill.focalPointRatio);
+            return;
+        }
+        if (display.GraphicsBitmapFill.axIsType(fill)) {
+            this.lineBitmapStyle(fill.bitmapData, fill.matrix, fill.repeat, fill.smooth);
+        }
+    };
+    Graphics.prototype._collectGraphicsData = function (result, awayGraphics, owner, recurse, isRoot) {
+        var _a;
+        if (!isRoot && (owner.visible === false || owner.adaptee.maskMode))
+            return;
+        if (awayGraphics) {
+            // AIR: IGraphicsData is in the local space of the Graphics being read.
+            // Recursed children are transformed into that object's space, not stage space.
+            var matrix = isRoot ? new AwayMatrix() : this._concatenatedMatrix(owner);
+            var items = awayGraphics.readGraphicsData();
+            for (var i = 0; i < items.length; i++) {
+                var as3 = this._toAS3GraphicsData(items[i], matrix);
+                if (as3)
+                    result.axSetNumericProperty(result.length, as3);
+            }
+        }
+        if (!recurse || !owner || !this.sec.flash.display.DisplayObjectContainer.axIsType(owner))
+            return;
+        var container = owner;
+        var n = container.numChildren;
+        for (var i = 0; i < n; i++) {
+            var child = container.getChildAt(i);
+            if (child.visible === false || child.adaptee.maskMode)
+                continue;
+            this._collectGraphicsData(result, (_a = child.graphics) === null || _a === void 0 ? void 0 : _a.adaptee, child, true, false);
+        }
+    };
+    /**
+     * Resolve the AS3 display object that owns this wrapper at call time from
+     * the AwayGraphics owner set (held weakly by AwayGraphics). The owner is
+     * the one whose AS3 adapter exposes this exact wrapper as its graphics,
+     * which stays exact when several timeline instances share one AwayGraphics.
+     */
+    Graphics.prototype._findOwner = function () {
+        var _this = this;
+        var found = null;
+        this._adaptee.forEachOwner(function (awayOwner) {
+            if (found)
+                return;
+            var adapter = awayOwner.adapter;
+            if (adapter.graphics === _this)
+                found = adapter;
+        });
+        return found;
+    };
+    Graphics.prototype._concatenatedMatrix = function (obj) {
+        var result = new AwayMatrix();
+        var stack = [];
+        var current = obj;
+        while (current) {
+            var transform = current.adaptee && current.adaptee.transform;
+            var local = transform && transform.matrix;
+            if (local)
+                stack.push(local);
+            current = current.parent;
+        }
+        for (var i = stack.length - 1; i >= 0; i--)
+            result.concat(stack[i]);
+        return result;
+    };
+    Graphics.prototype._toAS3GraphicsData = function (item, concatenated) {
+        var display = this.sec.flash.display;
+        var type = item.data_type;
+        if (type == GraphicsFillStyle.data_type)
+            return this._toAS3GraphicsData(item.fillStyle, concatenated);
+        if (type == SolidFillStyle.data_type) {
+            var solid = item;
+            return new display.GraphicsSolidFill(solid.color, solid.alpha);
+        }
+        if (type == GradientFillStyle.data_type) {
+            var gradient = item;
+            var matrix = concatenated.clone();
+            matrix.concat(gradient.matrix);
+            return new display.GraphicsGradientFill(gradient.type, this.sec.createArray(gradient.colors), this.sec.createArray(gradient.alphas), this.sec.createArray(gradient.ratios), new this.sec.flash.geom.Matrix(matrix), gradient.spreadMethod, gradient.interpolationMethod, gradient.focalPointRatio);
+        }
+        if (type == BitmapFillStyle.data_type) {
+            var bitmap = item;
+            var matrix = concatenated.clone();
+            matrix.concat(bitmap.matrix);
+            return new display.GraphicsBitmapFill(bitmap.image.adapter, new this.sec.flash.geom.Matrix(matrix), bitmap.repeat !== false, !!bitmap.smooth);
+        }
+        if (type == AwayGraphicsEndFill.data_type)
+            return new display.GraphicsEndFill();
+        if (type == GraphicsStrokeStyle.data_type) {
+            var stroke = item;
+            var fill = this._toAS3GraphicsData(this._strokeFill(stroke), concatenated);
+            return new display.GraphicsStroke(stroke.thickness, false, 'normal', styleName(CAPS_STYLES, stroke.capstyle), styleName(JOINT_STYLES, stroke.jointstyle), stroke.miterLimit, fill);
+        }
+        if (type == AwayGraphicsPath.data_type) {
+            var path = item;
+            var winding = path.winding === 'nonZero' ? 'nonZero' : 'evenOdd';
+            var commands = this._toInt32Vector(path.commands);
+            var data = this._toFloat64Vector(this._transformPairs(path.data, concatenated));
+            // Construct with a valid winding first (ABC validates it). Then poke
+            // commands/data onto both JS fields and $Bg slots — the ABC ctor does not.
+            var as3 = new display.GraphicsPath(null, null, winding);
+            as3.commands = commands;
+            as3.data = data;
+            as3.winding = winding;
+            as3.$Bgcommands = commands;
+            as3.$Bgdata = data;
+            as3.$Bgwinding = winding;
+            return as3;
+        }
+        return null;
+    };
+    Graphics.prototype._strokeFill = function (stroke) {
+        var fill = stroke.fillStyle;
+        if (fill && fill.data_type == GraphicsFillStyle.data_type)
+            fill = fill.fillStyle;
+        return fill;
+    };
+    Graphics.prototype._transformPairs = function (data, matrix) {
+        if (!data)
+            return [];
+        if (!matrix || data.length < 2)
+            return data;
+        var raw = matrix.rawData;
+        var a = raw[0], b = raw[1], c = raw[2], d = raw[3], tx = raw[4], ty = raw[5];
+        if (a === 1 && b === 0 && c === 0 && d === 1 && tx === 0 && ty === 0)
+            return data;
+        var out = data.slice();
+        for (var i = 0; i + 1 < out.length; i += 2) {
+            var x = out[i];
+            var y = out[i + 1];
+            out[i] = a * x + c * y + tx;
+            out[i + 1] = b * x + d * y + ty;
+        }
+        return out;
+    };
+    Graphics.prototype._toInt32Vector = function (values) {
+        var list = values || [];
+        var vector = new this.sec.Int32Vector(list.length, false);
+        for (var i = 0; i < list.length; i++)
+            vector.axSetNumericProperty(i, list[i]);
+        return vector;
+    };
+    Graphics.prototype._toFloat64Vector = function (values) {
+        var list = values || [];
+        var vector = new this.sec.Float64Vector(list.length, false);
+        for (var i = 0; i < list.length; i++)
+            vector.axSetNumericProperty(i, +list[i]);
+        return vector;
+    };
+    Graphics.classInitializer = function () {
+        // playerglobal.abcs Graphics is missing readGraphicsData, so linkClass never
+        // installs $BgreadGraphicsData. AS3 then calls a missing function (Error #1006).
+        var proto = this.dPrototype;
+        if (!proto)
+            return;
+        if (typeof proto.readGraphicsData === 'function')
+            proto.$BgreadGraphicsData = proto.readGraphicsData;
+    };
+    return Graphics;
+}(ASObject));
+export { Graphics };

package/dist/lib/display/GraphicsBitmapFill.d.ts

@@ -0,0 +1,13 @@
+import { ASObject } from '@awayfl/avm2';
+import { Matrix } from '../geom/Matrix';
+import { BitmapData } from './BitmapData';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+export declare class GraphicsBitmapFill extends ASObject implements IGraphicsFill, IGraphicsData {
+    static classInitializer: any;
+    bitmapData: BitmapData;
+    matrix: Matrix;
+    repeat: boolean;
+    smooth: boolean;
+    constructor(bitmapData?: BitmapData, matrix?: Matrix, repeat?: boolean, smooth?: boolean);
+}
+//# sourceMappingURL=GraphicsBitmapFill.d.ts.map

package/dist/lib/display/GraphicsBitmapFill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphicsBitmapFill.d.ts","sourceRoot":"","sources":["../../../lib/display/GraphicsBitmapFill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE/D,qBAAa,kBAAmB,SAAQ,QAAS,YAAW,aAAa,EAAE,aAAa;IAEvF,OAAc,gBAAgB,EAAE,GAAG,CAOjC;IAEK,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;gBAEX,UAAU,GAAE,UAAiB,EACxC,MAAM,GAAE,MAAa,EAAE,MAAM,GAAE,OAAc,EAAE,MAAM,GAAE,OAAe;CAgBvE"}

package/dist/lib/display/GraphicsBitmapFill.js

@@ -0,0 +1,36 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var GraphicsBitmapFill = /** @class */ (function (_super) {
+    __extends(GraphicsBitmapFill, _super);
+    function GraphicsBitmapFill(bitmapData, matrix, repeat, smooth) {
+        if (bitmapData === void 0) { bitmapData = null; }
+        if (matrix === void 0) { matrix = null; }
+        if (repeat === void 0) { repeat = true; }
+        if (smooth === void 0) { smooth = false; }
+        var _this = _super.call(this) || this;
+        _this.bitmapData = bitmapData;
+        _this.matrix = matrix;
+        _this.repeat = !!repeat;
+        _this.smooth = !!smooth;
+        var self = _this;
+        self.$BgbitmapData = bitmapData;
+        self.$Bgmatrix = matrix;
+        self.$Bgrepeat = _this.repeat;
+        self.$Bgsmooth = _this.smooth;
+        self._nativeBitmapData = bitmapData;
+        self._nativeMatrix = matrix;
+        self._nativeRepeat = _this.repeat;
+        self._nativeSmooth = _this.smooth;
+        return _this;
+    }
+    GraphicsBitmapFill.classInitializer = function () {
+        // playerglobal.abcs ships a bytecode ctor that never assigns the native
+        // fields. AS3 `new GraphicsBitmapFill(bd, matrix, …)` then produces an
+        // instance whose $BgbitmapData slot stays null. Bind the TS constructor.
+        var proto = this.tPrototype || this.dPrototype;
+        if (proto)
+            proto.axInitializer = GraphicsBitmapFill;
+    };
+    return GraphicsBitmapFill;
+}(ASObject));
+export { GraphicsBitmapFill };

package/dist/lib/display/GraphicsEndFill.d.ts

@@ -0,0 +1,7 @@
+import { ASObject } from '@awayfl/avm2';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+export declare class GraphicsEndFill extends ASObject implements IGraphicsFill, IGraphicsData {
+    static classInitializer: any;
+    constructor();
+}
+//# sourceMappingURL=GraphicsEndFill.d.ts.map

package/dist/lib/display/GraphicsEndFill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphicsEndFill.d.ts","sourceRoot":"","sources":["../../../lib/display/GraphicsEndFill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE/D,qBAAa,eAAgB,SAAQ,QAAS,YAAW,aAAa,EAAE,aAAa;IAEpF,OAAc,gBAAgB,EAAE,GAAG,CAAQ;;CAK3C"}

package/dist/lib/display/GraphicsEndFill.js

@@ -0,0 +1,11 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var GraphicsEndFill = /** @class */ (function (_super) {
+    __extends(GraphicsEndFill, _super);
+    function GraphicsEndFill() {
+        return _super.call(this) || this;
+    }
+    GraphicsEndFill.classInitializer = null;
+    return GraphicsEndFill;
+}(ASObject));
+export { GraphicsEndFill };

package/dist/lib/display/GraphicsGradientFill.d.ts

@@ -0,0 +1,16 @@
+import { ASArray, ASObject } from '@awayfl/avm2';
+import { Matrix } from '../geom/Matrix';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+export declare class GraphicsGradientFill extends ASObject implements IGraphicsFill, IGraphicsData {
+    static classInitializer: any;
+    colors: ASArray;
+    alphas: ASArray;
+    ratios: ASArray;
+    matrix: Matrix;
+    focalPointRatio: number;
+    type: string;
+    spreadMethod: any;
+    interpolationMethod: string;
+    constructor(type?: string, colors?: ASArray, alphas?: ASArray, ratios?: ASArray, matrix?: any, spreadMethod?: any, interpolationMethod?: string, focalPointRatio?: number);
+}
+//# sourceMappingURL=GraphicsGradientFill.d.ts.map