@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/geom/Rectangle.js

@@ -0,0 +1,478 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { Rectangle as AwayRectangle } from '@awayjs/core';
+var Rectangle = /** @class */ (function (_super) {
+    __extends(Rectangle, _super);
+    /**
+     * Creates a new Rectangle object with the top-left corner specified by the
+     * <code>x</code> and <code>y</code> parameters and with the specified
+     * <code>width</code> and <code>height</code> parameters. If you call this
+     * public without parameters, a rectangle with <code>x</code>,
+     * <code>y</code>, <code>width</code>, and <code>height</code> properties set
+     * to 0 is created.
+     *
+     * @param x      The <i>x</i> coordinate of the top-left corner of the
+     *               rectangle.
+     * @param y      The <i>y</i> coordinate of the top-left corner of the
+     *               rectangle.
+     * @param width  The width of the rectangle, in pixels.
+     * @param height The height of the rectangle, in pixels.
+     */
+    function Rectangle(xAdaptee, y, width, height) {
+        if (xAdaptee === void 0) { xAdaptee = 0; }
+        if (y === void 0) { y = 0; }
+        if (width === void 0) { width = 0; }
+        if (height === void 0) { height = 0; }
+        var _this = _super.call(this) || this;
+        _this._adaptee = (xAdaptee instanceof AwayRectangle) ? xAdaptee : new AwayRectangle(+xAdaptee, +y, +width, +height);
+        return _this;
+    }
+    Object.defineProperty(Rectangle.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "height", {
+        /**
+         * The height of the rectangle, in pixels. Changing the <code>height</code>
+         * value of a Rectangle object has no effect on the <code>x</code>,
+         * <code>y</code>, and <code>width</code> properties.
+         */
+        get: function () {
+            return this._adaptee._rawData[3];
+        },
+        set: function (value) {
+            this._adaptee._rawData[3] = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "width", {
+        /**
+         * The width of the rectangle, in pixels. Changing the <code>width</code>
+         * value of a Rectangle object has no effect on the <code>x</code>,
+         * <code>y</code>, and <code>height</code> properties.
+         */
+        get: function () {
+            return this._adaptee._rawData[2];
+        },
+        set: function (value) {
+            this._adaptee._rawData[2] = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "x", {
+        /**
+         * The <i>x</i> coordinate of the top-left corner of the rectangle. Changing
+         * the value of the <code>x</code> property of a Rectangle object has no
+         * effect on the <code>y</code>, <code>width</code>, and <code>height</code>
+         * properties.
+         *
+         * <p>The value of the <code>x</code> property is equal to the value of the
+         * <code>left</code> property.</p>
+         */
+        get: function () {
+            return this._adaptee._rawData[0];
+        },
+        set: function (value) {
+            this._adaptee._rawData[0] = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "y", {
+        /**
+         * The <i>y</i> coordinate of the top-left corner of the rectangle. Changing
+         * the value of the <code>y</code> property of a Rectangle object has no
+         * effect on the <code>x</code>, <code>width</code>, and <code>height</code>
+         * properties.
+         *
+         * <p>The value of the <code>y</code> property is equal to the value of the
+         * <code>top</code> property.</p>
+         */
+        get: function () {
+            return this._adaptee._rawData[1];
+        },
+        set: function (value) {
+            this._adaptee._rawData[1] = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "bottom", {
+        /**
+         * The sum of the <code>y</code> and <code>height</code> properties.
+         */
+        get: function () {
+            return this._adaptee.bottom;
+        },
+        set: function (value) {
+            this._adaptee.bottom = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "bottomRight", {
+        /**
+         * The location of the Rectangle object's bottom-right corner, determined by
+         * the values of the <code>right</code> and <code>bottom</code> properties.
+         */
+        get: function () {
+            return new this.sec.flash.geom.Point(this._adaptee.bottomRight);
+        },
+        set: function (value) {
+            this.bottom = value.y;
+            this.right = value.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "left", {
+        /**
+         * The <i>x</i> coordinate of the top-left corner of the rectangle. Changing
+         * the <code>left</code> property of a Rectangle object has no effect on the
+         * <code>y</code> and <code>height</code> properties. However it does affect
+         * the <code>width</code> property, whereas changing the <code>x</code> value
+         * does <i>not</i> affect the <code>width</code> property.
+         *
+         * <p>The value of the <code>left</code> property is equal to the value of
+         * the <code>x</code> property.</p>
+         */
+        get: function () {
+            return this._adaptee.left;
+        },
+        set: function (value) {
+            this._adaptee.left = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "right", {
+        /**
+         * The sum of the <code>x</code> and <code>width</code> properties.
+         */
+        get: function () {
+            return this._adaptee.right;
+        },
+        set: function (value) {
+            this._adaptee.right = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "size", {
+        /**
+         * The size of the Rectangle object, expressed as a Point object with the
+         * values of the <code>width</code> and <code>height</code> properties.
+         */
+        get: function () {
+            return new this.sec.flash.geom.Point(this._adaptee.size);
+        },
+        set: function (value) {
+            this.width = value.x;
+            this.height = value.y;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "top", {
+        /**
+         * The <i>y</i> coordinate of the top-left corner of the rectangle. Changing
+         * the <code>top</code> property of a Rectangle object has no effect on the
+         * <code>x</code> and <code>width</code> properties. However it does affect
+         * the <code>height</code> property, whereas changing the <code>y</code>
+         * value does <i>not</i> affect the <code>height</code> property.
+         *
+         * <p>The value of the <code>top</code> property is equal to the value of the
+         * <code>y</code> property.</p>
+         */
+        get: function () {
+            return this._adaptee.top;
+        },
+        set: function (value) {
+            this._adaptee.top = +value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "topLeft", {
+        /**
+         * The location of the Rectangle object's top-left corner, determined by the
+         * <i>x</i> and <i>y</i> coordinates of the point.
+         */
+        get: function () {
+            return new this.sec.flash.geom.Point(this._adaptee.topLeft);
+        },
+        set: function (value) {
+            this.top = value.y;
+            this.left = value.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Rectangle.prototype, "area", {
+        get: function () {
+            return this.width * this.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Rectangle.FromBounds = function (bounds) {
+        var xMin = bounds.xMin;
+        var yMin = bounds.yMin;
+        return new this.sec.flash.geom.Rectangle(xMin / 20, yMin / 20, (bounds.xMax - xMin) / 20, (bounds.yMax - yMin) / 20);
+    };
+    /**
+     * Returns a new Rectangle object with the same values for the
+     * <code>x</code>, <code>y</code>, <code>width</code>, and
+     * <code>height</code> properties as the original Rectangle object.
+     *
+     * @return A new Rectangle object with the same values for the
+     *         <code>x</code>, <code>y</code>, <code>width</code>, and
+     *         <code>height</code> properties as the original Rectangle object.
+     */
+    Rectangle.prototype.clone = function () {
+        return new this.sec.flash.geom.Rectangle(this._adaptee.clone());
+    };
+    /**
+     * Determines whether or not this Rectangle object is empty.
+     *
+     * @return A value of <code>true</code> if the Rectangle object's width or
+     *         height is less than or equal to 0; otherwise <code>false</code>.
+     */
+    Rectangle.prototype.isEmpty = function () {
+        return this._adaptee.isEmpty();
+    };
+    /**
+     * Sets all of the Rectangle object's properties to 0. A Rectangle object is
+     * empty if its width or height is less than or equal to 0.
+     *
+     * <p> This method sets the values of the <code>x</code>, <code>y</code>,
+     * <code>width</code>, and <code>height</code> properties to 0.</p>
+     *
+     */
+    Rectangle.prototype.setEmpty = function () {
+        return this._adaptee.setEmpty();
+    };
+    /**
+     * Increases the size of the Rectangle object by the specified amounts, in
+     * pixels. The center point of the Rectangle object stays the same, and its
+     * size increases to the left and right by the <code>dx</code> value, and to
+     * the top and the bottom by the <code>dy</code> value.
+     *
+     * @param dx The value to be added to the left and the right of the Rectangle
+     *           object. The following equation is used to calculate the new
+     *           width and position of the rectangle:
+     * @param dy The value to be added to the top and the bottom of the
+     *           Rectangle. The following equation is used to calculate the new
+     *           height and position of the rectangle:
+     */
+    Rectangle.prototype.inflate = function (dx, dy) {
+        this._adaptee.inflate(+dx, +dy);
+    };
+    /**
+     * Increases the size of the Rectangle object. This method is similar to the
+     * <code>Rectangle.inflate()</code> method except it takes a Point object as
+     * a parameter.
+     *
+     * <p>The following two code examples give the same result:</p>
+     *
+     * @param point The <code>x</code> property of this Point object is used to
+     *              increase the horizontal dimension of the Rectangle object.
+     *              The <code>y</code> property is used to increase the vertical
+     *              dimension of the Rectangle object.
+     */
+    Rectangle.prototype.inflatePoint = function (point) {
+        this._adaptee.inflatePoint(point.adaptee);
+    };
+    /**
+     * Adjusts the location of the Rectangle object, as determined by its
+     * top-left corner, by the specified amounts.
+     *
+     * @param dx Moves the <i>x</i> value of the Rectangle object by this amount.
+     * @param dy Moves the <i>y</i> value of the Rectangle object by this amount.
+     */
+    Rectangle.prototype.offset = function (dx, dy) {
+        this._adaptee.offset(+dx, +dy);
+    };
+    /**
+     * Adjusts the location of the Rectangle object using a Point object as a
+     * parameter. This method is similar to the <code>Rectangle.offset()</code>
+     * method, except that it takes a Point object as a parameter.
+     *
+     * @param point A Point object to use to offset this Rectangle object.
+     */
+    Rectangle.prototype.offsetPoint = function (point) {
+        this._adaptee.offsetPoint(point.adaptee);
+    };
+    /**
+     * Determines whether the specified point is contained within the rectangular
+     * region defined by this Rectangle object.
+     *
+     * @param x The <i>x</i> coordinate(horizontal position) of the point.
+     * @param y The <i>y</i> coordinate(vertical position) of the point.
+     * @return A value of <code>true</code> if the Rectangle object contains the
+     *         specified point; otherwise <code>false</code>.
+     */
+    Rectangle.prototype.contains = function (x, y) {
+        return this._adaptee.contains(+x, +y);
+    };
+    /**
+     * Determines whether the specified point is contained within the rectangular
+     * region defined by this Rectangle object. This method is similar to the
+     * <code>Rectangle.contains()</code> method, except that it takes a Point
+     * object as a parameter.
+     *
+     * @param point The point, as represented by its <i>x</i> and <i>y</i>
+     *              coordinates.
+     * @return A value of <code>true</code> if the Rectangle object contains the
+     *         specified point; otherwise <code>false</code>.
+     */
+    Rectangle.prototype.containsPoint = function (point) {
+        return this._adaptee.containsPoint(point.adaptee);
+    };
+    /**
+     * Determines whether the Rectangle object specified by the <code>rect</code>
+     * parameter is contained within this Rectangle object. A Rectangle object is
+     * said to contain another if the second Rectangle object falls entirely
+     * within the boundaries of the first.
+     *
+     * @param rect The Rectangle object being checked.
+     * @return A value of <code>true</code> if the Rectangle object that you
+     *         specify is contained by this Rectangle object; otherwise
+     *         <code>false</code>.
+     */
+    Rectangle.prototype.containsRect = function (rect) {
+        return this._adaptee.containsRect(rect.adaptee);
+    };
+    /**
+     * If the Rectangle object specified in the <code>toIntersect</code>
+     * parameter intersects with this Rectangle object, returns the area of
+     * intersection as a Rectangle object. If the rectangles do not intersect,
+     * this method returns an empty Rectangle object with its properties set to
+     * 0.
+     *
+     * @param toIntersect The Rectangle object to compare against to see if it
+     *                    intersects with this Rectangle object.
+     * @return A Rectangle object that equals the area of intersection. If the
+     *         rectangles do not intersect, this method returns an empty
+     *         Rectangle object; that is, a rectangle with its <code>x</code>,
+     *         <code>y</code>, <code>width</code>, and <code>height</code>
+     *         properties set to 0.
+     */
+    Rectangle.prototype.intersection = function (toIntersect) {
+        return new this.sec.flash.geom.Rectangle(this._adaptee.intersection(toIntersect.adaptee));
+    };
+    /**
+     * Determines whether the object specified in the <code>toIntersect</code>
+     * parameter intersects with this Rectangle object. This method checks the
+     * <code>x</code>, <code>y</code>, <code>width</code>, and
+     * <code>height</code> properties of the specified Rectangle object to see if
+     * it intersects with this Rectangle object.
+     *
+     * @param toIntersect The Rectangle object to compare against this Rectangle
+     *                    object.
+     * @return A value of <code>true</code> if the specified object intersects
+     *         with this Rectangle object; otherwise <code>false</code>.
+     */
+    Rectangle.prototype.intersects = function (toIntersect) {
+        return this._adaptee.intersects(toIntersect.adaptee);
+    };
+    /**
+     * Adds two rectangles together to create a new Rectangle object, by filling
+     * in the horizontal and vertical space between the two rectangles.
+     *
+     * <p><b>Note:</b> The <code>union()</code> method ignores rectangles with
+     * <code>0</code> as the height or width value, such as: <code>var
+     * rect2:Rectangle = new Rectangle(300,300,50,0);</code></p>
+     *
+     * @param toUnion A Rectangle object to add to this Rectangle object.
+     * @return A new Rectangle object that is the union of the two rectangles.
+     */
+    Rectangle.prototype.union = function (toUnion) {
+        return new this.sec.flash.geom.Rectangle(this._adaptee.union(toUnion.adaptee));
+    };
+    /**
+     * Determines whether the object specified in the <code>toCompare</code>
+     * parameter is equal to this Rectangle object. This method compares the
+     * <code>x</code>, <code>y</code>, <code>width</code>, and
+     * <code>height</code> properties of an object against the same properties of
+     * this Rectangle object.
+     *
+     * @param toCompare The rectangle to compare to this Rectangle object.
+     * @return A value of <code>true</code> if the object has exactly the same
+     *         values for the <code>x</code>, <code>y</code>, <code>width</code>,
+     *         and <code>height</code> properties as this Rectangle object;
+     *         otherwise <code>false</code>.
+     */
+    Rectangle.prototype.equals = function (toCompare) {
+        return this._adaptee.equals(toCompare.adaptee);
+    };
+    /**
+     * Copies all of rectangle data from the source Rectangle object into the
+     * calling Rectangle object.
+     *
+     * @param sourceRect The Rectangle object from which to copy the data.
+     */
+    Rectangle.prototype.copyFrom = function (sourceRect) {
+        this._adaptee.copyFrom(sourceRect.adaptee);
+    };
+    /**
+     * Sets the members of Rectangle to the specified values
+     *
+     * @param xa      The <i>x</i> coordinate of the top-left corner of the
+     *                rectangle.
+     * @param ya      The <i>y</i> coordinate of the top-left corner of the
+     *                rectangle.
+     * @param widtha  The width of the rectangle, in pixels.
+     * @param heighta The height of the rectangle, in pixels.
+     */
+    Rectangle.prototype.setTo = function (x, y, width, height) {
+        this._adaptee.setTo(+x, +y, +width, +height);
+    };
+    /**
+     * Builds and returns a string that lists the horizontal and vertical
+     * positions and the width and height of the Rectangle object.
+     *
+     * @return A string listing the value of each of the following properties of
+     *         the Rectangle object: <code>x</code>, <code>y</code>,
+     *         <code>width</code>, and <code>height</code>.
+     */
+    Rectangle.prototype.toString = function () {
+        return '(x=' + this.x + ', y=' + this.y + ', w=' + this.width + ', h=' + this.height + ')';
+    };
+    Rectangle.prototype.hashCode = function () {
+        var hash = 0;
+        hash += this.x * 20 | 0;
+        hash *= 37;
+        hash += this.y * 20 | 0;
+        hash *= 37;
+        hash += this.width * 20 | 0;
+        hash *= 37;
+        hash += this.height * 20 | 0;
+        return hash;
+    };
+    Rectangle.prototype.writeExternal = function (output) {
+        output.writeFloat(this.x);
+        output.writeFloat(this.y);
+        output.writeFloat(this.width);
+        output.writeFloat(this.height);
+    };
+    Rectangle.prototype.readExternal = function (input) {
+        this.x = input.readFloat();
+        this.y = input.readFloat();
+        this.width = input.readFloat();
+        this.height = input.readFloat();
+    };
+    // Called whenever the class is initialized.
+    Rectangle.classInitializer = null;
+    // List of static symbols to link.
+    Rectangle.classSymbols = null; // [];
+    // List of instance symbols to link.
+    Rectangle.instanceSymbols = null;
+    return Rectangle;
+}(ASObject));
+export { Rectangle };

package/dist/lib/geom/Transform.d.ts

@@ -0,0 +1,42 @@
+import { ASObject } from '@awayfl/avm2';
+import { Matrix } from './Matrix';
+import { ColorTransform } from './ColorTransform';
+import { Rectangle } from './Rectangle';
+import { Matrix3D } from './Matrix3D';
+import { PerspectiveProjection } from './PerspectiveProjection';
+import { DisplayObject } from '../display/DisplayObject';
+import { Transform as AwayTransform } from '@awayjs/core';
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare class Transform extends ASObject {
+    private _adaptee;
+    static classInitializer: any;
+    get adaptee(): AwayTransform;
+    constructor(displayObjectAdaptee: DisplayObject | AwayTransform);
+    get matrix(): Matrix;
+    set matrix(value: Matrix);
+    get colorTransform(): ColorTransform;
+    set colorTransform(value: ColorTransform);
+    get concatenatedMatrix(): Matrix;
+    get concatenatedColorTransform(): ColorTransform;
+    get pixelBounds(): Rectangle;
+    get matrix3D(): Matrix3D;
+    set matrix3D(m: Matrix3D);
+    getRelativeMatrix3D(relativeTo: DisplayObject): Matrix3D;
+    get perspectiveProjection(): PerspectiveProjection;
+    set perspectiveProjection(projection: PerspectiveProjection);
+}
+//# sourceMappingURL=Transform.d.ts.map

package/dist/lib/geom/Transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../lib/geom/Transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA8B,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD,OAAO,EAAE,SAAS,IAAI,aAAa,EAAwC,MAAM,cAAc,CAAC;AAGhG;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,SAAU,SAAQ,QAAQ;IACtC,OAAO,CAAC,QAAQ,CAAgB;IAEhC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,IAAW,OAAO,IAAI,aAAa,CAElC;gBAEY,oBAAoB,EAAE,aAAa,GAAG,aAAa;IAShE,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,MAAM,CAAC,KAAK,EAAE,MAAM,EAE9B;IAED,IAAW,cAAc,IAAI,cAAc,CAE1C;IAED,IAAW,cAAc,CAAC,KAAK,EAAE,cAAc,EAE9C;IAED,IAAW,kBAAkB,IAAI,MAAM,CAEtC;IAED,IAAW,0BAA0B,IAAI,cAAc,CAItD;IAED,IAAW,WAAW,IAAI,SAAS,CAKlC;IAED,IAAW,QAAQ,IAAI,QAAQ,CAE9B;IAED,IAAW,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAE9B;IAEM,mBAAmB,CAAC,UAAU,EAAE,aAAa,GAAG,QAAQ;IAQ/D,IAAW,qBAAqB,IAAI,qBAAqB,CAIxD;IAED,IAAW,qBAAqB,CAAC,UAAU,EAAE,qBAAqB,EAEjE;CACD"}

package/dist/lib/geom/Transform.js

@@ -0,0 +1,112 @@
+import { __extends } from "tslib";
+import { ASObject, Errors, checkNullParameter } from '@awayfl/avm2';
+import { release, notImplemented } from '@awayfl/swf-loader';
+import { PerspectiveProjection } from './PerspectiveProjection';
+import { Transform as AwayTransform } from '@awayjs/core';
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: Transform
+var Transform = /** @class */ (function (_super) {
+    __extends(Transform, _super);
+    function Transform(displayObjectAdaptee) {
+        var _this = _super.call(this) || this;
+        if (!displayObjectAdaptee)
+            _this.sec.throwError('ArgumentError', Errors.NullPointerError, 'displayObject');
+        _this._adaptee = (displayObjectAdaptee instanceof AwayTransform) ? displayObjectAdaptee : new AwayTransform();
+        return _this;
+    }
+    Object.defineProperty(Transform.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "matrix", {
+        get: function () {
+            return new this.sec.flash.geom.Matrix(this._adaptee.matrix);
+        },
+        set: function (value) {
+            this._adaptee.matrix = value.adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "colorTransform", {
+        get: function () {
+            return new this.sec.flash.geom.ColorTransform(this._adaptee.colorTransform.clone());
+        },
+        set: function (value) {
+            this._adaptee.colorTransform = value.adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "concatenatedMatrix", {
+        get: function () {
+            return new this.sec.flash.geom.Matrix(this._adaptee.matrix);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "concatenatedColorTransform", {
+        get: function () {
+            release || notImplemented('public flash.geom.Transform::get concatenatedColorTransform');
+            return new this.sec.flash.geom.ColorTransform(this._adaptee.colorTransform);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "pixelBounds", {
+        get: function () {
+            // Only somewhat implemented because this is largely untested.
+            release || notImplemented('public flash.geom.Transform::get pixelBounds');
+            return new this.sec.flash.geom.Rectangle(this._adaptee.pixelBounds);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transform.prototype, "matrix3D", {
+        get: function () {
+            return new this.sec.flash.geom.Matrix3D(this._adaptee.matrix3D);
+        },
+        set: function (m) {
+            release || notImplemented('public flash.geom.Transform::set matrix3D');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Transform.prototype.getRelativeMatrix3D = function (relativeTo) {
+        checkNullParameter(relativeTo, 'relativeTo', this.sec);
+        release || notImplemented('public flash.geom.Transform::getRelativeMatrix3D');
+        // TODO: actually calculate the relative matrix.
+        return new this.sec.flash.geom.Matrix3D(this._adaptee.matrix3D);
+    };
+    Object.defineProperty(Transform.prototype, "perspectiveProjection", {
+        get: function () {
+            release || notImplemented('public flash.geom.Transform::get perspectiveProjection');
+            return new PerspectiveProjection();
+        },
+        set: function (projection) {
+            release || notImplemented('public flash.geom.Transform::set perspectiveProjection');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Transform.classInitializer = null;
+    return Transform;
+}(ASObject));
+export { Transform };