sval
Version:
A javascript interpreter written in javascript
1,216 lines (1,197 loc) • 213 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('acorn')) :
typeof define === 'function' && define.amd ? define(['acorn'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sval = factory(global.acorn));
})(this, (function (acorn) { 'use strict';
var statement$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
get ExpressionStatement () { return ExpressionStatement$1; },
get BlockStatement () { return BlockStatement$1; },
get EmptyStatement () { return EmptyStatement$1; },
get DebuggerStatement () { return DebuggerStatement$1; },
get ReturnStatement () { return ReturnStatement$1; },
get BreakStatement () { return BreakStatement$1; },
get ContinueStatement () { return ContinueStatement$1; },
get LabeledStatement () { return LabeledStatement$1; },
get WithStatement () { return WithStatement$1; },
get IfStatement () { return IfStatement$1; },
get SwitchStatement () { return SwitchStatement$1; },
get SwitchCase () { return SwitchCase$1; },
get ThrowStatement () { return ThrowStatement$1; },
get TryStatement () { return TryStatement$1; },
get CatchClause () { return CatchClause$1; },
get WhileStatement () { return WhileStatement$1; },
get DoWhileStatement () { return DoWhileStatement$1; },
get ForStatement () { return ForStatement$1; },
get ForInStatement () { return ForInStatement$1; },
get ForOfStatement () { return ForOfStatement$1; }
});
var declaration$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
get FunctionDeclaration () { return FunctionDeclaration$1; },
get VariableDeclaration () { return VariableDeclaration$1; },
get VariableDeclarator () { return VariableDeclarator$1; },
get ClassDeclaration () { return ClassDeclaration$1; },
get ClassBody () { return ClassBody$1; },
get MethodDefinition () { return MethodDefinition$1; },
get PropertyDefinition () { return PropertyDefinition$1; },
get StaticBlock () { return StaticBlock$1; },
get ImportDeclaration () { return ImportDeclaration$1; },
get ExportDefaultDeclaration () { return ExportDefaultDeclaration$1; },
get ExportNamedDeclaration () { return ExportNamedDeclaration$1; },
get ExportAllDeclaration () { return ExportAllDeclaration$1; }
});
var statement = /*#__PURE__*/Object.freeze({
__proto__: null,
get ExpressionStatement () { return ExpressionStatement; },
get BlockStatement () { return BlockStatement; },
get EmptyStatement () { return EmptyStatement; },
get DebuggerStatement () { return DebuggerStatement; },
get ReturnStatement () { return ReturnStatement; },
get BreakStatement () { return BreakStatement; },
get ContinueStatement () { return ContinueStatement; },
get LabeledStatement () { return LabeledStatement; },
get WithStatement () { return WithStatement; },
get IfStatement () { return IfStatement; },
get SwitchStatement () { return SwitchStatement; },
get SwitchCase () { return SwitchCase; },
get ThrowStatement () { return ThrowStatement; },
get TryStatement () { return TryStatement; },
get CatchClause () { return CatchClause; },
get WhileStatement () { return WhileStatement; },
get DoWhileStatement () { return DoWhileStatement; },
get ForStatement () { return ForStatement; },
get ForInStatement () { return ForInStatement; },
get ForOfStatement () { return ForOfStatement; }
});
var declaration = /*#__PURE__*/Object.freeze({
__proto__: null,
get FunctionDeclaration () { return FunctionDeclaration; },
get VariableDeclaration () { return VariableDeclaration; },
get VariableDeclarator () { return VariableDeclarator; },
get ClassDeclaration () { return ClassDeclaration; },
get ClassBody () { return ClassBody; },
get MethodDefinition () { return MethodDefinition; },
get PropertyDefinition () { return PropertyDefinition; },
get StaticBlock () { return StaticBlock; },
get ImportDeclaration () { return ImportDeclaration; },
get ExportDefaultDeclaration () { return ExportDefaultDeclaration; },
get ExportNamedDeclaration () { return ExportNamedDeclaration; },
get ExportAllDeclaration () { return ExportAllDeclaration; }
});
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
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
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
var freeze = Object.freeze;
var define = Object.defineProperty;
var getDptor = Object.getOwnPropertyDescriptor;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn(obj, key) {
return hasOwnProperty.call(obj, key);
}
var getOwnNames = Object.getOwnPropertyNames;
var setPrototypeOf = Object.setPrototypeOf;
function setProto(obj, proto) {
setPrototypeOf ? setPrototypeOf(obj, proto) : obj.__proto__ = proto;
}
var getPrototypeOf = Object.getPrototypeOf;
function getProto(obj) {
return getPrototypeOf ? getPrototypeOf(obj) : obj.__proto__;
}
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
function getGetterOrSetter(method, obj, key) {
while (obj) {
var descriptor = getOwnPropertyDescriptor(obj, key);
var value = typeof descriptor !== 'undefined'
&& typeof descriptor.writable === 'undefined'
&& typeof descriptor[method] === 'function'
&& descriptor[method];
if (value) {
return value;
}
else {
obj = getProto(obj);
}
}
}
function getGetter(obj, key) {
return getGetterOrSetter('get', obj, key);
}
function getSetter(obj, key) {
return getGetterOrSetter('set', obj, key);
}
var create = Object.create;
function inherits(subClass, superClass) {
setProto(subClass, superClass);
subClass.prototype = create(superClass.prototype, {
constructor: {
value: subClass,
writable: true,
}
});
}
function _assign(target) {
for (var i = 1; i < arguments.length; ++i) {
var source = arguments[i];
for (var key in source) {
if (hasOwn(source, key)) {
target[key] = source[key];
}
}
}
return target;
}
var assign = Object.assign || _assign;
var names = [];
var globalObj = create(null);
var setGlobalObj = function (g) {
if (!g.Object)
throw 0;
names = getOwnNames(globalObj = g).filter(function (n) { return ['webkitStorageInfo', 'GLOBAL', 'root'].indexOf(n) === -1; });
};
try {
setGlobalObj(window);
}
catch (err) {
try {
setGlobalObj(self);
}
catch (err) {
try {
setGlobalObj(global);
}
catch (err) {
try {
setGlobalObj(globalThis);
}
catch (err) {
try {
globalObj.Object = Object;
}
catch (err) { }
try {
globalObj.Function = Function;
}
catch (err) { }
try {
globalObj.Array = Array;
}
catch (err) { }
try {
globalObj.Number = Number;
}
catch (err) { }
try {
globalObj.parseFloat = parseFloat;
}
catch (err) { }
try {
globalObj.parseInt = parseInt;
}
catch (err) { }
try {
globalObj.Infinity = Infinity;
}
catch (err) { }
try {
globalObj.NaN = NaN;
}
catch (err) { }
try {
globalObj.undefined = undefined;
}
catch (err) { }
try {
globalObj.Boolean = Boolean;
}
catch (err) { }
try {
globalObj.String = String;
}
catch (err) { }
try {
globalObj.Symbol = Symbol;
}
catch (err) { }
try {
globalObj.Date = Date;
}
catch (err) { }
try {
globalObj.Promise = Promise;
}
catch (err) { }
try {
globalObj.RegExp = RegExp;
}
catch (err) { }
try {
globalObj.Error = Error;
}
catch (err) { }
try {
globalObj.EvalError = EvalError;
}
catch (err) { }
try {
globalObj.RangeError = RangeError;
}
catch (err) { }
try {
globalObj.ReferenceError = ReferenceError;
}
catch (err) { }
try {
globalObj.SyntaxError = SyntaxError;
}
catch (err) { }
try {
globalObj.TypeError = TypeError;
}
catch (err) { }
try {
globalObj.URIError = URIError;
}
catch (err) { }
try {
globalObj.JSON = JSON;
}
catch (err) { }
try {
globalObj.Math = Math;
}
catch (err) { }
try {
globalObj.console = console;
}
catch (err) { }
try {
globalObj.Intl = Intl;
}
catch (err) { }
try {
globalObj.ArrayBuffer = ArrayBuffer;
}
catch (err) { }
try {
globalObj.Uint8Array = Uint8Array;
}
catch (err) { }
try {
globalObj.Int8Array = Int8Array;
}
catch (err) { }
try {
globalObj.Uint16Array = Uint16Array;
}
catch (err) { }
try {
globalObj.Int16Array = Int16Array;
}
catch (err) { }
try {
globalObj.Uint32Array = Uint32Array;
}
catch (err) { }
try {
globalObj.Int32Array = Int32Array;
}
catch (err) { }
try {
globalObj.Float32Array = Float32Array;
}
catch (err) { }
try {
globalObj.Float64Array = Float64Array;
}
catch (err) { }
try {
globalObj.Uint8ClampedArray = Uint8ClampedArray;
}
catch (err) { }
try {
globalObj.DataView = DataView;
}
catch (err) { }
try {
globalObj.Map = Map;
}
catch (err) { }
try {
globalObj.Set = Set;
}
catch (err) { }
try {
globalObj.WeakMap = WeakMap;
}
catch (err) { }
try {
globalObj.WeakSet = WeakSet;
}
catch (err) { }
try {
globalObj.Proxy = Proxy;
}
catch (err) { }
try {
globalObj.Reflect = Reflect;
}
catch (err) { }
try {
globalObj.BigInt = BigInt;
}
catch (err) { }
try {
globalObj.decodeURI = decodeURI;
}
catch (err) { }
try {
globalObj.decodeURIComponent = decodeURIComponent;
}
catch (err) { }
try {
globalObj.encodeURI = encodeURI;
}
catch (err) { }
try {
globalObj.encodeURIComponent = encodeURIComponent;
}
catch (err) { }
try {
globalObj.escape = escape;
}
catch (err) { }
try {
globalObj.unescape = unescape;
}
catch (err) { }
try {
globalObj.eval = eval;
}
catch (err) { }
try {
globalObj.isFinite = isFinite;
}
catch (err) { }
try {
globalObj.isNaN = isNaN;
}
catch (err) { }
try {
globalObj.SharedArrayBuffer = SharedArrayBuffer;
}
catch (err) { }
try {
globalObj.Atomics = Atomics;
}
catch (err) { }
try {
globalObj.WebAssembly = WebAssembly;
}
catch (err) { }
try {
globalObj.clearInterval = clearInterval;
}
catch (err) { }
try {
globalObj.clearTimeout = clearTimeout;
}
catch (err) { }
try {
globalObj.setInterval = setInterval;
}
catch (err) { }
try {
globalObj.setTimeout = setTimeout;
}
catch (err) { }
try {
globalObj.crypto = crypto;
}
catch (err) { }
try {
globalObj.URL = URL;
}
catch (err) { }
names = getOwnNames(globalObj);
}
}
}
}
if (globalObj.Symbol) {
!globalObj.Symbol.iterator && (globalObj.Symbol.iterator = createSymbol('iterator'));
!globalObj.Symbol.asyncIterator && (globalObj.Symbol.asyncIterator = createSymbol('asynciterator'));
}
var win = create({});
for (var i = 0; i < names.length; i++) {
var name_1 = names[i];
try {
win[name_1] = globalObj[name_1];
}
catch (err) { }
}
var WINDOW = createSymbol('window');
function createSandBox() {
var _a;
return assign(create((_a = {}, _a[WINDOW] = globalObj, _a)), win);
}
function createSymbol(key) {
return key + Math.random().toString(36).substring(2);
}
function getAsyncIterator(obj) {
var iterator;
if (typeof Symbol === 'function') {
iterator = obj[Symbol.asyncIterator];
!iterator && (iterator = obj[Symbol.iterator]);
}
if (iterator) {
return iterator.call(obj);
}
else if (typeof obj.next === 'function') {
return obj;
}
else {
var i_1 = 0;
return {
next: function () {
if (obj && i_1 >= obj.length)
obj = undefined;
return { value: obj && obj[i_1++], done: !obj };
}
};
}
}
var AWAIT = { RES: undefined };
var RETURN = { RES: undefined };
var CONTINUE = { LABEL: undefined };
var BREAK = { LABEL: undefined };
var SUPER = createSymbol('super');
var SUPERCALL = createSymbol('supercall');
var NOCTOR = createSymbol('noctor');
var CLSCTOR = createSymbol('clsctor');
var NEWTARGET = createSymbol('newtarget');
var PRIVATE = createSymbol('private');
var NOINIT = createSymbol('noinit');
var DEADZONE = createSymbol('deadzone');
var IMPORT = createSymbol('import');
var EXPORTS = createSymbol('exports');
var version = "0.6.1";
var Var = (function () {
function Var(kind, value) {
this.kind = kind;
this.value = value;
}
Var.prototype.get = function () {
return this.value;
};
Var.prototype.set = function (value) {
if (this.kind === 'const') {
throw new TypeError('Assignment to constant variable');
}
else {
return this.value = value;
}
};
return Var;
}());
var Prop = (function () {
function Prop(object, property) {
this.object = object;
this.property = property;
}
Prop.prototype.get = function () {
return this.object[this.property];
};
Prop.prototype.set = function (value) {
this.object[this.property] = value;
return true;
};
Prop.prototype.del = function () {
return delete this.object[this.property];
};
return Prop;
}());
var Scope = (function () {
function Scope(parent, isolated) {
if (parent === void 0) { parent = null; }
if (isolated === void 0) { isolated = false; }
this.context = create(null);
this.withContext = create(null);
this.parent = parent;
this.isolated = isolated;
}
Scope.prototype.global = function () {
var scope = this;
while (scope.parent) {
scope = scope.parent;
}
return scope;
};
Scope.prototype.find = function (name) {
if (this.context[name]) {
return this.context[name];
}
else if (name in this.withContext) {
return new Prop(this.withContext, name);
}
else if (this.parent) {
return this.parent.find(name);
}
else {
var win = this.global().find('window').get();
if (name in win) {
return new Prop(win, name);
}
else {
return null;
}
}
};
Scope.prototype.var = function (name, value) {
var scope = this;
while (scope.parent && !scope.isolated) {
scope = scope.parent;
}
var variable = scope.context[name];
if (!variable) {
scope.context[name] = new Var('var', value === NOINIT ? undefined : value);
}
else {
if (variable.kind === 'var') {
if (value !== NOINIT) {
variable.set(value);
}
}
else {
throw new SyntaxError("Identifier '" + name + "' has already been declared");
}
}
if (!scope.parent) {
var win = scope.find('window').get();
if (value !== NOINIT) {
define(win, name, { value: value, writable: true, enumerable: true });
}
}
};
Scope.prototype.let = function (name, value) {
var variable = this.context[name];
if (!variable || variable.get() === DEADZONE) {
this.context[name] = new Var('let', value);
}
else {
throw new SyntaxError("Identifier '" + name + "' has already been declared");
}
};
Scope.prototype.const = function (name, value) {
var variable = this.context[name];
if (!variable || variable.get() === DEADZONE) {
this.context[name] = new Var('const', value);
}
else {
throw new SyntaxError("Identifier '" + name + "' has already been declared");
}
};
Scope.prototype.func = function (name, value) {
var variable = this.context[name];
if (!variable || variable.kind === 'var') {
this.context[name] = new Var('var', value);
}
else {
throw new SyntaxError("Identifier '" + name + "' has already been declared");
}
};
Scope.prototype.with = function (value) {
if (Object.keys(value)) {
this.withContext = value;
}
};
return Scope;
}());
function runAsync(iterator, options) {
if (options === void 0) { options = {}; }
var res = options.res, err = options.err, ret = options.ret, fullRet = options.fullRet;
return new Promise(function (resolve, reject) {
if ('ret' in options) {
return resolve(iterator.return(ret));
}
if ('err' in options) {
onRejected(err);
}
else {
onFulfilled(res);
}
function onFulfilled(res) {
var ret;
try {
ret = iterator.next(res);
}
catch (e) {
return reject(e);
}
next(ret);
return null;
}
function onRejected(err) {
var ret;
try {
ret = iterator.throw(err);
}
catch (e) {
return reject(e);
}
next(ret);
}
function next(ret) {
if (ret.done)
return resolve(fullRet ? ret : ret.value);
if (ret.value !== AWAIT)
return resolve(ret);
var awaitValue = ret.value.RES;
var value = awaitValue && awaitValue.then === 'function'
? awaitValue : Promise.resolve(awaitValue);
return value.then(onFulfilled, onRejected);
}
});
}
function Identifier$1(node, scope, options) {
var _a, getVar, _b, throwErr, variable, value;
if (options === void 0) { options = {}; }
return __generator(this, function (_c) {
_a = options.getVar, getVar = _a === void 0 ? false : _a, _b = options.throwErr, throwErr = _b === void 0 ? true : _b;
if (node.name === 'undefined') {
return [2, undefined];
}
variable = scope.find(node.name);
if (variable) {
if (getVar) {
return [2, variable];
}
else {
value = variable.get();
if (value === DEADZONE) {
throw new ReferenceError(node.name + " is not defined");
}
else {
return [2, value];
}
}
}
else if (throwErr) {
throw new ReferenceError(node.name + " is not defined");
}
else {
return [2, undefined];
}
});
}
var identifier$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
Identifier: Identifier$1
});
function Literal$1(node, scope) {
return __generator(this, function (_a) {
return [2, node.value];
});
}
var literal$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
Literal: Literal$1
});
function ThisExpression$1(node, scope) {
var superCall;
return __generator(this, function (_a) {
superCall = scope.find(SUPERCALL);
if (superCall && !superCall.get()) {
throw new ReferenceError('Must call super constructor in derived class '
+ 'before accessing \'this\' or returning from derived constructor');
}
else {
return [2, scope.find('this').get()];
}
});
}
function ArrayExpression$1(node, scope) {
var results, i, item, _a, _b, _c, _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
results = [];
i = 0;
_e.label = 1;
case 1:
if (!(i < node.elements.length)) return [3, 6];
item = node.elements[i];
if (!(item.type === 'SpreadElement')) return [3, 3];
_b = (_a = results).concat;
return [5, __values(SpreadElement$1(item, scope))];
case 2:
results = _b.apply(_a, [_e.sent()]);
return [3, 5];
case 3:
_d = (_c = results).push;
return [5, __values(evaluate$1(item, scope))];
case 4:
_d.apply(_c, [_e.sent()]);
_e.label = 5;
case 5:
i++;
return [3, 1];
case 6: return [2, results];
}
});
}
function ObjectExpression$1(node, scope) {
var object, i, property, _a, _b, key, propKey, _c, value, propKind, oriDptor, oriDptor;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
object = {};
i = 0;
_d.label = 1;
case 1:
if (!(i < node.properties.length)) return [3, 11];
property = node.properties[i];
if (!(property.type === 'SpreadElement')) return [3, 3];
_a = assign;
_b = [object];
return [5, __values(SpreadElement$1(property, scope, { spreadProps: true }))];
case 2:
_a.apply(void 0, _b.concat([_d.sent()]));
return [3, 10];
case 3:
key = void 0;
propKey = property.key;
if (!property.computed) return [3, 5];
return [5, __values(evaluate$1(propKey, scope))];
case 4:
key = _d.sent();
return [3, 8];
case 5:
if (!(propKey.type === 'Identifier')) return [3, 6];
key = propKey.name;
return [3, 8];
case 6:
_c = '';
return [5, __values(Literal$1(propKey))];
case 7:
key = _c + (_d.sent());
_d.label = 8;
case 8: return [5, __values(evaluate$1(property.value, scope))];
case 9:
value = _d.sent();
propKind = property.kind;
if (propKind === 'init') {
object[key] = value;
}
else if (propKind === 'get') {
oriDptor = getDptor(object, key);
define(object, key, {
get: value,
set: oriDptor && oriDptor.set,
enumerable: true,
configurable: true
});
}
else {
oriDptor = getDptor(object, key);
define(object, key, {
get: oriDptor && oriDptor.get,
set: value,
enumerable: true,
configurable: true
});
}
_d.label = 10;
case 10:
i++;
return [3, 1];
case 11: return [2, object];
}
});
}
function FunctionExpression$1(node, scope) {
var tmpScope, func;
return __generator(this, function (_a) {
if (node.id && node.id.name) {
tmpScope = new Scope(scope);
func = createFunc(node, tmpScope);
tmpScope.const(node.id.name, func);
return [2, func];
}
else {
return [2, createFunc(node, scope)];
}
});
}
function UnaryExpression$1(node, scope) {
var arg, _a, variable;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
arg = node.argument;
_a = node.operator;
switch (_a) {
case '+': return [3, 1];
case '-': return [3, 3];
case '!': return [3, 5];
case '~': return [3, 7];
case 'void': return [3, 9];
case 'typeof': return [3, 11];
case 'delete': return [3, 15];
}
return [3, 20];
case 1: return [5, __values(evaluate$1(arg, scope))];
case 2: return [2, +(_b.sent())];
case 3: return [5, __values(evaluate$1(arg, scope))];
case 4: return [2, -(_b.sent())];
case 5: return [5, __values(evaluate$1(arg, scope))];
case 6: return [2, !(_b.sent())];
case 7: return [5, __values(evaluate$1(arg, scope))];
case 8: return [2, ~(_b.sent())];
case 9: return [5, __values(evaluate$1(arg, scope))];
case 10: return [2, void (_b.sent())];
case 11:
if (!(arg.type === 'Identifier')) return [3, 13];
return [5, __values(Identifier$1(arg, scope, { throwErr: false }))];
case 12: return [2, typeof (_b.sent())];
case 13: return [5, __values(evaluate$1(arg, scope))];
case 14: return [2, typeof (_b.sent())];
case 15:
if (!(arg.type === 'MemberExpression')) return [3, 17];
return [5, __values(MemberExpression$1(arg, scope, { getVar: true }))];
case 16:
variable = _b.sent();
return [2, variable.del()];
case 17:
if (!(arg.type === 'Identifier')) return [3, 18];
throw new SyntaxError('Delete of an unqualified identifier in strict mode');
case 18: return [5, __values(evaluate$1(arg, scope))];
case 19:
_b.sent();
return [2, true];
case 20: throw new SyntaxError("Unexpected token " + node.operator);
}
});
}
function UpdateExpression$1(node, scope) {
var arg, variable, value;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
arg = node.argument;
if (!(arg.type === 'Identifier')) return [3, 2];
return [5, __values(Identifier$1(arg, scope, { getVar: true }))];
case 1:
variable = _a.sent();
return [3, 5];
case 2:
if (!(arg.type === 'MemberExpression')) return [3, 4];
return [5, __values(MemberExpression$1(arg, scope, { getVar: true }))];
case 3:
variable = _a.sent();
return [3, 5];
case 4: throw new SyntaxError('Unexpected token');
case 5:
value = variable.get();
if (node.operator === '++') {
variable.set(value + 1);
return [2, node.prefix ? variable.get() : value];
}
else if (node.operator === '--') {
variable.set(value - 1);
return [2, node.prefix ? variable.get() : value];
}
else {
throw new SyntaxError("Unexpected token " + node.operator);
}
}
});
}
function BinaryExpression$1(node, scope) {
var left, right;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!(node.left.type === 'PrivateIdentifier')) return [3, 2];
left = node.left.name;
return [5, __values(evaluate$1(node.right, scope))];
case 1:
right = _a.sent();
right = right[PRIVATE] || {};
return [3, 5];
case 2: return [5, __values(evaluate$1(node.left, scope))];
case 3:
left = _a.sent();
return [5, __values(evaluate$1(node.right, scope))];
case 4:
right = _a.sent();
_a.label = 5;
case 5:
switch (node.operator) {
case '==': return [2, left == right];
case '!=': return [2, left != right];
case '===': return [2, left === right];
case '!==': return [2, left !== right];
case '<': return [2, left < right];
case '<=': return [2, left <= right];
case '>': return [2, left > right];
case '>=': return [2, left >= right];
case '<<': return [2, left << right];
case '>>': return [2, left >> right];
case '>>>': return [2, left >>> right];
case '+': return [2, left + right];
case '-': return [2, left - right];
case '*': return [2, left * right];
case '**': return [2, Math.pow(left, right)];
case '/': return [2, left / right];
case '%': return [2, left % right];
case '|': return [2, left | right];
case '^': return [2, left ^ right];
case '&': return [2, left & right];
case 'in': return [2, left in right];
case 'instanceof': return [2, left instanceof right];
default: throw new SyntaxError("Unexpected token " + node.operator);
}
}
});
}
function AssignmentExpression$1(node, scope) {
var left, variable, win, value_1, value;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
left = node.left;
if (!(left.type === 'Identifier')) return [3, 2];
return [5, __values(Identifier$1(left, scope, { getVar: true, throwErr: false }))];
case 1:
variable = _b.sent();
if (!variable) {
win = scope.global().find('window').get();
variable = new Prop(win, left.name);
}
return [3, 7];
case 2:
if (!(left.type === 'MemberExpression')) return [3, 4];
return [5, __values(MemberExpression$1(left, scope, { getVar: true }))];
case 3:
variable = _b.sent();
return [3, 7];
case 4: return [5, __values(evaluate$1(node.right, scope))];
case 5:
value_1 = _b.sent();
return [5, __values(pattern(left, scope, { feed: value_1 }))];
case 6: return [2, _b.sent()];
case 7: return [5, __values(evaluate$1(node.right, scope))];
case 8:
value = _b.sent();
switch (node.operator) {
case '=':
variable.set(value);
return [2, variable.get()];
case '+=':
variable.set(variable.get() + value);
return [2, variable.get()];
case '-=':
variable.set(variable.get() - value);
return [2, variable.get()];
case '*=':
variable.set(variable.get() * value);
return [2, variable.get()];
case '/=':
variable.set(variable.get() / value);
return [2, variable.get()];
case '%=':
variable.set(variable.get() % value);
return [2, variable.get()];
case '**=':
variable.set(Math.pow(variable.get(), value));
return [2, variable.get()];
case '<<=':
variable.set(variable.get() << value);
return [2, variable.get()];
case '>>=':
variable.set(variable.get() >> value);
return [2, variable.get()];
case '>>>=':
variable.set(variable.get() >>> value);
return [2, variable.get()];
case '|=':
variable.set(variable.get() | value);
return [2, variable.get()];
case '^=':
variable.set(variable.get() ^ value);
return [2, variable.get()];
case '&=':
variable.set(variable.get() & value);
return [2, variable.get()];
case '??=':
variable.set((_a = variable.get()) !== null && _a !== void 0 ? _a : value);
return [2, variable.get()];
case '&&=':
variable.set(variable.get() && value);
return [2, variable.get()];
case '||=':
variable.set(variable.get() || value);
return [2, variable.get()];
default: throw new SyntaxError("Unexpected token " + node.operator);
}
}
});
}
function LogicalExpression$1(node, scope) {
var _a, _b, _c, _d;
var _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
_a = node.operator;
switch (_a) {
case '||': return [3, 1];
case '&&': return [3, 5];
case '??': return [3, 9];
}
return [3, 14];
case 1: return [5, __values(evaluate$1(node.left, scope))];
case 2:
_b = (_f.sent());
if (_b) return [3, 4];
return [5, __values(evaluate$1(node.right, scope))];
case 3:
_b = (_f.sent());
_f.label = 4;
case 4: return [2, _b];
case 5: return [5, __values(evaluate$1(node.left, scope))];
case 6:
_c = (_f.sent());
if (!_c) return [3, 8];
return [5, __values(evaluate$1(node.right, scope))];
case 7:
_c = (_f.sent());
_f.label = 8;
case 8: return [2, _c];
case 9: return [5, __values(evaluate$1(node.left, scope))];
case 10:
if (!((_e = (_f.sent())) !== null && _e !== void 0)) return [3, 11];
_d = _e;
return [3, 13];
case 11: return [5, __values(evaluate$1(node.right, scope))];
case 12:
_d = (_f.sent());
_f.label = 13;
case 13: return [2, _d];
case 14: throw new SyntaxError("Unexpected token " + node.operator);
}
});
}
function MemberExpression$1(node, scope, options) {
var _a, getObj, _b, getVar, object, key, priv, setter, thisObject, privateKey, getter, thisObject;
if (options === void 0) { options = {}; }
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = options.getObj, getObj = _a === void 0 ? false : _a, _b = options.getVar, getVar = _b === void 0 ? false : _b;
if (!(node.object.type === 'Super')) return [3, 2];
return [5, __values(Super$1(node.object, scope, { getProto: true }))];
case 1:
object = _c.sent();
return [3, 4];
case 2: return [5, __values(evaluate$1(node.object, scope))];
case 3:
object = _c.sent();
_c.label = 4;
case 4:
if (getObj)
return [2, object];
priv = false;
if (!node.computed) return [3, 6];
return [5, __values(evaluate$1(node.property, scope))];
case 5:
key = _c.sent();
return [3, 7];
case 6:
if (node.property.type === 'PrivateIdentifier') {
key = node.property.name;
priv = true;
}
else {
key = node.property.name;
}
_c.label = 7;
case 7:
if (priv) {
object = object[PRIVATE];
}
if (getVar) {
setter = getSetter(object, key);
if (node.object.type === 'Super' && setter) {
thisObject = scope.find('this').get();
privateKey = createSymbol(key);
define(thisObject, privateKey, { set: sett