@awayfl/avm2/dist/lib/nat/ASError.js

Virtual machine for executing AS3 code

import { __extends } from "tslib";
import { ASObject } from './ASObject';
import { getErrorInfo, formatErrorMessage, getErrorMessage } from '../errors';
import { defineNonEnumerableProperty } from '@awayfl/swf-loader';
var ASError = /** @class */ (function (_super) {
    __extends(ASError, _super);
    function ASError(message, id) {
        var _this = _super.call(this) || this;
        if (arguments.length < 1) {
            message = '';
        }
        _this.$Bgmessage = String(message);
        _this._errorID = id | 0;
        return _this;
    }
    ASError.throwError = function (type, id) {
        var rest = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            rest[_i - 2] = arguments[_i];
        }
        var info = getErrorInfo(id);
        var args = [info];
        for (var i = 0; i < rest.length; i++) {
            args.push(rest[i]);
        }
        var message = formatErrorMessage.apply(null, args);
        throw type.axConstruct([message, id]);
    };
    ASError.classInitializer = function (asClass) {
        defineNonEnumerableProperty(this, '$Bglength', 1);
        defineNonEnumerableProperty(this.dPrototype, '$Bgname', this.classInfo.instanceInfo.multiname.name);
        if (asClass === ASError) {
            defineNonEnumerableProperty(this.dPrototype, '$Bgmessage', 'Error');
            defineNonEnumerableProperty(this.dPrototype, '$BgtoString', ASError.prototype.toString);
        }
    };
    ASError.prototype.toString = function () {
        return this.$Bgmessage !== '' ? this.$Bgname + ': ' + this.$Bgmessage : this.$Bgname;
    };
    Object.defineProperty(ASError.prototype, "errorID", {
        get: function () {
            return this._errorID;
        },
        enumerable: false,
        configurable: true
    });
    ASError.prototype.getStackTrace = function () {
        // Stack traces are only available in debug builds. We only do opt.
        return null;
    };
    ASError.getErrorMessage = getErrorMessage;
    return ASError;
}(ASObject));
export { ASError };
var ASDefinitionError = /** @class */ (function (_super) {
    __extends(ASDefinitionError, _super);
    function ASDefinitionError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASDefinitionError;
}(ASError));
export { ASDefinitionError };
var ASEvalError = /** @class */ (function (_super) {
    __extends(ASEvalError, _super);
    function ASEvalError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASEvalError;
}(ASError));
export { ASEvalError };
var ASRangeError = /** @class */ (function (_super) {
    __extends(ASRangeError, _super);
    function ASRangeError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASRangeError;
}(ASError));
export { ASRangeError };
var ASReferenceError = /** @class */ (function (_super) {
    __extends(ASReferenceError, _super);
    function ASReferenceError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASReferenceError;
}(ASError));
export { ASReferenceError };
var ASSecurityError = /** @class */ (function (_super) {
    __extends(ASSecurityError, _super);
    function ASSecurityError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASSecurityError;
}(ASError));
export { ASSecurityError };
var ASSyntaxError = /** @class */ (function (_super) {
    __extends(ASSyntaxError, _super);
    function ASSyntaxError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASSyntaxError;
}(ASError));
export { ASSyntaxError };
var ASTypeError = /** @class */ (function (_super) {
    __extends(ASTypeError, _super);
    function ASTypeError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASTypeError;
}(ASError));
export { ASTypeError };
var ASURIError = /** @class */ (function (_super) {
    __extends(ASURIError, _super);
    function ASURIError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASURIError;
}(ASError));
export { ASURIError };
var ASVerifyError = /** @class */ (function (_super) {
    __extends(ASVerifyError, _super);
    function ASVerifyError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASVerifyError;
}(ASError));
export { ASVerifyError };
var ASUninitializedError = /** @class */ (function (_super) {
    __extends(ASUninitializedError, _super);
    function ASUninitializedError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASUninitializedError;
}(ASError));
export { ASUninitializedError };
var ASArgumentError = /** @class */ (function (_super) {
    __extends(ASArgumentError, _super);
    function ASArgumentError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASArgumentError;
}(ASError));
export { ASArgumentError };
var ASIOError = /** @class */ (function (_super) {
    __extends(ASIOError, _super);
    function ASIOError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASIOError;
}(ASError));
export { ASIOError };
var ASEOFError = /** @class */ (function (_super) {
    __extends(ASEOFError, _super);
    function ASEOFError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASEOFError;
}(ASError));
export { ASEOFError };
var ASMemoryError = /** @class */ (function (_super) {
    __extends(ASMemoryError, _super);
    function ASMemoryError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASMemoryError;
}(ASError));
export { ASMemoryError };
var ASIllegalOperationError = /** @class */ (function (_super) {
    __extends(ASIllegalOperationError, _super);
    function ASIllegalOperationError() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ASIllegalOperationError;
}(ASError));
export { ASIllegalOperationError };