@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/geom/Vector3D.js

@@ -0,0 +1,434 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { Vector3D as AwayVector3D } 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: Vector3D
+var Vector3D = /** @class */ (function (_super) {
+    __extends(Vector3D, _super);
+    /**
+   * Creates an instance of a Vector3D object. If you do not specify a
+   * parameter for the constructor, a Vector3D object is created with
+   * the elements (0,0,0,0).
+   *
+   * @param x The first element, such as the x coordinate.
+   * @param y The second element, such as the y coordinate.
+   * @param z The third element, such as the z coordinate.
+   * @param w An optional element for additional data such as the angle
+   *          of rotation.
+   */
+    function Vector3D(xAdaptee, y, z, w) {
+        if (xAdaptee === void 0) { xAdaptee = 0; }
+        if (y === void 0) { y = 0; }
+        if (z === void 0) { z = 0; }
+        if (w === void 0) { w = 0; }
+        var _this = _super.call(this) || this;
+        _this._adaptee = (xAdaptee instanceof AwayVector3D) ? xAdaptee : new AwayVector3D(+xAdaptee, +y, +z, +w);
+        return _this;
+    }
+    Vector3D.classInitializer = function () {
+        this.X_AXIS = Object.freeze(this.Create(1, 0, 0, 0));
+        this.Y_AXIS = Object.freeze(this.Create(1, 0, 0, 0));
+        this.Z_AXIS = Object.freeze(this.Create(1, 0, 0, 0));
+    };
+    Vector3D.Create = function (x, y, z, w) {
+        var v = Object.create(this.tPrototype);
+        v._adaptee = new AwayVector3D(x, y, z, w);
+        /*v.x = x;
+    v.y = y;
+    v.z = z;
+    v.w = w;*/
+        return v;
+    };
+    Object.defineProperty(Vector3D.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "x", {
+        /**
+       * The first element of a Vector3D object, such as the x coordinate of
+       * a point in the three-dimensional space. The default value is 0.
+       */
+        get: function () {
+            return this._adaptee._rawData[0];
+        },
+        set: function (value) {
+            this._adaptee._rawData[0] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "y", {
+        /*
+       *The second element of a Vector3D object, such as the y coordinate of
+       * a point in the three-dimensional space. The default value is 0.
+       */
+        get: function () {
+            return this._adaptee._rawData[1];
+        },
+        set: function (value) {
+            this._adaptee._rawData[1] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "z", {
+        /**
+       * The third element of a Vector3D object, such as the z coordinate of
+       * a point in the three-dimensional space. The default value is 0.
+       */
+        get: function () {
+            return this._adaptee._rawData[2];
+        },
+        set: function (value) {
+            this._adaptee._rawData[2] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "w", {
+        /**
+       * The fourth element of a Vector3D object (in addition to the x, y,
+       * and z properties) can hold data such as the angle of rotation. The
+       * default value is 0.
+       *
+       * <p>Quaternion notation employs an angle as the fourth element in
+       * its calculation of three-dimensional rotation. The w property can
+       * be used to define the angle of rotation about the Vector3D object.
+       * The combination of the rotation angle and the coordinates (x,y,z)
+       * determines the display object's orientation.</p>
+       *
+       * <p>In addition, the w property can be used as a perspective warp
+       * factor for a projected three-dimensional position or as a projection
+       * transform value in representing a three-dimensional coordinate
+       * projected into the two-dimensional space. For example, you can
+       * create a projection matrix using the <code>Matrix3D.rawData</code>
+       * property, that, when applied to a Vector3D object, produces a
+       * transform value in the Vector3D object's fourth element (the w
+       * property). Dividing the Vector3D object's other elements by the
+       * transform value then produces a projected Vector3D object. You can
+       * use the <code>Vector3D.project()</code> method to divide the first
+       * three elements of a Vector3D object by its fourth element.</p>
+       */
+        get: function () {
+            return this._adaptee._rawData[3];
+        },
+        set: function (value) {
+            this._adaptee._rawData[3] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "length", {
+        /**
+       * The length, magnitude, of the current Vector3D object from the
+       * origin (0,0,0) to the object's x, y, and z coordinates. The w
+       * property is ignored. A unit vector has a length or magnitude of
+       * one.
+       */
+        get: function () {
+            return this._adaptee.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector3D.prototype, "lengthSquared", {
+        /**
+       * The square of the length of the current Vector3D object, calculated
+       * using the x, y, and z properties. The w property is ignored. Use the
+       * <code>lengthSquared()</code> method whenever possible instead of the
+       * slower <code>Math.sqrt()</code> method call of the
+       * <code>Vector3D.length()</code> method.
+       */
+        get: function () {
+            return this._adaptee.lengthSquared;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+   * Returns the angle in radians between two vectors. The returned angle
+   * is the smallest radian the first Vector3D object rotates until it
+   * aligns with the second Vector3D object.
+   *
+   * <p>The <code>angleBetween()</code> method is a static method. You
+   * can use it directly as a method of the Vector3D class.</p>
+   *
+   * <p>To convert a degree to a radian, you can use the following
+   * formula:</p>
+   *
+   * <p><code>radian = Math.PI/180 * degree</code></p>
+   *
+   * @param a The first Vector3D object.
+   * @param b The second Vector3D object.
+   * @returns The angle between two Vector3D objects.
+   */
+    Vector3D.angleBetween = function (a, b) {
+        return AwayVector3D.angleBetween(a.adaptee, b.adaptee);
+    };
+    /**
+   * Returns the distance between two Vector3D objects. The
+   * <code>distance()</code> method is a static method. You can use it
+   * directly as a method of the Vector3D export class to get the Euclidean
+   * distance between two three-dimensional points.
+   *
+   * @param pt1 A Vector3D object as the first three-dimensional point.
+   * @param pt2 A Vector3D object as the second three-dimensional point.
+   * @returns The distance between two Vector3D objects.
+   */
+    Vector3D.distance = function (pt1, pt2) {
+        return AwayVector3D.distance(pt1.adaptee, pt2.adaptee);
+    };
+    /**
+   * If the current Vector3D object and the one specified as the
+   * parameter are unit vertices, this method returns the cosine of the
+   * angle between the two vertices. Unit vertices are vertices that
+   * point to the same direction but their length is one. They remove the
+   * length of the vector as a factor in the result. You can use the
+   * <code>normalize()</code> method to convert a vector to a unit
+   * vector.
+   *
+   * <p>The <code>dotProduct()</code> method finds the angle between two
+   * vertices. It is also used in backface culling or lighting
+   * calculations. Backface culling is a procedure for determining which
+   * surfaces are hidden from the viewpoint. You can use the normalized
+   * vertices from the camera, or eye, viewpoint and the cross product of
+   * the vertices of a polygon surface to get the dot product. If the dot
+   * product is less than zero, then the surface is facing the camera or
+   * the viewer. If the two unit vertices are perpendicular to each
+   * other, they are orthogonal and the dot product is zero. If the two
+   * vertices are parallel to each other, the dot product is one.</p>
+   *
+   * @param a The second Vector3D object.
+   * @returns A scalar which is the dot product of the current Vector3D
+   *          object and the specified Vector3D object.
+   */
+    Vector3D.prototype.dotProduct = function (a) {
+        return this._adaptee.dotProduct(a.adaptee);
+    };
+    /**
+   * Returns a new Vector3D object that is perpendicular (at a right
+   * angle) to the current Vector3D and another Vector3D object. If the
+   * returned Vector3D object's coordinates are (0,0,0), then the two
+   * Vector3D objects are parallel to each other.
+   *
+   * <p>You can use the normalized cross product of two vertices of a
+   * polygon surface with the normalized vector of the camera or eye
+   * viewpoint to get a dot product. The value of the dot product can
+   * identify whether a surface of a three-dimensional object is hidden
+   * from the viewpoint.</p>
+   *
+   * @param a A second Vector3D object.
+   * @returns A new Vector3D object that is perpendicular to the current
+   *          Vector3D object and the Vector3D object specified as the
+   *          parameter.
+   */
+    Vector3D.prototype.crossProduct = function (a) {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.crossProduct(a.adaptee));
+    };
+    /**
+   * Converts a Vector3D object to a unit vector by dividing the first
+   * three elements (x, y, z) by the length of the vector. Unit vertices
+   * are vertices that have a direction but their length is one. They
+   * simplify vector calculations by removing length as a factor.
+   */
+    Vector3D.prototype.normalize = function () {
+        return this._adaptee.normalize();
+    };
+    /**
+   * Scales the current Vector3D object by a scalar, a magnitude. The
+   * Vector3D object's x, y, and z elements are multiplied by the scalar
+   * number specified in the parameter. For example, if the vector is
+   * scaled by ten, the result is a vector that is ten times longer. The
+   * scalar can also change the direction of the vector. Multiplying the
+   * vector by a negative number reverses its direction.
+   *
+   * @param s A multiplier (scalar) used to scale a Vector3D object.
+   */
+    Vector3D.prototype.scaleBy = function (s) {
+        this._adaptee.scaleBy(+s);
+    };
+    /**
+   * Increments the value of the x, y, and z elements of the current
+   * Vector3D object by the values of the x, y, and z elements of a
+   * specified Vector3D object. Unlike the <code>Vector3D.add()</code>
+   * method, the <code>incrementBy()</code> method changes the current
+   * Vector3D object and does not return a new Vector3D object.
+   *
+   * @param a The Vector3D object to be added to the current Vector3D
+   *          object.
+   */
+    Vector3D.prototype.incrementBy = function (a) {
+        this._adaptee.incrementBy(a.adaptee);
+    };
+    /**
+   * Decrements the value of the x, y, and z elements of the current
+   * Vector3D object by the values of the x, y, and z elements of
+   * specified Vector3D object. Unlike the
+   * <code>Vector3D.subtract()</code> method, the
+   * <code>decrementBy()</code> method changes the current Vector3D
+   * object and does not return a new Vector3D object.
+   *
+   * @param a The Vector3D object containing the values to subtract from
+   *          the current Vector3D object.
+   */
+    Vector3D.prototype.decrementBy = function (a) {
+        this._adaptee.decrementBy(a.adaptee);
+    };
+    /**
+   * Adds the value of the x, y, and z elements of the current Vector3D
+   * object to the values of the x, y, and z elements of another Vector3D
+   * object. The <code>add()</code> method does not change the current
+   * Vector3D object. Instead, it returns a new Vector3D object with
+   * the new values.
+   *
+   * <p>The result of adding two vectors together is a resultant vector.
+   * One way to visualize the result is by drawing a vector from the
+   * origin or tail of the first vector to the end or head of the second
+   * vector. The resultant vector is the distance between the origin
+   * point of the first vector and the end point of the second vector.
+   * </p>
+   */
+    Vector3D.prototype.add = function (a) {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.add(a.adaptee));
+    };
+    /**
+   * Subtracts the value of the x, y, and z elements of the current
+   * Vector3D object from the values of the x, y, and z elements of
+   * another Vector3D object. The <code>subtract()</code> method does not
+   * change the current Vector3D object. Instead, this method returns a
+   * new Vector3D object with the new values.
+   *
+   * @param a The Vector3D object to be subtracted from the current
+   *          Vector3D object.
+   * @returns A new Vector3D object that is the difference between the
+   *          current Vector3D and the specified Vector3D object.
+   */
+    Vector3D.prototype.subtract = function (a) {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.subtract(a.adaptee));
+    };
+    /**
+   * Sets the current Vector3D object to its inverse. The inverse object
+   * is also considered the opposite of the original object. The value of
+   * the x, y, and z properties of the current Vector3D object is changed
+   * to -x, -y, and -z.
+   */
+    Vector3D.prototype.negate = function () {
+        this._adaptee.negate();
+    };
+    /**
+   * Determines whether two Vector3D objects are equal by comparing the
+   * x, y, and z elements of the current Vector3D object with a
+   * specified Vector3D object. If the values of these elements are the
+   * same, the two Vector3D objects are equal. If the second optional
+   * parameter is set to true, all four elements of the Vector3D objects,
+   * including the w property, are compared.
+   *
+   * @param toCompare The Vector3D object to be compared with the current
+   *                  Vector3D object.
+   * @param allFour   An optional parameter that specifies whether the w
+   *                  property of the Vector3D objects is used in the
+   *                  comparison.
+   * @returns A value of true if the specified Vector3D object is equal
+   *          to the current Vector3D object; false if it is not equal.
+   */
+    Vector3D.prototype.equals = function (toCompare, allFour) {
+        return this._adaptee.equals(toCompare.adaptee, allFour);
+    };
+    /**
+   * Compares the elements of the current Vector3D object with the
+   * elements of a specified Vector3D object to determine whether they
+   * are nearly equal. The two Vector3D objects are nearly equal if the
+   * value of all the elements of the two vertices are equal, or the
+   * result of the comparison is within the tolerance range. The
+   * difference between two elements must be less than the number
+   * specified as the tolerance parameter. If the third optional
+   * parameter is set to <code>true</code>, all four elements of the
+   * Vector3D objects, including the <code>w</code> property, are
+   * compared. Otherwise, only the x, y, and z elements are included in
+   * the comparison.
+   *
+   * @param toCompare The Vector3D object to be compared with the current
+   *                  Vector3D object.
+   * @param tolerance A number determining the tolerance factor. If the
+   *                  difference between the values of the Vector3D
+   *                  element specified in the toCompare parameter and
+   *                  the current Vector3D element is less than the
+   *                  tolerance number, the two values are considered
+   *                  nearly equal.
+   * @param allFour   An optional parameter that specifies whether the w
+   *                  property of the Vector3D objects is used in the
+   *                  comparison.
+   * @returns A value of true if the specified Vector3D object is nearly
+   *          equal to the current Vector3D object; false if it is not
+   *          equal.
+   */
+    Vector3D.prototype.nearEquals = function (toCompare, tolerance, allFour) {
+        return this._adaptee.nearEquals(toCompare.adaptee, tolerance, allFour);
+    };
+    /**
+   * Divides the value of the <code>x</code>, <code>y</code>, and
+   * <code>z</code> properties of the current Vector3D object by the
+   * value of its <code>w</code> property.
+   *
+   * <p>If the current Vector3D object is the result of multiplying a
+   * Vector3D object by a projection Matrix3D object, the w property can
+   * hold the transform value. The <code>project()</code> method then can
+   * complete the projection by dividing the elements by the
+   * <code>w</code> property. Use the <code>Matrix3D.rawData</code>
+   * property to create a projection Matrix3D object.</p>
+   */
+    Vector3D.prototype.project = function () {
+        this._adaptee.project();
+    };
+    /**
+   * Copies all of vector data from the source Vector3D object into the
+   * calling Vector3D object.
+   *
+   * @param sourceVector3D The Vector3D object from which to copy the data.
+   */
+    Vector3D.prototype.copyFrom = function (sourceVector3D) {
+        this._adaptee.copyFrom(sourceVector3D.adaptee);
+    };
+    /**
+   * Sets the members of Vector3D to the specified values
+   *
+   * @param xa The first element, such as the x coordinate.
+   * @param ya The second element, such as the y coordinate.
+   * @param za The third element, such as the z coordinate.
+   */
+    Vector3D.prototype.setTo = function (xa, ya, za) {
+        this._adaptee.setTo(xa, ya, za);
+    };
+    /**
+   * Returns a new Vector3D object that is an exact copy of the current
+   * Vector3D object.
+   *
+   * @returns A new Vector3D object that is a copy of the current
+   * Vector3D object.
+   */
+    Vector3D.prototype.clone = function () {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.clone());
+    };
+    Vector3D.prototype.toString = function () {
+        return 'Vector3D(' + this.x + ', ' + this.y + ', ' + this.z + ')';
+    };
+    return Vector3D;
+}(ASObject));
+export { Vector3D };

package/dist/lib/globalization/LocaleID.d.ts

@@ -0,0 +1,38 @@
+import { ASObject, GenericVector } from '@awayfl/avm2';
+export declare abstract class LastOperationStatus {
+    static readonly BUFFER_OVERFLOW_ERROR: string;
+    static readonly ERROR_CODE_UNKNOWN: string;
+    static readonly ILLEGAL_ARGUMENT_ERROR: string;
+    static readonly INDEX_OUT_OF_BOUNDS_ERROR: string;
+    static readonly INVALID_ATTR_VALUE: string;
+    static readonly INVALID_CHAR_FOUND: string;
+    static readonly MEMORY_ALLOCATION_ERROR: string;
+    static readonly NO_ERROR: string;
+    static readonly NUMBER_OVERFLOW_ERROR: string;
+    static readonly PARSE_ERROR: string;
+    static readonly PATTERN_SYNTAX_ERROR: string;
+    static readonly PLATFORM_API_FAILED: string;
+    static readonly TRUNCATED_CHAR_FOUND: string;
+    static readonly UNEXPECTED_TOKEN: string;
+    static readonly UNSUPPORTED_ERROR: string;
+    static readonly USING_DEFAULT_WARNING: string;
+    static readonly USING_FALLBACK_WARNING: string;
+}
+export declare class LocaleID extends ASObject {
+    private _name;
+    static axClass: typeof LocaleID;
+    readonly DEFAULT: string;
+    private _lastOperationStatus;
+    get lastOperationStatus(): string;
+    get name(): string;
+    get ctor(): typeof LocaleID;
+    constructor(_name: string);
+    static determinePreferredLocales(want: GenericVector, have: GenericVector, keyword?: string): GenericVector;
+    getLanguage(): string;
+    getRegion(): string;
+    getScript(): string;
+    getVariant(): String;
+    isRightToLeft(): Boolean;
+    getKeysAndValues(): Object;
+}
+//# sourceMappingURL=LocaleID.d.ts.map

package/dist/lib/globalization/LocaleID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocaleID.d.ts","sourceRoot":"","sources":["../../../lib/globalization/LocaleID.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAW,MAAM,cAAc,CAAC;AAEhE,8BAAsB,mBAAmB;IACxC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAyB;IACtE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAsB;IAChE,MAAM,CAAC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAA0B;IACxE,MAAM,CAAC,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAA2B;IAC5E,MAAM,CAAC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAsB;IAChE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAsB;IAChE,MAAM,CAAC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAA2B;IAC1E,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAa;IAC7C,MAAM,CAAC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAyB;IACtE,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAgB;IACnD,MAAM,CAAC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAwB;IACpE,MAAM,CAAC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAuB;IAClE,MAAM,CAAC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAwB;IACpE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAqB;IAC7D,MAAM,CAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAsB;IAC/D,MAAM,CAAC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAyB;IACtE,MAAM,CAAC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAA0B;CACxE;AAED,qBAAa,QAAS,SAAQ,QAAQ;IAmBzB,OAAO,CAAC,KAAK;IAlBzB,MAAM,CAAC,OAAO,EAAE,OAAO,QAAQ,CAAC;IAEhC,SAAgB,OAAO,EAAE,MAAM,CAAe;IAE9C,OAAO,CAAC,oBAAoB,CAAqD;IAEjF,IAAW,mBAAmB,IAAI,MAAM,CAEvC;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAI,IAAI,oBAEP;gBAEmB,KAAK,EAAE,MAAM;WAInB,yBAAyB,CACtC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,MAAwB,GAC/B,aAAa;IAMhB,WAAW,IAAI,MAAM;IAOrB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,UAAU,IAAI,MAAM;IAOpB,aAAa,IAAI,OAAO;IAMxB,gBAAgB,IAAI,MAAM;CAM1B"}

package/dist/lib/globalization/LocaleID.js

@@ -0,0 +1,92 @@
+import { __extends } from "tslib";
+import { ASObject, GenericVector } from '@awayfl/avm2';
+var LastOperationStatus = /** @class */ (function () {
+    function LastOperationStatus() {
+    }
+    LastOperationStatus.BUFFER_OVERFLOW_ERROR = 'bufferOverflowError';
+    LastOperationStatus.ERROR_CODE_UNKNOWN = 'errorCodeUnknown';
+    LastOperationStatus.ILLEGAL_ARGUMENT_ERROR = 'illegalArgumentError';
+    LastOperationStatus.INDEX_OUT_OF_BOUNDS_ERROR = 'indexOutOfBoundsError';
+    LastOperationStatus.INVALID_ATTR_VALUE = 'invalidAttrValue';
+    LastOperationStatus.INVALID_CHAR_FOUND = 'invalidCharFound';
+    LastOperationStatus.MEMORY_ALLOCATION_ERROR = 'memoryAllocationError';
+    LastOperationStatus.NO_ERROR = 'noError';
+    LastOperationStatus.NUMBER_OVERFLOW_ERROR = 'numberOverflowError';
+    LastOperationStatus.PARSE_ERROR = 'parseError';
+    LastOperationStatus.PATTERN_SYNTAX_ERROR = 'patternSyntaxError';
+    LastOperationStatus.PLATFORM_API_FAILED = 'platformAPIFailed';
+    LastOperationStatus.TRUNCATED_CHAR_FOUND = 'truncatedCharFound';
+    LastOperationStatus.UNEXPECTED_TOKEN = 'unexpectedToken';
+    LastOperationStatus.UNSUPPORTED_ERROR = 'unsupportedError';
+    LastOperationStatus.USING_DEFAULT_WARNING = 'usingDefaultWarning';
+    LastOperationStatus.USING_FALLBACK_WARNING = 'usingFallbackWarning';
+    return LastOperationStatus;
+}());
+export { LastOperationStatus };
+var LocaleID = /** @class */ (function (_super) {
+    __extends(LocaleID, _super);
+    function LocaleID(_name) {
+        var _this = _super.call(this) || this;
+        _this._name = _name;
+        _this.DEFAULT = 'i-default';
+        _this._lastOperationStatus = LastOperationStatus.USING_DEFAULT_WARNING;
+        return _this;
+    }
+    Object.defineProperty(LocaleID.prototype, "lastOperationStatus", {
+        get: function () {
+            return this._lastOperationStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LocaleID.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LocaleID.prototype, "ctor", {
+        get: function () {
+            return LocaleID;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LocaleID.determinePreferredLocales = function (want, have, keyword) {
+        if (keyword === void 0) { keyword = 'userinterface'; }
+        console.warn('[LocaleID] `determinePreferredLocales` not implemented');
+        return new GenericVector();
+    };
+    LocaleID.prototype.getLanguage = function () {
+        console.warn('[LocaleID] `getLanguage` not implemented, use default: en');
+        this._lastOperationStatus = LastOperationStatus.NO_ERROR;
+        return 'en';
+    };
+    LocaleID.prototype.getRegion = function () {
+        console.warn('[LocaleID] `getRegion` not implemented, use default: UK');
+        this._lastOperationStatus = LastOperationStatus.NO_ERROR;
+        return 'UK';
+    };
+    LocaleID.prototype.getScript = function () {
+        console.warn('[LocaleID] `getScript` not implemented, use default: \'\'');
+        this._lastOperationStatus = LastOperationStatus.USING_DEFAULT_WARNING;
+        return '';
+    };
+    LocaleID.prototype.getVariant = function () {
+        console.warn('[LocaleID] `getVariant` not implemented, use default: \'\'');
+        this._lastOperationStatus = LastOperationStatus.USING_DEFAULT_WARNING;
+        return '';
+    };
+    LocaleID.prototype.isRightToLeft = function () {
+        console.warn('[LocaleID] `isRightToLeft` not implemented, use default: true');
+        return true;
+    };
+    LocaleID.prototype.getKeysAndValues = function () {
+        console.warn('[LocaleID] `isRightToLeft` not implemented, use default: null');
+        this._lastOperationStatus = LastOperationStatus.USING_DEFAULT_WARNING;
+        return null;
+    };
+    return LocaleID;
+}(ASObject));
+export { LocaleID };