sval 0.5.2 → 0.5.4

package/dist/sval.es6.js

@@ -1,45 +1,9 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('acorn')) :
   typeof define === 'function' && define.amd ? define(['acorn'], factory) :
-  (global = global || self, global.Sval = factory(global.acorn));
-}(this, (function (acorn) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sval = factory(global.acorn));
+})(this, (function (acorn) { 'use strict';
 
-  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 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; }
-  });
   var statement$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get ExpressionStatement () { return ExpressionStatement$1; },
@@ -49,6 +13,8 @@
     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; },
@@ -76,6 +42,44 @@
     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; }
+  });
 
   const freeze = Object.freeze;
   const define = Object.defineProperty;
@@ -395,6 +399,10 @@
               globalObj.crypto = crypto;
           }
           catch (err) { }
+          try {
+              globalObj.URL = URL;
+          }
+          catch (err) { }
           names = getOwnNames(globalObj);
       }
   }
@@ -443,8 +451,8 @@
 
   const AWAIT = { RES: undefined };
   const RETURN = { RES: undefined };
-  const CONTINUE = createSymbol('continue');
-  const BREAK = createSymbol('break');
+  const CONTINUE = { LABEL: undefined };
+  const BREAK = { LABEL: undefined };
   const SUPER = createSymbol('super');
   const SUPERCALL = createSymbol('supercall');
   const NOCTOR = createSymbol('noctor');
@@ -456,7 +464,7 @@
   const IMPORT = createSymbol('import');
   const EXPORTS = createSymbol('exports');
 
-  var version = "0.5.2";
+  var version = "0.5.4";
 
   class Var {
       constructor(kind, value) {
@@ -495,6 +503,7 @@
   class Scope {
       constructor(parent = null, isolated = false) {
           this.context = create(null);
+          this.withContext = create(null);
           this.parent = parent;
           this.isolated = isolated;
       }
@@ -505,18 +514,13 @@
           }
           return scope;
       }
-      clone() {
-          const cloneScope = new Scope(this.parent, this.isolated);
-          for (const name in this.context) {
-              const variable = this.context[name];
-              cloneScope[variable.kind](name, variable.get());
-          }
-          return cloneScope;
-      }
       find(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);
           }
@@ -583,9 +587,14 @@
               throw new SyntaxError(`Identifier '${name}' has already been declared`);
           }
       }
+      with(value) {
+          if (Object.keys(value)) {
+              this.withContext = value;
+          }
+      }
   }
 
-  function Identifier(node, scope, options = {}) {
+  function Identifier$1(node, scope, options = {}) {
       const { getVar = false, throwErr = true } = options;
       if (node.name === 'undefined') {
           return undefined;
@@ -613,21 +622,21 @@
       }
   }
 
-  var identifier = /*#__PURE__*/Object.freeze({
+  var identifier$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Identifier: Identifier
+    Identifier: Identifier$1
   });
 
-  function Literal(node, scope) {
+  function Literal$1(node, scope) {
       return node.value;
   }
 
-  var literal = /*#__PURE__*/Object.freeze({
+  var literal$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Literal: Literal
+    Literal: Literal$1
   });
 
-  function ThisExpression(node, scope) {
+  function ThisExpression$1(node, scope) {
       const superCall = scope.find(SUPERCALL);
       if (superCall && !superCall.get()) {
           throw new ReferenceError('Must call super constructor in derived class '
@@ -637,41 +646,41 @@
           return scope.find('this').get();
       }
   }
-  function ArrayExpression(node, scope) {
+  function ArrayExpression$1(node, scope) {
       let results = [];
       for (let i = 0; i < node.elements.length; i++) {
           const item = node.elements[i];
           if (item.type === 'SpreadElement') {
-              results = results.concat(SpreadElement(item, scope));
+              results = results.concat(SpreadElement$1(item, scope));
           }
           else {
-              results.push(evaluate(item, scope));
+              results.push(evaluate$1(item, scope));
           }
       }
       return results;
   }
-  function ObjectExpression(node, scope) {
+  function ObjectExpression$1(node, scope) {
       const object = {};
       for (let i = 0; i < node.properties.length; i++) {
           const property = node.properties[i];
           if (property.type === 'SpreadElement') {
-              assign(object, SpreadElement(property, scope));
+              assign(object, SpreadElement$1(property, scope));
           }
           else {
               let key;
               const propKey = property.key;
               if (property.computed) {
-                  key = evaluate(propKey, scope);
+                  key = evaluate$1(propKey, scope);
               }
               else {
                   if (propKey.type === 'Identifier') {
                       key = propKey.name;
                   }
                   else {
-                      key = '' + (Literal(propKey));
+                      key = '' + (Literal$1(propKey));
                   }
               }
-              const value = evaluate(property.value, scope);
+              const value = evaluate$1(property.value, scope);
               const propKind = property.kind;
               if (propKind === 'init') {
                   object[key] = value;
@@ -698,55 +707,55 @@
       }
       return object;
   }
-  function FunctionExpression(node, scope) {
+  function FunctionExpression$1(node, scope) {
       if (node.id && node.id.name) {
           const tmpScope = new Scope(scope);
-          const func = createFunc$1(node, tmpScope);
+          const func = createFunc(node, tmpScope);
           tmpScope.const(node.id.name, func);
           return func;
       }
       else {
-          return createFunc$1(node, scope);
+          return createFunc(node, scope);
       }
   }
-  function UnaryExpression(node, scope) {
+  function UnaryExpression$1(node, scope) {
       const arg = node.argument;
       switch (node.operator) {
-          case '+': return +(evaluate(arg, scope));
-          case '-': return -(evaluate(arg, scope));
-          case '!': return !(evaluate(arg, scope));
-          case '~': return ~(evaluate(arg, scope));
-          case 'void': return void (evaluate(arg, scope));
+          case '+': return +(evaluate$1(arg, scope));
+          case '-': return -(evaluate$1(arg, scope));
+          case '!': return !(evaluate$1(arg, scope));
+          case '~': return ~(evaluate$1(arg, scope));
+          case 'void': return void (evaluate$1(arg, scope));
           case 'typeof':
               if (arg.type === 'Identifier') {
-                  return typeof (Identifier(arg, scope, { throwErr: false }));
+                  return typeof (Identifier$1(arg, scope, { throwErr: false }));
               }
               else {
-                  return typeof (evaluate(arg, scope));
+                  return typeof (evaluate$1(arg, scope));
               }
           case 'delete':
               if (arg.type === 'MemberExpression') {
-                  const variable = MemberExpression(arg, scope, { getVar: true });
+                  const variable = MemberExpression$1(arg, scope, { getVar: true });
                   return variable.del();
               }
               else if (arg.type === 'Identifier') {
                   throw new SyntaxError('Delete of an unqualified identifier in strict mode');
               }
               else {
-                  evaluate(arg, scope);
+                  evaluate$1(arg, scope);
                   return true;
               }
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function UpdateExpression(node, scope) {
+  function UpdateExpression$1(node, scope) {
       const arg = node.argument;
       let variable;
       if (arg.type === 'Identifier') {
-          variable = Identifier(arg, scope, { getVar: true });
+          variable = Identifier$1(arg, scope, { getVar: true });
       }
       else if (arg.type === 'MemberExpression') {
-          variable = MemberExpression(arg, scope, { getVar: true });
+          variable = MemberExpression$1(arg, scope, { getVar: true });
       }
       else {
           throw new SyntaxError('Unexpected token');
@@ -764,17 +773,17 @@
           throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function BinaryExpression(node, scope) {
+  function BinaryExpression$1(node, scope) {
       let left;
       let right;
       if (node.left.type === 'PrivateIdentifier') {
           left = node.left.name;
-          right = evaluate(node.right, scope);
+          right = evaluate$1(node.right, scope);
           right = right[PRIVATE];
       }
       else {
-          left = evaluate(node.left, scope);
-          right = evaluate(node.right, scope);
+          left = evaluate$1(node.left, scope);
+          right = evaluate$1(node.right, scope);
       }
       switch (node.operator) {
           case '==': return left == right;
@@ -802,25 +811,25 @@
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function AssignmentExpression(node, scope) {
+  function AssignmentExpression$1(node, scope) {
       var _a;
       const left = node.left;
       let variable;
       if (left.type === 'Identifier') {
-          variable = Identifier(left, scope, { getVar: true, throwErr: false });
+          variable = Identifier$1(left, scope, { getVar: true, throwErr: false });
           if (!variable) {
               const win = scope.global().find('window').get();
               variable = new Prop(win, left.name);
           }
       }
       else if (left.type === 'MemberExpression') {
-          variable = MemberExpression(left, scope, { getVar: true });
+          variable = MemberExpression$1(left, scope, { getVar: true });
       }
       else {
-          const value = evaluate(node.right, scope);
-          return pattern$3(left, scope, { feed: value });
+          const value = evaluate$1(node.right, scope);
+          return pattern(left, scope, { feed: value });
       }
-      const value = evaluate(node.right, scope);
+      const value = evaluate$1(node.right, scope);
       switch (node.operator) {
           case '=':
               variable.set(value);
@@ -873,34 +882,34 @@
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function LogicalExpression(node, scope) {
+  function LogicalExpression$1(node, scope) {
       var _a;
       switch (node.operator) {
           case '||':
-              return (evaluate(node.left, scope)) || (evaluate(node.right, scope));
+              return (evaluate$1(node.left, scope)) || (evaluate$1(node.right, scope));
           case '&&':
-              return (evaluate(node.left, scope)) && (evaluate(node.right, scope));
+              return (evaluate$1(node.left, scope)) && (evaluate$1(node.right, scope));
           case '??':
-              return (_a = (evaluate(node.left, scope))) !== null && _a !== void 0 ? _a : (evaluate(node.right, scope));
+              return (_a = (evaluate$1(node.left, scope))) !== null && _a !== void 0 ? _a : (evaluate$1(node.right, scope));
           default:
               throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function MemberExpression(node, scope, options = {}) {
+  function MemberExpression$1(node, scope, options = {}) {
       const { getObj = false, getVar = false } = options;
       let object;
       if (node.object.type === 'Super') {
-          object = Super(node.object, scope, { getProto: true });
+          object = Super$1(node.object, scope, { getProto: true });
       }
       else {
-          object = evaluate(node.object, scope);
+          object = evaluate$1(node.object, scope);
       }
       if (getObj)
           return object;
       let key;
       let priv = false;
       if (node.computed) {
-          key = evaluate(node.property, scope);
+          key = evaluate$1(node.property, scope);
       }
       else if (node.property.type === 'PrivateIdentifier') {
           key = node.property.name;
@@ -941,23 +950,23 @@
           }
       }
   }
-  function ConditionalExpression(node, scope) {
-      return (evaluate(node.test, scope))
-          ? (evaluate(node.consequent, scope))
-          : (evaluate(node.alternate, scope));
+  function ConditionalExpression$1(node, scope) {
+      return (evaluate$1(node.test, scope))
+          ? (evaluate$1(node.consequent, scope))
+          : (evaluate$1(node.alternate, scope));
   }
-  function CallExpression(node, scope) {
+  function CallExpression$1(node, scope) {
       let func;
       let object;
       if (node.callee.type === 'MemberExpression') {
-          object = MemberExpression(node.callee, scope, { getObj: true });
+          object = MemberExpression$1(node.callee, scope, { getObj: true });
           if (node.callee.optional && object == null) {
               return undefined;
           }
           let key;
           let priv = false;
           if (node.callee.computed) {
-              key = evaluate(node.callee.property, scope);
+              key = evaluate$1(node.callee.property, scope);
           }
           else if (node.callee.property.type === 'PrivateIdentifier') {
               key = node.callee.property.name;
@@ -989,7 +998,7 @@
       }
       else {
           object = scope.find('this').get();
-          func = evaluate(node.callee, scope);
+          func = evaluate$1(node.callee, scope);
           if (node.optional && func == null) {
               return undefined;
           }
@@ -1018,10 +1027,10 @@
       for (let i = 0; i < node.arguments.length; i++) {
           const arg = node.arguments[i];
           if (arg.type === 'SpreadElement') {
-              args = args.concat(SpreadElement(arg, scope));
+              args = args.concat(SpreadElement$1(arg, scope));
           }
           else {
-              args.push(evaluate(arg, scope));
+              args.push(evaluate$1(arg, scope));
           }
       }
       if (node.callee.type === 'Super') {
@@ -1033,13 +1042,22 @@
               scope.find(SUPERCALL).set(true);
           }
       }
-      if (object && object[WINDOW] && func.toString().indexOf('[native code]') !== -1) {
-          return func.apply(object[WINDOW], args);
+      try {
+          return func.apply(object, args);
+      }
+      catch (err) {
+          if (err instanceof TypeError && err.message === 'Illegal invocation'
+              && func.toString().indexOf('[native code]') !== -1) {
+              const win = scope.global().find('window').get();
+              if (win && win[WINDOW]) {
+                  return func.apply(win[WINDOW], args);
+              }
+          }
+          throw err;
       }
-      return func.apply(object, args);
   }
-  function NewExpression(node, scope) {
-      const constructor = evaluate(node.callee, scope);
+  function NewExpression$1(node, scope) {
+      const constructor = evaluate$1(node.callee, scope);
       if (typeof constructor !== 'function') {
           let name;
           if (node.callee.type === 'Identifier') {
@@ -1062,15 +1080,15 @@
       for (let i = 0; i < node.arguments.length; i++) {
           const arg = node.arguments[i];
           if (arg.type === 'SpreadElement') {
-              args = args.concat(SpreadElement(arg, scope));
+              args = args.concat(SpreadElement$1(arg, scope));
           }
           else {
-              args.push(evaluate(arg, scope));
+              args.push(evaluate$1(arg, scope));
           }
       }
       return new constructor(...args);
   }
-  function MetaProperty(node, scope) {
+  function MetaProperty$1(node, scope) {
       if (node.meta.name === 'new' && node.property.name === 'target') {
           return scope.find(NEWTARGET).get();
       }
@@ -1078,33 +1096,33 @@
           return { url: '' };
       }
   }
-  function SequenceExpression(node, scope) {
+  function SequenceExpression$1(node, scope) {
       let result;
       for (let i = 0; i < node.expressions.length; i++) {
-          result = evaluate(node.expressions[i], scope);
+          result = evaluate$1(node.expressions[i], scope);
       }
       return result;
   }
-  function ArrowFunctionExpression(node, scope) {
-      return createFunc$1(node, scope);
+  function ArrowFunctionExpression$1(node, scope) {
+      return createFunc(node, scope);
   }
-  function TemplateLiteral(node, scope) {
+  function TemplateLiteral$1(node, scope) {
       const quasis = node.quasis.slice();
       const expressions = node.expressions.slice();
       let result = '';
       let temEl;
       let expr;
       while (temEl = quasis.shift()) {
-          result += TemplateElement(temEl);
+          result += TemplateElement$1(temEl);
           expr = expressions.shift();
           if (expr) {
-              result += evaluate(expr, scope);
+              result += evaluate$1(expr, scope);
           }
       }
       return result;
   }
-  function TaggedTemplateExpression(node, scope) {
-      const tagFunc = evaluate(node.tag, scope);
+  function TaggedTemplateExpression$1(node, scope) {
+      const tagFunc = evaluate$1(node.tag, scope);
       const quasis = node.quasi.quasis;
       const str = quasis.map(v => v.value.cooked);
       const raw = quasis.map(v => v.value.raw);
@@ -1115,40 +1133,40 @@
       const args = [];
       if (expressions) {
           for (let i = 0; i < expressions.length; i++) {
-              args.push(evaluate(expressions[i], scope));
+              args.push(evaluate$1(expressions[i], scope));
           }
       }
       return tagFunc(freeze(str), ...args);
   }
-  function TemplateElement(node, scope) {
+  function TemplateElement$1(node, scope) {
       return node.value.raw;
   }
-  function ClassExpression(node, scope) {
+  function ClassExpression$1(node, scope) {
       if (node.id && node.id.name) {
           const tmpScope = new Scope(scope);
-          const klass = createClass$1(node, tmpScope);
+          const klass = createClass(node, tmpScope);
           tmpScope.const(node.id.name, klass);
           return klass;
       }
       else {
-          return createClass$1(node, scope);
+          return createClass(node, scope);
       }
   }
-  function Super(node, scope, options = {}) {
+  function Super$1(node, scope, options = {}) {
       const { getProto = false } = options;
       const superClass = scope.find(SUPER).get();
       return getProto ? superClass.prototype : superClass;
   }
-  function SpreadElement(node, scope) {
-      const result = evaluate(node.argument, scope);
+  function SpreadElement$1(node, scope) {
+      const result = evaluate$1(node.argument, scope);
       return typeof result === 'string' ? [...result] : result;
   }
-  function ChainExpression(node, scope) {
-      return evaluate(node.expression, scope);
+  function ChainExpression$1(node, scope) {
+      return evaluate$1(node.expression, scope);
   }
-  function ImportExpression(node, scope) {
+  function ImportExpression$1(node, scope) {
       const globalScope = scope.global();
-      const source = evaluate(node.source, scope);
+      const source = evaluate$1(node.source, scope);
       const module = globalScope.find(IMPORT + source);
       let value;
       if (module) {
@@ -1168,35 +1186,35 @@
       return Promise.resolve(value);
   }
 
-  var expression = /*#__PURE__*/Object.freeze({
+  var expression$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ThisExpression: ThisExpression,
-    ArrayExpression: ArrayExpression,
-    ObjectExpression: ObjectExpression,
-    FunctionExpression: FunctionExpression,
-    UnaryExpression: UnaryExpression,
-    UpdateExpression: UpdateExpression,
-    BinaryExpression: BinaryExpression,
-    AssignmentExpression: AssignmentExpression,
-    LogicalExpression: LogicalExpression,
-    MemberExpression: MemberExpression,
-    ConditionalExpression: ConditionalExpression,
-    CallExpression: CallExpression,
-    NewExpression: NewExpression,
-    MetaProperty: MetaProperty,
-    SequenceExpression: SequenceExpression,
-    ArrowFunctionExpression: ArrowFunctionExpression,
-    TemplateLiteral: TemplateLiteral,
-    TaggedTemplateExpression: TaggedTemplateExpression,
-    TemplateElement: TemplateElement,
-    ClassExpression: ClassExpression,
-    Super: Super,
-    SpreadElement: SpreadElement,
-    ChainExpression: ChainExpression,
-    ImportExpression: ImportExpression
+    ThisExpression: ThisExpression$1,
+    ArrayExpression: ArrayExpression$1,
+    ObjectExpression: ObjectExpression$1,
+    FunctionExpression: FunctionExpression$1,
+    UnaryExpression: UnaryExpression$1,
+    UpdateExpression: UpdateExpression$1,
+    BinaryExpression: BinaryExpression$1,
+    AssignmentExpression: AssignmentExpression$1,
+    LogicalExpression: LogicalExpression$1,
+    MemberExpression: MemberExpression$1,
+    ConditionalExpression: ConditionalExpression$1,
+    CallExpression: CallExpression$1,
+    NewExpression: NewExpression$1,
+    MetaProperty: MetaProperty$1,
+    SequenceExpression: SequenceExpression$1,
+    ArrowFunctionExpression: ArrowFunctionExpression$1,
+    TemplateLiteral: TemplateLiteral$1,
+    TaggedTemplateExpression: TaggedTemplateExpression$1,
+    TemplateElement: TemplateElement$1,
+    ClassExpression: ClassExpression$1,
+    Super: Super$1,
+    SpreadElement: SpreadElement$1,
+    ChainExpression: ChainExpression$1,
+    ImportExpression: ImportExpression$1
   });
 
-  function ObjectPattern(node, scope, options = {}) {
+  function ObjectPattern$1(node, scope, options = {}) {
       const { kind = 'var', hoist = false, onlyBlock = false, feed = {} } = options;
       const fedKeys = [];
       for (let i = 0; i < node.properties.length; i++) {
@@ -1209,18 +1227,18 @@
                           scope[kind](value.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
                       }
                       else {
-                          pattern$3(value, scope, { kind, hoist, onlyBlock });
+                          pattern(value, scope, { kind, hoist, onlyBlock });
                       }
                   }
                   else {
-                      RestElement(property, scope, { kind, hoist, onlyBlock });
+                      RestElement$1(property, scope, { kind, hoist, onlyBlock });
                   }
               }
           }
           else if (property.type === 'Property') {
               let key;
               if (property.computed) {
-                  key = evaluate(property.key, scope);
+                  key = evaluate$1(property.key, scope);
               }
               else {
                   key = property.key.name;
@@ -1231,18 +1249,18 @@
                   scope[kind](value.name, feed[key]);
               }
               else {
-                  pattern$3(value, scope, { kind, feed: feed[key] });
+                  pattern(value, scope, { kind, feed: feed[key] });
               }
           }
           else {
               const rest = assign({}, feed);
               for (let i = 0; i < fedKeys.length; i++)
                   delete rest[fedKeys[i]];
-              RestElement(property, scope, { kind, feed: rest });
+              RestElement$1(property, scope, { kind, feed: rest });
           }
       }
   }
-  function ArrayPattern(node, scope, options = {}) {
+  function ArrayPattern$1(node, scope, options = {}) {
       const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
       const result = [];
       for (let i = 0; i < node.elements.length; i++) {
@@ -1255,7 +1273,7 @@
                       scope[kind](element.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
                   }
                   else {
-                      pattern$3(element, scope, { kind, hoist, onlyBlock });
+                      pattern(element, scope, { kind, hoist, onlyBlock });
                   }
               }
           }
@@ -1264,23 +1282,23 @@
                   scope[kind](element.name, feed[i]);
               }
               else {
-                  const variable = Identifier(element, scope, { getVar: true });
+                  const variable = Identifier$1(element, scope, { getVar: true });
                   variable.set(feed[i]);
                   result.push(variable.get());
               }
           }
           else if (element.type === 'RestElement') {
-              RestElement(element, scope, { kind, feed: feed.slice(i) });
+              RestElement$1(element, scope, { kind, feed: feed.slice(i) });
           }
           else {
-              pattern$3(element, scope, { kind, feed: feed[i] });
+              pattern(element, scope, { kind, feed: feed[i] });
           }
       }
       if (result.length) {
           return result;
       }
   }
-  function RestElement(node, scope, options = {}) {
+  function RestElement$1(node, scope, options = {}) {
       const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
       const arg = node.argument;
       if (hoist) {
@@ -1289,7 +1307,7 @@
                   scope[kind](arg.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  pattern$3(arg, scope, { kind, hoist, onlyBlock });
+                  pattern(arg, scope, { kind, hoist, onlyBlock });
               }
           }
       }
@@ -1298,16 +1316,16 @@
               scope[kind](arg.name, feed);
           }
           else {
-              const variable = Identifier(arg, scope, { getVar: true });
+              const variable = Identifier$1(arg, scope, { getVar: true });
               variable.set(feed);
           }
       }
       else {
-          pattern$3(arg, scope, { kind, feed });
+          pattern(arg, scope, { kind, feed });
       }
   }
-  function AssignmentPattern(node, scope, options = {}) {
-      const { kind = 'var', hoist = false, onlyBlock = false, feed = evaluate(node.right, scope) } = options;
+  function AssignmentPattern$1(node, scope, options = {}) {
+      const { kind = 'var', hoist = false, onlyBlock = false, feed = evaluate$1(node.right, scope) } = options;
       const left = node.left;
       if (hoist) {
           if (onlyBlock || kind === 'var') {
@@ -1315,7 +1333,7 @@
                   scope[kind](left.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  pattern$3(left, scope, { kind, hoist, onlyBlock });
+                  pattern(left, scope, { kind, hoist, onlyBlock });
               }
           }
       }
@@ -1323,21 +1341,21 @@
           scope[kind](left.name, feed);
       }
       else {
-          pattern$3(left, scope, { kind, feed });
+          pattern(left, scope, { kind, feed });
       }
   }
 
-  var pattern = /*#__PURE__*/Object.freeze({
+  var pattern$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ObjectPattern: ObjectPattern,
-    ArrayPattern: ArrayPattern,
-    RestElement: RestElement,
-    AssignmentPattern: AssignmentPattern
+    ObjectPattern: ObjectPattern$1,
+    ArrayPattern: ArrayPattern$1,
+    RestElement: RestElement$1,
+    AssignmentPattern: AssignmentPattern$1
   });
 
   function Program(program, scope) {
       for (let i = 0; i < program.body.length; i++) {
-          evaluate(program.body[i], scope);
+          evaluate$1(program.body[i], scope);
       }
   }
 
@@ -1346,14 +1364,14 @@
     Program: Program
   });
 
-  let evaluateOps;
-  function evaluate(node, scope) {
+  let evaluateOps$1;
+  function evaluate$1(node, scope) {
       if (!node)
           return;
-      if (!evaluateOps) {
-          evaluateOps = assign({}, declaration, expression, identifier, statement, literal, pattern, program);
+      if (!evaluateOps$1) {
+          evaluateOps$1 = assign({}, declaration$1, expression$1, identifier$1, statement$1, literal$1, pattern$3, program);
       }
-      const handler = evaluateOps[node.type];
+      const handler = evaluateOps$1[node.type];
       if (handler) {
           return handler(node, scope);
       }
@@ -1362,59 +1380,126 @@
       }
   }
 
-  function ExpressionStatement(node, scope) {
-      evaluate(node.expression, scope);
+  function ExpressionStatement$1(node, scope) {
+      evaluate$1(node.expression, scope);
   }
-  function BlockStatement(block, scope, options = {}) {
+  function BlockStatement$1(block, scope, options = {}) {
       const { invasived = false, hoisted = false, } = options;
       const subScope = invasived ? scope : new Scope(scope);
       if (!hoisted) {
-          hoist$1(block, subScope, { onlyBlock: true });
+          hoist(block, subScope, { onlyBlock: true });
       }
       for (let i = 0; i < block.body.length; i++) {
-          const result = evaluate(block.body[i], subScope);
-          if (result === BREAK || result === CONTINUE || result === RETURN) {
+          const result = evaluate$1(block.body[i], subScope);
+          if (result === BREAK) {
+              if (result.LABEL && result.LABEL === options.label) {
+                  break;
+              }
+              return result;
+          }
+          if (result === CONTINUE || result === RETURN) {
               return result;
           }
       }
   }
-  function EmptyStatement() {
+  function EmptyStatement$1() {
   }
-  function DebuggerStatement() {
+  function DebuggerStatement$1() {
       debugger;
   }
-  function ReturnStatement(node, scope) {
-      RETURN.RES = node.argument ? (evaluate(node.argument, scope)) : undefined;
+  function ReturnStatement$1(node, scope) {
+      RETURN.RES = node.argument ? (evaluate$1(node.argument, scope)) : undefined;
       return RETURN;
   }
-  function BreakStatement() {
+  function BreakStatement$1(node) {
+      var _a;
+      BREAK.LABEL = (_a = node.label) === null || _a === void 0 ? void 0 : _a.name;
       return BREAK;
   }
-  function ContinueStatement() {
+  function ContinueStatement$1(node) {
+      var _a;
+      CONTINUE.LABEL = (_a = node.label) === null || _a === void 0 ? void 0 : _a.name;
       return CONTINUE;
   }
-  function IfStatement(node, scope) {
-      if (evaluate(node.test, scope)) {
-          return evaluate(node.consequent, scope);
+  function LabeledStatement$1(node, scope) {
+      const label = node.label.name;
+      if (node.body.type === 'WhileStatement') {
+          return WhileStatement$1(node.body, scope, { label });
       }
-      else {
-          return evaluate(node.alternate, scope);
+      if (node.body.type === 'DoWhileStatement') {
+          return DoWhileStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForStatement') {
+          return ForStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForInStatement') {
+          return ForInStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForOfStatement') {
+          return ForOfStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'BlockStatement') {
+          return BlockStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'WithStatement') {
+          return WithStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'IfStatement') {
+          return IfStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'SwitchStatement') {
+          return SwitchStatement$1(node.body, scope, { label });
+      }
+      if (node.body.type === 'TryStatement') {
+          return TryStatement$1(node.body, scope, { label });
+      }
+      throw new SyntaxError(`${node.body.type} cannot be labeled`);
+  }
+  function WithStatement$1(node, scope, options = {}) {
+      const withScope = new Scope(scope);
+      withScope.with(evaluate$1(node.object, scope));
+      const result = evaluate$1(node.body, withScope);
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
+          }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
+      }
+  }
+  function IfStatement$1(node, scope, options = {}) {
+      const result = evaluate$1(node.test, scope)
+          ? evaluate$1(node.consequent, scope)
+          : evaluate$1(node.alternate, scope);
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
+          }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
       }
   }
-  function SwitchStatement(node, scope) {
-      const discriminant = evaluate(node.discriminant, scope);
+  function SwitchStatement$1(node, scope, options = {}) {
+      const discriminant = evaluate$1(node.discriminant, scope);
       let matched = false;
       for (let i = 0; i < node.cases.length; i++) {
           const eachCase = node.cases[i];
           if (!matched
               && (!eachCase.test
-                  || (evaluate(eachCase.test, scope)) === discriminant)) {
+                  || (evaluate$1(eachCase.test, scope)) === discriminant)) {
               matched = true;
           }
           if (matched) {
-              const result = SwitchCase(eachCase, scope);
+              const result = SwitchCase$1(eachCase, scope);
               if (result === BREAK) {
-                  break;
+                  if (result.LABEL === options.label) {
+                      break;
+                  }
+                  return result;
               }
               if (result === CONTINUE || result === RETURN) {
                   return result;
@@ -1422,20 +1507,21 @@
           }
       }
   }
-  function SwitchCase(node, scope) {
+  function SwitchCase$1(node, scope) {
       for (let i = 0; i < node.consequent.length; i++) {
-          const result = evaluate(node.consequent[i], scope);
+          const result = evaluate$1(node.consequent[i], scope);
           if (result === BREAK || result === CONTINUE || result === RETURN) {
               return result;
           }
       }
   }
-  function ThrowStatement(node, scope) {
-      throw evaluate(node.argument, scope);
+  function ThrowStatement$1(node, scope) {
+      throw evaluate$1(node.argument, scope);
   }
-  function TryStatement(node, scope) {
+  function TryStatement$1(node, scope, options = {}) {
+      let result;
       try {
-          return BlockStatement(node.block, scope);
+          result = BlockStatement$1(node.block, scope);
       }
       catch (err) {
           if (node.handler) {
@@ -1447,10 +1533,10 @@
                       subScope.var(name, err);
                   }
                   else {
-                      pattern$3(param, scope, { feed: err });
+                      pattern(param, scope, { feed: err });
                   }
               }
-              return CatchClause(node.handler, subScope);
+              result = CatchClause$1(node.handler, subScope);
           }
           else {
               throw err;
@@ -1458,89 +1544,125 @@
       }
       finally {
           if (node.finalizer) {
-              const result = BlockStatement(node.finalizer, scope);
-              if (result === BREAK || result === CONTINUE || result === RETURN) {
-                  return result;
-              }
+              result = BlockStatement$1(node.finalizer, scope);
           }
       }
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
+          }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
+      }
   }
-  function CatchClause(node, scope) {
-      return BlockStatement(node.body, scope, { invasived: true });
+  function CatchClause$1(node, scope) {
+      return BlockStatement$1(node.body, scope, { invasived: true });
   }
-  function WhileStatement(node, scope) {
-      while (evaluate(node.test, scope)) {
-          const result = evaluate(node.body, scope);
+  function WhileStatement$1(node, scope, options = {}) {
+      while (evaluate$1(node.test, scope)) {
+          const result = evaluate$1(node.body, scope);
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function DoWhileStatement(node, scope) {
+  function DoWhileStatement$1(node, scope, options = {}) {
       do {
-          const result = evaluate(node.body, scope);
+          const result = evaluate$1(node.body, scope);
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
-      } while (evaluate(node.test, scope));
+      } while (evaluate$1(node.test, scope));
   }
-  function ForStatement(node, scope) {
+  function ForStatement$1(node, scope, options = {}) {
       const forScope = new Scope(scope);
-      for (evaluate(node.init, forScope); node.test ? (evaluate(node.test, forScope)) : true; evaluate(node.update, forScope)) {
+      for (evaluate$1(node.init, forScope); node.test ? (evaluate$1(node.test, forScope)) : true; evaluate$1(node.update, forScope)) {
           const subScope = new Scope(forScope);
           let result;
           if (node.body.type === 'BlockStatement') {
-              result = BlockStatement(node.body, subScope, { invasived: true });
+              result = BlockStatement$1(node.body, subScope, { invasived: true });
           }
           else {
-              result = evaluate(node.body, subScope);
+              result = evaluate$1(node.body, subScope);
           }
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function ForInStatement(node, scope) {
-      for (const value in evaluate(node.right, scope)) {
-          const result = ForXHandler$1(node, scope, { value });
+  function ForInStatement$1(node, scope, options = {}) {
+      for (const value in evaluate$1(node.right, scope)) {
+          const result = ForXHandler(node, scope, { value });
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function ForOfStatement(node, scope) {
-      const right = evaluate(node.right, scope);
+  function ForOfStatement$1(node, scope, options = {}) {
+      const right = evaluate$1(node.right, scope);
       for (const value of right) {
-          const result = ForXHandler$1(node, scope, { value });
+          const result = ForXHandler(node, scope, { value });
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
@@ -1548,15 +1670,15 @@
       }
   }
 
-  function FunctionDeclaration(node, scope) {
-      scope.func(node.id.name, createFunc$1(node, scope));
+  function FunctionDeclaration$1(node, scope) {
+      scope.func(node.id.name, createFunc(node, scope));
   }
-  function VariableDeclaration(node, scope, options = {}) {
+  function VariableDeclaration$1(node, scope, options = {}) {
       for (let i = 0; i < node.declarations.length; i++) {
-          VariableDeclarator(node.declarations[i], scope, assign({ kind: node.kind }, options));
+          VariableDeclarator$1(node.declarations[i], scope, assign({ kind: node.kind }, options));
       }
   }
-  function VariableDeclarator(node, scope, options = {}) {
+  function VariableDeclarator$1(node, scope, options = {}) {
       const { kind = 'var', hoist = false, onlyBlock = false, feed } = options;
       if (hoist) {
           if (onlyBlock || kind === 'var') {
@@ -1564,13 +1686,13 @@
                   scope[kind](node.id.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  pattern$3(node.id, scope, { kind, hoist, onlyBlock });
+                  pattern(node.id, scope, { kind, hoist, onlyBlock });
               }
           }
       }
       else {
           const hasFeed = 'feed' in options;
-          const value = hasFeed ? feed : evaluate(node.init, scope);
+          const value = hasFeed ? feed : evaluate$1(node.init, scope);
           if (node.id.type === 'Identifier') {
               const name = node.id.name;
               if (kind === 'var' && !node.init && !hasFeed) {
@@ -1590,34 +1712,34 @@
               }
           }
           else {
-              pattern$3(node.id, scope, { kind, feed: value });
+              pattern(node.id, scope, { kind, feed: value });
           }
       }
   }
-  function ClassDeclaration(node, scope) {
-      scope.func(node.id.name, createClass$1(node, scope));
+  function ClassDeclaration$1(node, scope) {
+      scope.func(node.id.name, createClass(node, scope));
   }
-  function ClassBody(node, scope, options = {}) {
+  function ClassBody$1(node, scope, options = {}) {
       const { klass, superClass } = options;
       for (let i = 0; i < node.body.length; i++) {
           const def = node.body[i];
           if (def.type === 'MethodDefinition') {
-              MethodDefinition(def, scope, { klass, superClass });
+              MethodDefinition$1(def, scope, { klass, superClass });
           }
           else if (def.type === 'PropertyDefinition' && def.static) {
-              PropertyDefinition(def, scope, { klass, superClass });
+              PropertyDefinition$1(def, scope, { klass, superClass });
           }
           else if (def.type === 'StaticBlock') {
-              StaticBlock(def, scope, { klass, superClass });
+              StaticBlock$1(def, scope, { klass, superClass });
           }
       }
   }
-  function MethodDefinition(node, scope, options = {}) {
+  function MethodDefinition$1(node, scope, options = {}) {
       const { klass, superClass } = options;
       let key;
       let priv = false;
       if (node.computed) {
-          key = evaluate(node.key, scope);
+          key = evaluate$1(node.key, scope);
       }
       else if (node.key.type === 'Identifier') {
           key = node.key.name;
@@ -1636,7 +1758,7 @@
           }
           obj = obj[PRIVATE];
       }
-      const value = createFunc$1(node.value, scope, { superClass });
+      const value = createFunc(node.value, scope, { superClass });
       switch (node.kind) {
           case 'constructor':
               break;
@@ -1669,12 +1791,12 @@
               throw new SyntaxError('Unexpected token');
       }
   }
-  function PropertyDefinition(node, scope, options = {}) {
+  function PropertyDefinition$1(node, scope, options = {}) {
       const { klass, superClass } = options;
       let key;
       let priv = false;
       if (node.computed) {
-          key = evaluate(node.key, scope);
+          key = evaluate$1(node.key, scope);
       }
       else if (node.key.type === 'Identifier') {
           key = node.key.name;
@@ -1696,19 +1818,19 @@
           obj = obj[PRIVATE];
       }
       if (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression') {
-          obj[key] = createFunc$1(node.value, subScope, { superClass });
+          obj[key] = createFunc(node.value, subScope, { superClass });
       }
       else {
-          obj[key] = evaluate(node.value, subScope);
+          obj[key] = evaluate$1(node.value, subScope);
       }
   }
-  function StaticBlock(node, scope, options = {}) {
+  function StaticBlock$1(node, scope, options = {}) {
       const { klass } = options;
       const subScope = new Scope(scope, true);
       subScope.const('this', klass);
-      return BlockStatement(node, subScope, { invasived: true });
+      return BlockStatement$1(node, subScope, { invasived: true });
   }
-  function ImportDeclaration(node, scope) {
+  function ImportDeclaration$1(node, scope) {
       const globalScope = scope.global();
       const module = globalScope.find(IMPORT + node.source.value);
       let value;
@@ -1745,19 +1867,19 @@
           scope.var(spec.local.name, name === '*' ? assign({}, value) : value[name]);
       }
   }
-  function ExportDefaultDeclaration(node, scope) {
+  function ExportDefaultDeclaration$1(node, scope) {
       const globalScope = scope.global();
       let value;
       if (node.declaration.type === 'FunctionDeclaration') {
-          value = createFunc$1(node.declaration, scope);
+          value = createFunc(node.declaration, scope);
           scope.func(node.declaration.id.name, value);
       }
       else if (node.declaration.type === 'ClassDeclaration') {
-          value = createClass$1(node.declaration, scope);
+          value = createClass(node.declaration, scope);
           scope.func(node.declaration.id.name, value);
       }
       else {
-          value = evaluate(node.declaration, scope);
+          value = evaluate$1(node.declaration, scope);
       }
       const variable = globalScope.find(EXPORTS);
       if (variable) {
@@ -1767,11 +1889,11 @@
           }
       }
   }
-  function ExportNamedDeclaration(node, scope) {
+  function ExportNamedDeclaration$1(node, scope) {
       const globalScope = scope.global();
       if (node.declaration) {
           if (node.declaration.type === 'FunctionDeclaration') {
-              const value = createFunc$1(node.declaration, scope);
+              const value = createFunc(node.declaration, scope);
               scope.func(node.declaration.id.name, value);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
@@ -1782,7 +1904,7 @@
               }
           }
           else if (node.declaration.type === 'ClassDeclaration') {
-              const value = createClass$1(node.declaration, scope);
+              const value = createClass(node.declaration, scope);
               scope.func(node.declaration.id.name, value);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
@@ -1793,7 +1915,7 @@
               }
           }
           else if (node.declaration.type === 'VariableDeclaration') {
-              VariableDeclaration(node.declaration, scope);
+              VariableDeclaration$1(node.declaration, scope);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
                   const exports = variable.get();
@@ -1828,7 +1950,7 @@
           }
       }
   }
-  function ExportAllDeclaration(node, scope) {
+  function ExportAllDeclaration$1(node, scope) {
       const globalScope = scope.global();
       const module = globalScope.find(IMPORT + node.source.value);
       let value;
@@ -1855,7 +1977,7 @@
       }
   }
 
-  function* Identifier$1(node, scope, options = {}) {
+  function* Identifier(node, scope, options = {}) {
       const { getVar = false, throwErr = true } = options;
       if (node.name === 'undefined') {
           return undefined;
@@ -1883,21 +2005,21 @@
       }
   }
 
-  var identifier$1 = /*#__PURE__*/Object.freeze({
+  var identifier = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Identifier: Identifier$1
+    Identifier: Identifier
   });
 
-  function* Literal$1(node, scope) {
+  function* Literal(node, scope) {
       return node.value;
   }
 
-  var literal$1 = /*#__PURE__*/Object.freeze({
+  var literal = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Literal: Literal$1
+    Literal: Literal
   });
 
-  function* ThisExpression$1(node, scope) {
+  function* ThisExpression(node, scope) {
       const superCall = scope.find(SUPERCALL);
       if (superCall && !superCall.get()) {
           throw new ReferenceError('Must call super constructor in derived class '
@@ -1907,41 +2029,41 @@
           return scope.find('this').get();
       }
   }
-  function* ArrayExpression$1(node, scope) {
+  function* ArrayExpression(node, scope) {
       let results = [];
       for (let i = 0; i < node.elements.length; i++) {
           const item = node.elements[i];
           if (item.type === 'SpreadElement') {
-              results = results.concat(yield* SpreadElement$1(item, scope));
+              results = results.concat(yield* SpreadElement(item, scope));
           }
           else {
-              results.push(yield* evaluate$1(item, scope));
+              results.push(yield* evaluate(item, scope));
           }
       }
       return results;
   }
-  function* ObjectExpression$1(node, scope) {
+  function* ObjectExpression(node, scope) {
       const object = {};
       for (let i = 0; i < node.properties.length; i++) {
           const property = node.properties[i];
           if (property.type === 'SpreadElement') {
-              assign(object, yield* SpreadElement$1(property, scope));
+              assign(object, yield* SpreadElement(property, scope));
           }
           else {
               let key;
               const propKey = property.key;
               if (property.computed) {
-                  key = yield* evaluate$1(propKey, scope);
+                  key = yield* evaluate(propKey, scope);
               }
               else {
                   if (propKey.type === 'Identifier') {
                       key = propKey.name;
                   }
                   else {
-                      key = '' + (yield* Literal$1(propKey));
+                      key = '' + (yield* Literal(propKey));
                   }
               }
-              const value = yield* evaluate$1(property.value, scope);
+              const value = yield* evaluate(property.value, scope);
               const propKind = property.kind;
               if (propKind === 'init') {
                   object[key] = value;
@@ -1968,55 +2090,55 @@
       }
       return object;
   }
-  function* FunctionExpression$1(node, scope) {
+  function* FunctionExpression(node, scope) {
       if (node.id && node.id.name) {
           const tmpScope = new Scope(scope);
-          const func = createFunc(node, tmpScope);
+          const func = createFunc$1(node, tmpScope);
           tmpScope.const(node.id.name, func);
           return func;
       }
       else {
-          return createFunc(node, scope);
+          return createFunc$1(node, scope);
       }
   }
-  function* UnaryExpression$1(node, scope) {
+  function* UnaryExpression(node, scope) {
       const arg = node.argument;
       switch (node.operator) {
-          case '+': return +(yield* evaluate$1(arg, scope));
-          case '-': return -(yield* evaluate$1(arg, scope));
-          case '!': return !(yield* evaluate$1(arg, scope));
-          case '~': return ~(yield* evaluate$1(arg, scope));
-          case 'void': return void (yield* evaluate$1(arg, scope));
+          case '+': return +(yield* evaluate(arg, scope));
+          case '-': return -(yield* evaluate(arg, scope));
+          case '!': return !(yield* evaluate(arg, scope));
+          case '~': return ~(yield* evaluate(arg, scope));
+          case 'void': return void (yield* evaluate(arg, scope));
           case 'typeof':
               if (arg.type === 'Identifier') {
-                  return typeof (yield* Identifier$1(arg, scope, { throwErr: false }));
+                  return typeof (yield* Identifier(arg, scope, { throwErr: false }));
               }
               else {
-                  return typeof (yield* evaluate$1(arg, scope));
+                  return typeof (yield* evaluate(arg, scope));
               }
           case 'delete':
               if (arg.type === 'MemberExpression') {
-                  const variable = yield* MemberExpression$1(arg, scope, { getVar: true });
+                  const variable = yield* MemberExpression(arg, scope, { getVar: true });
                   return variable.del();
               }
               else if (arg.type === 'Identifier') {
                   throw new SyntaxError('Delete of an unqualified identifier in strict mode');
               }
               else {
-                  yield* evaluate$1(arg, scope);
+                  yield* evaluate(arg, scope);
                   return true;
               }
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function* UpdateExpression$1(node, scope) {
+  function* UpdateExpression(node, scope) {
       const arg = node.argument;
       let variable;
       if (arg.type === 'Identifier') {
-          variable = yield* Identifier$1(arg, scope, { getVar: true });
+          variable = yield* Identifier(arg, scope, { getVar: true });
       }
       else if (arg.type === 'MemberExpression') {
-          variable = yield* MemberExpression$1(arg, scope, { getVar: true });
+          variable = yield* MemberExpression(arg, scope, { getVar: true });
       }
       else {
           throw new SyntaxError('Unexpected token');
@@ -2034,17 +2156,17 @@
           throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function* BinaryExpression$1(node, scope) {
+  function* BinaryExpression(node, scope) {
       let left;
       let right;
       if (node.left.type === 'PrivateIdentifier') {
           left = node.left.name;
-          right = yield* evaluate$1(node.right, scope);
+          right = yield* evaluate(node.right, scope);
           right = right[PRIVATE];
       }
       else {
-          left = yield* evaluate$1(node.left, scope);
-          right = yield* evaluate$1(node.right, scope);
+          left = yield* evaluate(node.left, scope);
+          right = yield* evaluate(node.right, scope);
       }
       switch (node.operator) {
           case '==': return left == right;
@@ -2072,25 +2194,25 @@
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function* AssignmentExpression$1(node, scope) {
+  function* AssignmentExpression(node, scope) {
       var _a;
       const left = node.left;
       let variable;
       if (left.type === 'Identifier') {
-          variable = yield* Identifier$1(left, scope, { getVar: true, throwErr: false });
+          variable = yield* Identifier(left, scope, { getVar: true, throwErr: false });
           if (!variable) {
               const win = scope.global().find('window').get();
               variable = new Prop(win, left.name);
           }
       }
       else if (left.type === 'MemberExpression') {
-          variable = yield* MemberExpression$1(left, scope, { getVar: true });
+          variable = yield* MemberExpression(left, scope, { getVar: true });
       }
       else {
-          const value = yield* evaluate$1(node.right, scope);
-          return yield* pattern$2(left, scope, { feed: value });
+          const value = yield* evaluate(node.right, scope);
+          return yield* pattern$1(left, scope, { feed: value });
       }
-      const value = yield* evaluate$1(node.right, scope);
+      const value = yield* evaluate(node.right, scope);
       switch (node.operator) {
           case '=':
               variable.set(value);
@@ -2143,34 +2265,34 @@
           default: throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function* LogicalExpression$1(node, scope) {
+  function* LogicalExpression(node, scope) {
       var _a;
       switch (node.operator) {
           case '||':
-              return (yield* evaluate$1(node.left, scope)) || (yield* evaluate$1(node.right, scope));
+              return (yield* evaluate(node.left, scope)) || (yield* evaluate(node.right, scope));
           case '&&':
-              return (yield* evaluate$1(node.left, scope)) && (yield* evaluate$1(node.right, scope));
+              return (yield* evaluate(node.left, scope)) && (yield* evaluate(node.right, scope));
           case '??':
-              return (_a = (yield* evaluate$1(node.left, scope))) !== null && _a !== void 0 ? _a : (yield* evaluate$1(node.right, scope));
+              return (_a = (yield* evaluate(node.left, scope))) !== null && _a !== void 0 ? _a : (yield* evaluate(node.right, scope));
           default:
               throw new SyntaxError(`Unexpected token ${node.operator}`);
       }
   }
-  function* MemberExpression$1(node, scope, options = {}) {
+  function* MemberExpression(node, scope, options = {}) {
       const { getObj = false, getVar = false } = options;
       let object;
       if (node.object.type === 'Super') {
-          object = yield* Super$1(node.object, scope, { getProto: true });
+          object = yield* Super(node.object, scope, { getProto: true });
       }
       else {
-          object = yield* evaluate$1(node.object, scope);
+          object = yield* evaluate(node.object, scope);
       }
       if (getObj)
           return object;
       let key;
       let priv = false;
       if (node.computed) {
-          key = yield* evaluate$1(node.property, scope);
+          key = yield* evaluate(node.property, scope);
       }
       else if (node.property.type === 'PrivateIdentifier') {
           key = node.property.name;
@@ -2211,23 +2333,23 @@
           }
       }
   }
-  function* ConditionalExpression$1(node, scope) {
-      return (yield* evaluate$1(node.test, scope))
-          ? (yield* evaluate$1(node.consequent, scope))
-          : (yield* evaluate$1(node.alternate, scope));
+  function* ConditionalExpression(node, scope) {
+      return (yield* evaluate(node.test, scope))
+          ? (yield* evaluate(node.consequent, scope))
+          : (yield* evaluate(node.alternate, scope));
   }
-  function* CallExpression$1(node, scope) {
+  function* CallExpression(node, scope) {
       let func;
       let object;
       if (node.callee.type === 'MemberExpression') {
-          object = yield* MemberExpression$1(node.callee, scope, { getObj: true });
+          object = yield* MemberExpression(node.callee, scope, { getObj: true });
           if (node.callee.optional && object == null) {
               return undefined;
           }
           let key;
           let priv = false;
           if (node.callee.computed) {
-              key = yield* evaluate$1(node.callee.property, scope);
+              key = yield* evaluate(node.callee.property, scope);
           }
           else if (node.callee.property.type === 'PrivateIdentifier') {
               key = node.callee.property.name;
@@ -2259,7 +2381,7 @@
       }
       else {
           object = scope.find('this').get();
-          func = yield* evaluate$1(node.callee, scope);
+          func = yield* evaluate(node.callee, scope);
           if (node.optional && func == null) {
               return undefined;
           }
@@ -2288,10 +2410,10 @@
       for (let i = 0; i < node.arguments.length; i++) {
           const arg = node.arguments[i];
           if (arg.type === 'SpreadElement') {
-              args = args.concat(yield* SpreadElement$1(arg, scope));
+              args = args.concat(yield* SpreadElement(arg, scope));
           }
           else {
-              args.push(yield* evaluate$1(arg, scope));
+              args.push(yield* evaluate(arg, scope));
           }
       }
       if (node.callee.type === 'Super') {
@@ -2303,13 +2425,22 @@
               scope.find(SUPERCALL).set(true);
           }
       }
-      if (object && object[WINDOW] && func.toString().indexOf('[native code]') !== -1) {
-          return func.apply(object[WINDOW], args);
+      try {
+          return func.apply(object, args);
+      }
+      catch (err) {
+          if (err instanceof TypeError && err.message === 'Illegal invocation'
+              && func.toString().indexOf('[native code]') !== -1) {
+              const win = scope.global().find('window').get();
+              if (win && win[WINDOW]) {
+                  return func.apply(win[WINDOW], args);
+              }
+          }
+          throw err;
       }
-      return func.apply(object, args);
   }
-  function* NewExpression$1(node, scope) {
-      const constructor = yield* evaluate$1(node.callee, scope);
+  function* NewExpression(node, scope) {
+      const constructor = yield* evaluate(node.callee, scope);
       if (typeof constructor !== 'function') {
           let name;
           if (node.callee.type === 'Identifier') {
@@ -2332,15 +2463,15 @@
       for (let i = 0; i < node.arguments.length; i++) {
           const arg = node.arguments[i];
           if (arg.type === 'SpreadElement') {
-              args = args.concat(yield* SpreadElement$1(arg, scope));
+              args = args.concat(yield* SpreadElement(arg, scope));
           }
           else {
-              args.push(yield* evaluate$1(arg, scope));
+              args.push(yield* evaluate(arg, scope));
           }
       }
       return new constructor(...args);
   }
-  function* MetaProperty$1(node, scope) {
+  function* MetaProperty(node, scope) {
       if (node.meta.name === 'new' && node.property.name === 'target') {
           return scope.find(NEWTARGET).get();
       }
@@ -2348,33 +2479,33 @@
           return { url: '' };
       }
   }
-  function* SequenceExpression$1(node, scope) {
+  function* SequenceExpression(node, scope) {
       let result;
       for (let i = 0; i < node.expressions.length; i++) {
-          result = yield* evaluate$1(node.expressions[i], scope);
+          result = yield* evaluate(node.expressions[i], scope);
       }
       return result;
   }
-  function* ArrowFunctionExpression$1(node, scope) {
-      return createFunc(node, scope);
+  function* ArrowFunctionExpression(node, scope) {
+      return createFunc$1(node, scope);
   }
-  function* TemplateLiteral$1(node, scope) {
+  function* TemplateLiteral(node, scope) {
       const quasis = node.quasis.slice();
       const expressions = node.expressions.slice();
       let result = '';
       let temEl;
       let expr;
       while (temEl = quasis.shift()) {
-          result += yield* TemplateElement$1(temEl);
+          result += yield* TemplateElement(temEl);
           expr = expressions.shift();
           if (expr) {
-              result += yield* evaluate$1(expr, scope);
+              result += yield* evaluate(expr, scope);
           }
       }
       return result;
   }
-  function* TaggedTemplateExpression$1(node, scope) {
-      const tagFunc = yield* evaluate$1(node.tag, scope);
+  function* TaggedTemplateExpression(node, scope) {
+      const tagFunc = yield* evaluate(node.tag, scope);
       const quasis = node.quasi.quasis;
       const str = quasis.map(v => v.value.cooked);
       const raw = quasis.map(v => v.value.raw);
@@ -2385,40 +2516,40 @@
       const args = [];
       if (expressions) {
           for (let i = 0; i < expressions.length; i++) {
-              args.push(yield* evaluate$1(expressions[i], scope));
+              args.push(yield* evaluate(expressions[i], scope));
           }
       }
       return tagFunc(freeze(str), ...args);
   }
-  function* TemplateElement$1(node, scope) {
+  function* TemplateElement(node, scope) {
       return node.value.raw;
   }
-  function* ClassExpression$1(node, scope) {
+  function* ClassExpression(node, scope) {
       if (node.id && node.id.name) {
           const tmpScope = new Scope(scope);
-          const klass = yield* createClass(node, tmpScope);
+          const klass = yield* createClass$1(node, tmpScope);
           tmpScope.const(node.id.name, klass);
           return klass;
       }
       else {
-          return yield* createClass(node, scope);
+          return yield* createClass$1(node, scope);
       }
   }
-  function* Super$1(node, scope, options = {}) {
+  function* Super(node, scope, options = {}) {
       const { getProto = false } = options;
       const superClass = scope.find(SUPER).get();
       return getProto ? superClass.prototype : superClass;
   }
-  function* SpreadElement$1(node, scope) {
-      const result = yield* evaluate$1(node.argument, scope);
+  function* SpreadElement(node, scope) {
+      const result = yield* evaluate(node.argument, scope);
       return typeof result === 'string' ? [...result] : result;
   }
-  function* ChainExpression$1(node, scope) {
-      return yield* evaluate$1(node.expression, scope);
+  function* ChainExpression(node, scope) {
+      return yield* evaluate(node.expression, scope);
   }
-  function* ImportExpression$1(node, scope) {
+  function* ImportExpression(node, scope) {
       const globalScope = scope.global();
-      const source = yield* evaluate$1(node.source, scope);
+      const source = yield* evaluate(node.source, scope);
       const module = globalScope.find(IMPORT + source);
       let value;
       if (module) {
@@ -2438,45 +2569,45 @@
       return Promise.resolve(value);
   }
   function* YieldExpression(node, scope) {
-      const res = yield* evaluate$1(node.argument, scope);
+      const res = yield* evaluate(node.argument, scope);
       return node.delegate ? yield* res : yield res;
   }
   function* AwaitExpression(node, scope) {
-      AWAIT.RES = yield* evaluate$1(node.argument, scope);
+      AWAIT.RES = yield* evaluate(node.argument, scope);
       return yield AWAIT;
   }
 
-  var expression$1 = /*#__PURE__*/Object.freeze({
+  var expression = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ThisExpression: ThisExpression$1,
-    ArrayExpression: ArrayExpression$1,
-    ObjectExpression: ObjectExpression$1,
-    FunctionExpression: FunctionExpression$1,
-    UnaryExpression: UnaryExpression$1,
-    UpdateExpression: UpdateExpression$1,
-    BinaryExpression: BinaryExpression$1,
-    AssignmentExpression: AssignmentExpression$1,
-    LogicalExpression: LogicalExpression$1,
-    MemberExpression: MemberExpression$1,
-    ConditionalExpression: ConditionalExpression$1,
-    CallExpression: CallExpression$1,
-    NewExpression: NewExpression$1,
-    MetaProperty: MetaProperty$1,
-    SequenceExpression: SequenceExpression$1,
-    ArrowFunctionExpression: ArrowFunctionExpression$1,
-    TemplateLiteral: TemplateLiteral$1,
-    TaggedTemplateExpression: TaggedTemplateExpression$1,
-    TemplateElement: TemplateElement$1,
-    ClassExpression: ClassExpression$1,
-    Super: Super$1,
-    SpreadElement: SpreadElement$1,
-    ChainExpression: ChainExpression$1,
-    ImportExpression: ImportExpression$1,
+    ThisExpression: ThisExpression,
+    ArrayExpression: ArrayExpression,
+    ObjectExpression: ObjectExpression,
+    FunctionExpression: FunctionExpression,
+    UnaryExpression: UnaryExpression,
+    UpdateExpression: UpdateExpression,
+    BinaryExpression: BinaryExpression,
+    AssignmentExpression: AssignmentExpression,
+    LogicalExpression: LogicalExpression,
+    MemberExpression: MemberExpression,
+    ConditionalExpression: ConditionalExpression,
+    CallExpression: CallExpression,
+    NewExpression: NewExpression,
+    MetaProperty: MetaProperty,
+    SequenceExpression: SequenceExpression,
+    ArrowFunctionExpression: ArrowFunctionExpression,
+    TemplateLiteral: TemplateLiteral,
+    TaggedTemplateExpression: TaggedTemplateExpression,
+    TemplateElement: TemplateElement,
+    ClassExpression: ClassExpression,
+    Super: Super,
+    SpreadElement: SpreadElement,
+    ChainExpression: ChainExpression,
+    ImportExpression: ImportExpression,
     YieldExpression: YieldExpression,
     AwaitExpression: AwaitExpression
   });
 
-  function* ObjectPattern$1(node, scope, options = {}) {
+  function* ObjectPattern(node, scope, options = {}) {
       const { kind = 'var', hoist = false, onlyBlock = false, feed = {} } = options;
       const fedKeys = [];
       for (let i = 0; i < node.properties.length; i++) {
@@ -2489,18 +2620,18 @@
                           scope[kind](value.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
                       }
                       else {
-                          yield* pattern$2(value, scope, { kind, hoist, onlyBlock });
+                          yield* pattern$1(value, scope, { kind, hoist, onlyBlock });
                       }
                   }
                   else {
-                      yield* RestElement$1(property, scope, { kind, hoist, onlyBlock });
+                      yield* RestElement(property, scope, { kind, hoist, onlyBlock });
                   }
               }
           }
           else if (property.type === 'Property') {
               let key;
               if (property.computed) {
-                  key = yield* evaluate$1(property.key, scope);
+                  key = yield* evaluate(property.key, scope);
               }
               else {
                   key = property.key.name;
@@ -2511,18 +2642,18 @@
                   scope[kind](value.name, feed[key]);
               }
               else {
-                  yield* pattern$2(value, scope, { kind, feed: feed[key] });
+                  yield* pattern$1(value, scope, { kind, feed: feed[key] });
               }
           }
           else {
               const rest = assign({}, feed);
               for (let i = 0; i < fedKeys.length; i++)
                   delete rest[fedKeys[i]];
-              yield* RestElement$1(property, scope, { kind, feed: rest });
+              yield* RestElement(property, scope, { kind, feed: rest });
           }
       }
   }
-  function* ArrayPattern$1(node, scope, options = {}) {
+  function* ArrayPattern(node, scope, options = {}) {
       const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
       const result = [];
       for (let i = 0; i < node.elements.length; i++) {
@@ -2535,7 +2666,7 @@
                       scope[kind](element.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
                   }
                   else {
-                      yield* pattern$2(element, scope, { kind, hoist, onlyBlock });
+                      yield* pattern$1(element, scope, { kind, hoist, onlyBlock });
                   }
               }
           }
@@ -2544,23 +2675,23 @@
                   scope[kind](element.name, feed[i]);
               }
               else {
-                  const variable = yield* Identifier$1(element, scope, { getVar: true });
+                  const variable = yield* Identifier(element, scope, { getVar: true });
                   variable.set(feed[i]);
                   result.push(variable.get());
               }
           }
           else if (element.type === 'RestElement') {
-              yield* RestElement$1(element, scope, { kind, feed: feed.slice(i) });
+              yield* RestElement(element, scope, { kind, feed: feed.slice(i) });
           }
           else {
-              yield* pattern$2(element, scope, { kind, feed: feed[i] });
+              yield* pattern$1(element, scope, { kind, feed: feed[i] });
           }
       }
       if (result.length) {
           return result;
       }
   }
-  function* RestElement$1(node, scope, options = {}) {
+  function* RestElement(node, scope, options = {}) {
       const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
       const arg = node.argument;
       if (hoist) {
@@ -2569,7 +2700,7 @@
                   scope[kind](arg.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  yield* pattern$2(arg, scope, { kind, hoist, onlyBlock });
+                  yield* pattern$1(arg, scope, { kind, hoist, onlyBlock });
               }
           }
       }
@@ -2578,16 +2709,16 @@
               scope[kind](arg.name, feed);
           }
           else {
-              const variable = yield* Identifier$1(arg, scope, { getVar: true });
+              const variable = yield* Identifier(arg, scope, { getVar: true });
               variable.set(feed);
           }
       }
       else {
-          yield* pattern$2(arg, scope, { kind, feed });
+          yield* pattern$1(arg, scope, { kind, feed });
       }
   }
-  function* AssignmentPattern$1(node, scope, options = {}) {
-      const { kind = 'var', hoist = false, onlyBlock = false, feed = yield* evaluate$1(node.right, scope) } = options;
+  function* AssignmentPattern(node, scope, options = {}) {
+      const { kind = 'var', hoist = false, onlyBlock = false, feed = yield* evaluate(node.right, scope) } = options;
       const left = node.left;
       if (hoist) {
           if (onlyBlock || kind === 'var') {
@@ -2595,7 +2726,7 @@
                   scope[kind](left.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  yield* pattern$2(left, scope, { kind, hoist, onlyBlock });
+                  yield* pattern$1(left, scope, { kind, hoist, onlyBlock });
               }
           }
       }
@@ -2603,26 +2734,26 @@
           scope[kind](left.name, feed);
       }
       else {
-          yield* pattern$2(left, scope, { kind, feed });
+          yield* pattern$1(left, scope, { kind, feed });
       }
   }
 
-  var pattern$1 = /*#__PURE__*/Object.freeze({
+  var pattern$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ObjectPattern: ObjectPattern$1,
-    ArrayPattern: ArrayPattern$1,
-    RestElement: RestElement$1,
-    AssignmentPattern: AssignmentPattern$1
+    ObjectPattern: ObjectPattern,
+    ArrayPattern: ArrayPattern,
+    RestElement: RestElement,
+    AssignmentPattern: AssignmentPattern
   });
 
-  let evaluateOps$1;
-  function* evaluate$1(node, scope) {
+  let evaluateOps;
+  function* evaluate(node, scope) {
       if (!node)
           return;
-      if (!evaluateOps$1) {
-          evaluateOps$1 = assign({}, declaration$1, expression$1, identifier$1, statement$1, literal$1, pattern$1);
+      if (!evaluateOps) {
+          evaluateOps = assign({}, declaration, expression, identifier, statement, literal, pattern$2);
       }
-      const handler = evaluateOps$1[node.type];
+      const handler = evaluateOps[node.type];
       if (handler) {
           return yield* handler(node, scope);
       }
@@ -2631,59 +2762,126 @@
       }
   }
 
-  function* ExpressionStatement$1(node, scope) {
-      yield* evaluate$1(node.expression, scope);
+  function* ExpressionStatement(node, scope) {
+      yield* evaluate(node.expression, scope);
   }
-  function* BlockStatement$1(block, scope, options = {}) {
+  function* BlockStatement(block, scope, options = {}) {
       const { invasived = false, hoisted = false, } = options;
       const subScope = invasived ? scope : new Scope(scope);
       if (!hoisted) {
-          yield* hoist(block, subScope, { onlyBlock: true });
+          yield* hoist$1(block, subScope, { onlyBlock: true });
       }
       for (let i = 0; i < block.body.length; i++) {
-          const result = yield* evaluate$1(block.body[i], subScope);
-          if (result === BREAK || result === CONTINUE || result === RETURN) {
+          const result = yield* evaluate(block.body[i], subScope);
+          if (result === BREAK) {
+              if (result.LABEL && result.LABEL === options.label) {
+                  break;
+              }
+              return result;
+          }
+          if (result === CONTINUE || result === RETURN) {
               return result;
           }
       }
   }
-  function* EmptyStatement$1() {
+  function* EmptyStatement() {
   }
-  function* DebuggerStatement$1() {
+  function* DebuggerStatement() {
       debugger;
   }
-  function* ReturnStatement$1(node, scope) {
-      RETURN.RES = node.argument ? (yield* evaluate$1(node.argument, scope)) : undefined;
+  function* ReturnStatement(node, scope) {
+      RETURN.RES = node.argument ? (yield* evaluate(node.argument, scope)) : undefined;
       return RETURN;
   }
-  function* BreakStatement$1() {
+  function* BreakStatement(node) {
+      var _a;
+      BREAK.LABEL = (_a = node.label) === null || _a === void 0 ? void 0 : _a.name;
       return BREAK;
   }
-  function* ContinueStatement$1() {
+  function* ContinueStatement(node) {
+      var _a;
+      CONTINUE.LABEL = (_a = node.label) === null || _a === void 0 ? void 0 : _a.name;
       return CONTINUE;
   }
-  function* IfStatement$1(node, scope) {
-      if (yield* evaluate$1(node.test, scope)) {
-          return yield* evaluate$1(node.consequent, scope);
+  function* LabeledStatement(node, scope) {
+      const label = node.label.name;
+      if (node.body.type === 'WhileStatement') {
+          return yield* WhileStatement(node.body, scope, { label });
       }
-      else {
-          return yield* evaluate$1(node.alternate, scope);
+      if (node.body.type === 'DoWhileStatement') {
+          return yield* DoWhileStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForStatement') {
+          return yield* ForStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForInStatement') {
+          return yield* ForInStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'ForOfStatement') {
+          return yield* ForOfStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'BlockStatement') {
+          return yield* BlockStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'WithStatement') {
+          return yield* WithStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'IfStatement') {
+          return yield* IfStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'SwitchStatement') {
+          return yield* SwitchStatement(node.body, scope, { label });
+      }
+      if (node.body.type === 'TryStatement') {
+          return yield* TryStatement(node.body, scope, { label });
+      }
+      throw new SyntaxError(`${node.body.type} cannot be labeled`);
+  }
+  function* WithStatement(node, scope, options = {}) {
+      const withScope = new Scope(scope);
+      withScope.with(yield* evaluate(node.object, scope));
+      const result = yield* evaluate(node.body, withScope);
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
+          }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
       }
   }
-  function* SwitchStatement$1(node, scope) {
-      const discriminant = yield* evaluate$1(node.discriminant, scope);
+  function* IfStatement(node, scope, options = {}) {
+      const result = yield* evaluate(node.test, scope)
+          ? yield* evaluate(node.consequent, scope)
+          : yield* evaluate(node.alternate, scope);
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
+          }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
+      }
+  }
+  function* SwitchStatement(node, scope, options = {}) {
+      const discriminant = yield* evaluate(node.discriminant, scope);
       let matched = false;
       for (let i = 0; i < node.cases.length; i++) {
           const eachCase = node.cases[i];
           if (!matched
               && (!eachCase.test
-                  || (yield* evaluate$1(eachCase.test, scope)) === discriminant)) {
+                  || (yield* evaluate(eachCase.test, scope)) === discriminant)) {
               matched = true;
           }
           if (matched) {
-              const result = yield* SwitchCase$1(eachCase, scope);
+              const result = yield* SwitchCase(eachCase, scope);
               if (result === BREAK) {
-                  break;
+                  if (result.LABEL === options.label) {
+                      break;
+                  }
+                  return result;
               }
               if (result === CONTINUE || result === RETURN) {
                   return result;
@@ -2691,20 +2889,21 @@
           }
       }
   }
-  function* SwitchCase$1(node, scope) {
+  function* SwitchCase(node, scope) {
       for (let i = 0; i < node.consequent.length; i++) {
-          const result = yield* evaluate$1(node.consequent[i], scope);
+          const result = yield* evaluate(node.consequent[i], scope);
           if (result === BREAK || result === CONTINUE || result === RETURN) {
               return result;
           }
       }
   }
-  function* ThrowStatement$1(node, scope) {
-      throw yield* evaluate$1(node.argument, scope);
+  function* ThrowStatement(node, scope) {
+      throw yield* evaluate(node.argument, scope);
   }
-  function* TryStatement$1(node, scope) {
+  function* TryStatement(node, scope, options = {}) {
+      let result;
       try {
-          return yield* BlockStatement$1(node.block, scope);
+          result = yield* BlockStatement(node.block, scope);
       }
       catch (err) {
           if (node.handler) {
@@ -2716,10 +2915,10 @@
                       subScope.var(name, err);
                   }
                   else {
-                      yield* pattern$2(param, scope, { feed: err });
+                      yield* pattern$1(param, scope, { feed: err });
                   }
               }
-              return yield* CatchClause$1(node.handler, subScope);
+              result = yield* CatchClause(node.handler, subScope);
           }
           else {
               throw err;
@@ -2727,92 +2926,128 @@
       }
       finally {
           if (node.finalizer) {
-              const result = yield* BlockStatement$1(node.finalizer, scope);
-              if (result === BREAK || result === CONTINUE || result === RETURN) {
-                  return result;
-              }
+              result = yield* BlockStatement(node.finalizer, scope);
+          }
+      }
+      if (result === BREAK) {
+          if (result.LABEL && result.LABEL === options.label) {
+              return;
           }
+          return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+          return result;
       }
   }
-  function* CatchClause$1(node, scope) {
-      return yield* BlockStatement$1(node.body, scope, { invasived: true });
+  function* CatchClause(node, scope) {
+      return yield* BlockStatement(node.body, scope, { invasived: true });
   }
-  function* WhileStatement$1(node, scope) {
-      while (yield* evaluate$1(node.test, scope)) {
-          const result = yield* evaluate$1(node.body, scope);
+  function* WhileStatement(node, scope, options = {}) {
+      while (yield* evaluate(node.test, scope)) {
+          const result = yield* evaluate(node.body, scope);
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function* DoWhileStatement$1(node, scope) {
+  function* DoWhileStatement(node, scope, options = {}) {
       do {
-          const result = yield* evaluate$1(node.body, scope);
+          const result = yield* evaluate(node.body, scope);
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
-      } while (yield* evaluate$1(node.test, scope));
+      } while (yield* evaluate(node.test, scope));
   }
-  function* ForStatement$1(node, scope) {
+  function* ForStatement(node, scope, options = {}) {
       const forScope = new Scope(scope);
-      for (yield* evaluate$1(node.init, forScope); node.test ? (yield* evaluate$1(node.test, forScope)) : true; yield* evaluate$1(node.update, forScope)) {
+      for (yield* evaluate(node.init, forScope); node.test ? (yield* evaluate(node.test, forScope)) : true; yield* evaluate(node.update, forScope)) {
           const subScope = new Scope(forScope);
           let result;
           if (node.body.type === 'BlockStatement') {
-              result = yield* BlockStatement$1(node.body, subScope, { invasived: true });
+              result = yield* BlockStatement(node.body, subScope, { invasived: true });
           }
           else {
-              result = yield* evaluate$1(node.body, subScope);
+              result = yield* evaluate(node.body, subScope);
           }
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function* ForInStatement$1(node, scope) {
-      for (const value in yield* evaluate$1(node.right, scope)) {
-          const result = yield* ForXHandler(node, scope, { value });
+  function* ForInStatement(node, scope, options = {}) {
+      for (const value in yield* evaluate(node.right, scope)) {
+          const result = yield* ForXHandler$1(node, scope, { value });
           if (result === BREAK) {
-              break;
+              if (result.LABEL === options.label) {
+                  break;
+              }
+              return result;
           }
           else if (result === CONTINUE) {
-              continue;
+              if (result.LABEL === options.label) {
+                  continue;
+              }
+              return result;
           }
           else if (result === RETURN) {
               return result;
           }
       }
   }
-  function* ForOfStatement$1(node, scope) {
-      const right = yield* evaluate$1(node.right, scope);
+  function* ForOfStatement(node, scope, options = {}) {
+      const right = yield* evaluate(node.right, scope);
       if (node.await) {
           const iterator = getAsyncIterator(right);
           let ret;
           for (AWAIT.RES = iterator.next(), ret = yield AWAIT; !ret.done; AWAIT.RES = iterator.next(), ret = yield AWAIT) {
-              const result = yield* ForXHandler(node, scope, { value: ret.value });
+              const result = yield* ForXHandler$1(node, scope, { value: ret.value });
               if (result === BREAK) {
-                  break;
+                  if (result.LABEL === options.label) {
+                      break;
+                  }
+                  return result;
               }
               else if (result === CONTINUE) {
-                  continue;
+                  if (result.LABEL === options.label) {
+                      continue;
+                  }
+                  return result;
               }
               else if (result === RETURN) {
                   return result;
@@ -2821,12 +3056,18 @@
       }
       else {
           for (const value of right) {
-              const result = yield* ForXHandler(node, scope, { value });
+              const result = yield* ForXHandler$1(node, scope, { value });
               if (result === BREAK) {
-                  break;
+                  if (result.LABEL === options.label) {
+                      break;
+                  }
+                  return result;
               }
               else if (result === CONTINUE) {
-                  continue;
+                  if (result.LABEL === options.label) {
+                      continue;
+                  }
+                  return result;
               }
               else if (result === RETURN) {
                   return result;
@@ -2835,15 +3076,15 @@
       }
   }
 
-  function* FunctionDeclaration$1(node, scope) {
-      scope.func(node.id.name, createFunc(node, scope));
+  function* FunctionDeclaration(node, scope) {
+      scope.func(node.id.name, createFunc$1(node, scope));
   }
-  function* VariableDeclaration$1(node, scope, options = {}) {
+  function* VariableDeclaration(node, scope, options = {}) {
       for (let i = 0; i < node.declarations.length; i++) {
-          yield* VariableDeclarator$1(node.declarations[i], scope, assign({ kind: node.kind }, options));
+          yield* VariableDeclarator(node.declarations[i], scope, assign({ kind: node.kind }, options));
       }
   }
-  function* VariableDeclarator$1(node, scope, options = {}) {
+  function* VariableDeclarator(node, scope, options = {}) {
       const { kind = 'var', hoist = false, onlyBlock = false, feed } = options;
       if (hoist) {
           if (onlyBlock || kind === 'var') {
@@ -2851,13 +3092,13 @@
                   scope[kind](node.id.name, onlyBlock ? DEADZONE : kind === 'var' ? NOINIT : undefined);
               }
               else {
-                  yield* pattern$2(node.id, scope, { kind, hoist, onlyBlock });
+                  yield* pattern$1(node.id, scope, { kind, hoist, onlyBlock });
               }
           }
       }
       else {
           const hasFeed = 'feed' in options;
-          const value = hasFeed ? feed : yield* evaluate$1(node.init, scope);
+          const value = hasFeed ? feed : yield* evaluate(node.init, scope);
           if (node.id.type === 'Identifier') {
               const name = node.id.name;
               if (kind === 'var' && !node.init && !hasFeed) {
@@ -2877,34 +3118,34 @@
               }
           }
           else {
-              yield* pattern$2(node.id, scope, { kind, feed: value });
+              yield* pattern$1(node.id, scope, { kind, feed: value });
           }
       }
   }
-  function* ClassDeclaration$1(node, scope) {
-      scope.func(node.id.name, yield* createClass(node, scope));
+  function* ClassDeclaration(node, scope) {
+      scope.func(node.id.name, yield* createClass$1(node, scope));
   }
-  function* ClassBody$1(node, scope, options = {}) {
+  function* ClassBody(node, scope, options = {}) {
       const { klass, superClass } = options;
       for (let i = 0; i < node.body.length; i++) {
           const def = node.body[i];
           if (def.type === 'MethodDefinition') {
-              yield* MethodDefinition$1(def, scope, { klass, superClass });
+              yield* MethodDefinition(def, scope, { klass, superClass });
           }
           else if (def.type === 'PropertyDefinition' && def.static) {
-              yield* PropertyDefinition$1(def, scope, { klass, superClass });
+              yield* PropertyDefinition(def, scope, { klass, superClass });
           }
           else if (def.type === 'StaticBlock') {
-              yield* StaticBlock$1(def, scope, { klass, superClass });
+              yield* StaticBlock(def, scope, { klass, superClass });
           }
       }
   }
-  function* MethodDefinition$1(node, scope, options = {}) {
+  function* MethodDefinition(node, scope, options = {}) {
       const { klass, superClass } = options;
       let key;
       let priv = false;
       if (node.computed) {
-          key = yield* evaluate$1(node.key, scope);
+          key = yield* evaluate(node.key, scope);
       }
       else if (node.key.type === 'Identifier') {
           key = node.key.name;
@@ -2923,7 +3164,7 @@
           }
           obj = obj[PRIVATE];
       }
-      const value = createFunc(node.value, scope, { superClass });
+      const value = createFunc$1(node.value, scope, { superClass });
       switch (node.kind) {
           case 'constructor':
               break;
@@ -2956,12 +3197,12 @@
               throw new SyntaxError('Unexpected token');
       }
   }
-  function* PropertyDefinition$1(node, scope, options = {}) {
+  function* PropertyDefinition(node, scope, options = {}) {
       const { klass, superClass } = options;
       let key;
       let priv = false;
       if (node.computed) {
-          key = yield* evaluate$1(node.key, scope);
+          key = yield* evaluate(node.key, scope);
       }
       else if (node.key.type === 'Identifier') {
           key = node.key.name;
@@ -2983,19 +3224,19 @@
           obj = obj[PRIVATE];
       }
       if (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression') {
-          obj[key] = createFunc(node.value, subScope, { superClass });
+          obj[key] = createFunc$1(node.value, subScope, { superClass });
       }
       else {
-          obj[key] = yield* evaluate$1(node.value, subScope);
+          obj[key] = yield* evaluate(node.value, subScope);
       }
   }
-  function* StaticBlock$1(node, scope, options = {}) {
+  function* StaticBlock(node, scope, options = {}) {
       const { klass } = options;
       const subScope = new Scope(scope, true);
       subScope.const('this', klass);
-      return yield* BlockStatement$1(node, subScope, { invasived: true });
+      return yield* BlockStatement(node, subScope, { invasived: true });
   }
-  function* ImportDeclaration$1(node, scope) {
+  function* ImportDeclaration(node, scope) {
       const globalScope = scope.global();
       const module = globalScope.find(IMPORT + node.source.value);
       let value;
@@ -3032,19 +3273,19 @@
           scope.var(spec.local.name, name === '*' ? assign({}, value) : value[name]);
       }
   }
-  function* ExportDefaultDeclaration$1(node, scope) {
+  function* ExportDefaultDeclaration(node, scope) {
       const globalScope = scope.global();
       let value;
       if (node.declaration.type === 'FunctionDeclaration') {
-          value = createFunc(node.declaration, scope);
+          value = createFunc$1(node.declaration, scope);
           scope.func(node.declaration.id.name, value);
       }
       else if (node.declaration.type === 'ClassDeclaration') {
-          value = yield* createClass(node.declaration, scope);
+          value = yield* createClass$1(node.declaration, scope);
           scope.func(node.declaration.id.name, value);
       }
       else {
-          value = yield* evaluate$1(node.declaration, scope);
+          value = yield* evaluate(node.declaration, scope);
       }
       const variable = globalScope.find(EXPORTS);
       if (variable) {
@@ -3054,11 +3295,11 @@
           }
       }
   }
-  function* ExportNamedDeclaration$1(node, scope) {
+  function* ExportNamedDeclaration(node, scope) {
       const globalScope = scope.global();
       if (node.declaration) {
           if (node.declaration.type === 'FunctionDeclaration') {
-              const value = createFunc(node.declaration, scope);
+              const value = createFunc$1(node.declaration, scope);
               scope.func(node.declaration.id.name, value);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
@@ -3069,7 +3310,7 @@
               }
           }
           else if (node.declaration.type === 'ClassDeclaration') {
-              const value = yield* createClass(node.declaration, scope);
+              const value = yield* createClass$1(node.declaration, scope);
               scope.func(node.declaration.id.name, value);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
@@ -3080,7 +3321,7 @@
               }
           }
           else if (node.declaration.type === 'VariableDeclaration') {
-              yield* VariableDeclaration$1(node.declaration, scope);
+              yield* VariableDeclaration(node.declaration, scope);
               const variable = globalScope.find(EXPORTS);
               if (variable) {
                   const exports = variable.get();
@@ -3115,7 +3356,7 @@
           }
       }
   }
-  function* ExportAllDeclaration$1(node, scope) {
+  function* ExportAllDeclaration(node, scope) {
       const globalScope = scope.global();
       const module = globalScope.find(IMPORT + node.source.value);
       let value;
@@ -3188,7 +3429,7 @@
       });
   }
 
-  function* hoist(block, scope, options = {}) {
+  function* hoist$1(block, scope, options = {}) {
       const { onlyBlock = false } = options;
       const funcDclrList = [];
       const funcDclrIdxs = [];
@@ -3200,10 +3441,10 @@
           }
           else if (statement.type === 'VariableDeclaration'
               && ['const', 'let'].indexOf(statement.kind) !== -1) {
-              yield* VariableDeclaration$1(statement, scope, { hoist: true, onlyBlock: true });
+              yield* VariableDeclaration(statement, scope, { hoist: true, onlyBlock: true });
           }
           else if (!onlyBlock) {
-              yield* hoistVarRecursion(statement, scope);
+              yield* hoistVarRecursion$1(statement, scope);
           }
       }
       if (funcDclrIdxs.length) {
@@ -3213,80 +3454,81 @@
           block.body = funcDclrList.concat(block.body);
       }
   }
-  function* hoistVarRecursion(statement, scope) {
+  function* hoistVarRecursion$1(statement, scope) {
       switch (statement.type) {
           case 'VariableDeclaration':
-              yield* VariableDeclaration$1(statement, scope, { hoist: true });
+              yield* VariableDeclaration(statement, scope, { hoist: true });
               break;
           case 'ForInStatement':
           case 'ForOfStatement':
               if (statement.left.type === 'VariableDeclaration') {
-                  yield* VariableDeclaration$1(statement.left, scope, { hoist: true });
+                  yield* VariableDeclaration(statement.left, scope, { hoist: true });
               }
           case 'ForStatement':
               if (statement.type === 'ForStatement' && statement.init.type === 'VariableDeclaration') {
-                  yield* VariableDeclaration$1(statement.init, scope, { hoist: true });
+                  yield* VariableDeclaration(statement.init, scope, { hoist: true });
               }
           case 'WhileStatement':
           case 'DoWhileStatement':
-              yield* hoistVarRecursion(statement.body, scope);
+              yield* hoistVarRecursion$1(statement.body, scope);
               break;
           case 'IfStatement':
-              yield* hoistVarRecursion(statement.consequent, scope);
+              yield* hoistVarRecursion$1(statement.consequent, scope);
               if (statement.alternate) {
-                  yield* hoistVarRecursion(statement.alternate, scope);
+                  yield* hoistVarRecursion$1(statement.alternate, scope);
               }
               break;
           case 'BlockStatement':
               for (let i = 0; i < statement.body.length; i++) {
-                  yield* hoistVarRecursion(statement.body[i], scope);
+                  yield* hoistVarRecursion$1(statement.body[i], scope);
               }
               break;
           case 'SwitchStatement':
               for (let i = 0; i < statement.cases.length; i++) {
                   for (let j = 0; j < statement.cases[i].consequent.length; j++) {
-                      yield* hoistVarRecursion(statement.cases[i].consequent[j], scope);
+                      yield* hoistVarRecursion$1(statement.cases[i].consequent[j], scope);
                   }
               }
               break;
           case 'TryStatement': {
               const tryBlock = statement.block.body;
               for (let i = 0; i < tryBlock.length; i++) {
-                  yield* hoistVarRecursion(tryBlock[i], scope);
+                  yield* hoistVarRecursion$1(tryBlock[i], scope);
               }
               const catchBlock = statement.handler && statement.handler.body.body;
               if (catchBlock) {
                   for (let i = 0; i < catchBlock.length; i++) {
-                      yield* hoistVarRecursion(catchBlock[i], scope);
+                      yield* hoistVarRecursion$1(catchBlock[i], scope);
                   }
               }
               const finalBlock = statement.finalizer && statement.finalizer.body;
               if (finalBlock) {
                   for (let i = 0; i < finalBlock.length; i++) {
-                      yield* hoistVarRecursion(finalBlock[i], scope);
+                      yield* hoistVarRecursion$1(finalBlock[i], scope);
                   }
               }
               break;
           }
       }
   }
-  function* pattern$2(node, scope, options = {}) {
+  function* pattern$1(node, scope, options = {}) {
       switch (node.type) {
           case 'ObjectPattern':
-              return yield* ObjectPattern$1(node, scope, options);
+              return yield* ObjectPattern(node, scope, options);
           case 'ArrayPattern':
-              return yield* ArrayPattern$1(node, scope, options);
+              return yield* ArrayPattern(node, scope, options);
           case 'RestElement':
-              return yield* RestElement$1(node, scope, options);
+              return yield* RestElement(node, scope, options);
           case 'AssignmentPattern':
-              return yield* AssignmentPattern$1(node, scope, options);
+              return yield* AssignmentPattern(node, scope, options);
           default:
               throw new SyntaxError('Unexpected token');
       }
   }
-  function createFunc(node, scope, options = {}) {
+  function createFunc$1(node, scope, options = {}) {
+      var _a;
       if (!node.generator && !node.async) {
-          return createFunc$1(node, scope, options);
+          return createFunc(node, scope, options);
       }
       const { superClass, construct } = options;
       const params = node.params;
@@ -3311,22 +3553,22 @@
                   subScope.var(param.name, args[i]);
               }
               else if (param.type === 'RestElement') {
-                  yield* RestElement$1(param, subScope, { kind: 'var', feed: args.slice(i) });
+                  yield* RestElement(param, subScope, { kind: 'var', feed: args.slice(i) });
               }
               else {
-                  yield* pattern$2(param, subScope, { kind: 'var', feed: args[i] });
+                  yield* pattern$1(param, subScope, { kind: 'var', feed: args[i] });
               }
           }
           let result;
           if (node.body.type === 'BlockStatement') {
-              yield* hoist(node.body, subScope);
-              result = yield* BlockStatement$1(node.body, subScope, {
+              yield* hoist$1(node.body, subScope);
+              result = yield* BlockStatement(node.body, subScope, {
                   invasived: true,
                   hoisted: true
               });
           }
           else {
-              result = yield* evaluate$1(node.body, subScope);
+              result = yield* evaluate(node.body, subScope);
               if (node.type === 'ArrowFunctionExpression') {
                   RETURN.RES = result;
                   result = RETURN;
@@ -3378,16 +3620,23 @@
           value: params.length,
           configurable: true
       });
+      const source = (_a = node.loc) === null || _a === void 0 ? void 0 : _a.source;
+      if (source) {
+          define(func, 'toString', {
+              value: () => source.substring(node.start, node.end),
+              configurable: true
+          });
+      }
       return func;
   }
-  function* createClass(node, scope) {
-      const superClass = yield* evaluate$1(node.superClass, scope);
+  function* createClass$1(node, scope) {
+      const superClass = yield* evaluate(node.superClass, scope);
       const methodBody = node.body.body;
       const construct = function* (object) {
           for (let i = 0; i < methodBody.length; i++) {
               const def = methodBody[i];
               if (def.type === 'PropertyDefinition' && !def.static) {
-                  yield* PropertyDefinition$1(def, scope, { klass: object, superClass });
+                  yield* PropertyDefinition(def, scope, { klass: object, superClass });
               }
           }
       };
@@ -3400,14 +3649,14 @@
       for (let i = 0; i < methodBody.length; i++) {
           const method = methodBody[i];
           if (method.type === 'MethodDefinition' && method.kind === 'constructor') {
-              klass = createFunc(method.value, scope, { superClass, construct });
+              klass = createFunc$1(method.value, scope, { superClass, construct });
               break;
           }
       }
       if (superClass) {
           inherits(klass, superClass);
       }
-      yield* ClassBody$1(node.body, scope, { klass, superClass });
+      yield* ClassBody(node.body, scope, { klass, superClass });
       define(klass, CLSCTOR, { value: true });
       define(klass, 'name', {
           value: node.id && node.id.name || '',
@@ -3415,31 +3664,31 @@
       });
       return klass;
   }
-  function* ForXHandler(node, scope, options) {
+  function* ForXHandler$1(node, scope, options) {
       const { value } = options;
       const left = node.left;
       const subScope = new Scope(scope);
       if (left.type === 'VariableDeclaration') {
-          yield* VariableDeclaration$1(left, subScope, { feed: value });
+          yield* VariableDeclaration(left, subScope, { feed: value });
       }
       else if (left.type === 'Identifier') {
-          const variable = yield* Identifier(left, scope, { getVar: true });
+          const variable = yield* Identifier$1(left, scope, { getVar: true });
           variable.set(value);
       }
       else {
-          yield* pattern$2(left, scope, { feed: value });
+          yield* pattern$1(left, scope, { feed: value });
       }
       let result;
       if (node.body.type === 'BlockStatement') {
-          result = yield* BlockStatement$1(node.body, subScope, { invasived: true });
+          result = yield* BlockStatement(node.body, subScope, { invasived: true });
       }
       else {
-          result = yield* evaluate$1(node.body, subScope);
+          result = yield* evaluate(node.body, subScope);
       }
       return result;
   }
 
-  function hoist$1(block, scope, options = {}) {
+  function hoist(block, scope, options = {}) {
       const { onlyBlock = false } = options;
       const funcDclrList = [];
       const funcDclrIdxs = [];
@@ -3451,10 +3700,10 @@
           }
           else if (statement.type === 'VariableDeclaration'
               && ['const', 'let'].indexOf(statement.kind) !== -1) {
-              VariableDeclaration(statement, scope, { hoist: true, onlyBlock: true });
+              VariableDeclaration$1(statement, scope, { hoist: true, onlyBlock: true });
           }
           else if (!onlyBlock) {
-              hoistVarRecursion$1(statement, scope);
+              hoistVarRecursion(statement, scope);
           }
       }
       if (funcDclrIdxs.length) {
@@ -3464,80 +3713,81 @@
           block.body = funcDclrList.concat(block.body);
       }
   }
-  function hoistVarRecursion$1(statement, scope) {
+  function hoistVarRecursion(statement, scope) {
       switch (statement.type) {
           case 'VariableDeclaration':
-              VariableDeclaration(statement, scope, { hoist: true });
+              VariableDeclaration$1(statement, scope, { hoist: true });
               break;
           case 'ForInStatement':
           case 'ForOfStatement':
               if (statement.left.type === 'VariableDeclaration') {
-                  VariableDeclaration(statement.left, scope, { hoist: true });
+                  VariableDeclaration$1(statement.left, scope, { hoist: true });
               }
           case 'ForStatement':
               if (statement.type === 'ForStatement' && statement.init.type === 'VariableDeclaration') {
-                  VariableDeclaration(statement.init, scope, { hoist: true });
+                  VariableDeclaration$1(statement.init, scope, { hoist: true });
               }
           case 'WhileStatement':
           case 'DoWhileStatement':
-              hoistVarRecursion$1(statement.body, scope);
+              hoistVarRecursion(statement.body, scope);
               break;
           case 'IfStatement':
-              hoistVarRecursion$1(statement.consequent, scope);
+              hoistVarRecursion(statement.consequent, scope);
               if (statement.alternate) {
-                  hoistVarRecursion$1(statement.alternate, scope);
+                  hoistVarRecursion(statement.alternate, scope);
               }
               break;
           case 'BlockStatement':
               for (let i = 0; i < statement.body.length; i++) {
-                  hoistVarRecursion$1(statement.body[i], scope);
+                  hoistVarRecursion(statement.body[i], scope);
               }
               break;
           case 'SwitchStatement':
               for (let i = 0; i < statement.cases.length; i++) {
                   for (let j = 0; j < statement.cases[i].consequent.length; j++) {
-                      hoistVarRecursion$1(statement.cases[i].consequent[j], scope);
+                      hoistVarRecursion(statement.cases[i].consequent[j], scope);
                   }
               }
               break;
           case 'TryStatement': {
               const tryBlock = statement.block.body;
               for (let i = 0; i < tryBlock.length; i++) {
-                  hoistVarRecursion$1(tryBlock[i], scope);
+                  hoistVarRecursion(tryBlock[i], scope);
               }
               const catchBlock = statement.handler && statement.handler.body.body;
               if (catchBlock) {
                   for (let i = 0; i < catchBlock.length; i++) {
-                      hoistVarRecursion$1(catchBlock[i], scope);
+                      hoistVarRecursion(catchBlock[i], scope);
                   }
               }
               const finalBlock = statement.finalizer && statement.finalizer.body;
               if (finalBlock) {
                   for (let i = 0; i < finalBlock.length; i++) {
-                      hoistVarRecursion$1(finalBlock[i], scope);
+                      hoistVarRecursion(finalBlock[i], scope);
                   }
               }
               break;
           }
       }
   }
-  function pattern$3(node, scope, options = {}) {
+  function pattern(node, scope, options = {}) {
       switch (node.type) {
           case 'ObjectPattern':
-              return ObjectPattern(node, scope, options);
+              return ObjectPattern$1(node, scope, options);
           case 'ArrayPattern':
-              return ArrayPattern(node, scope, options);
+              return ArrayPattern$1(node, scope, options);
           case 'RestElement':
-              return RestElement(node, scope, options);
+              return RestElement$1(node, scope, options);
           case 'AssignmentPattern':
-              return AssignmentPattern(node, scope, options);
+              return AssignmentPattern$1(node, scope, options);
           default:
               throw new SyntaxError('Unexpected token');
       }
   }
-  function createFunc$1(node, scope, options = {}) {
+  function createFunc(node, scope, options = {}) {
+      var _a;
       if (node.generator || node.async) {
-          return createFunc(node, scope, options);
+          return createFunc$1(node, scope, options);
       }
       const { superClass, construct } = options;
       const params = node.params;
@@ -3562,22 +3812,22 @@
                   subScope.var(param.name, args[i]);
               }
               else if (param.type === 'RestElement') {
-                  RestElement(param, subScope, { kind: 'var', feed: args.slice(i) });
+                  RestElement$1(param, subScope, { kind: 'var', feed: args.slice(i) });
               }
               else {
-                  pattern$3(param, subScope, { kind: 'var', feed: args[i] });
+                  pattern(param, subScope, { kind: 'var', feed: args[i] });
               }
           }
           let result;
           if (node.body.type === 'BlockStatement') {
-              hoist$1(node.body, subScope);
-              result = BlockStatement(node.body, subScope, {
+              hoist(node.body, subScope);
+              result = BlockStatement$1(node.body, subScope, {
                   invasived: true,
                   hoisted: true
               });
           }
           else {
-              result = evaluate(node.body, subScope);
+              result = evaluate$1(node.body, subScope);
               if (node.type === 'ArrowFunctionExpression') {
                   RETURN.RES = result;
                   result = RETURN;
@@ -3601,16 +3851,23 @@
           value: params.length,
           configurable: true
       });
+      const source = (_a = node.loc) === null || _a === void 0 ? void 0 : _a.source;
+      if (source) {
+          define(func, 'toString', {
+              value: () => source.substring(node.start, node.end),
+              configurable: true
+          });
+      }
       return func;
   }
-  function createClass$1(node, scope) {
-      const superClass = evaluate(node.superClass, scope);
+  function createClass(node, scope) {
+      const superClass = evaluate$1(node.superClass, scope);
       const methodBody = node.body.body;
       const construct = function (object) {
           for (let i = 0; i < methodBody.length; i++) {
               const def = methodBody[i];
               if (def.type === 'PropertyDefinition' && !def.static) {
-                  PropertyDefinition(def, scope, { klass: object, superClass });
+                  PropertyDefinition$1(def, scope, { klass: object, superClass });
               }
           }
       };
@@ -3623,14 +3880,14 @@
       for (let i = 0; i < methodBody.length; i++) {
           const method = methodBody[i];
           if (method.type === 'MethodDefinition' && method.kind === 'constructor') {
-              klass = createFunc$1(method.value, scope, { superClass, construct });
+              klass = createFunc(method.value, scope, { superClass, construct });
               break;
           }
       }
       if (superClass) {
           inherits(klass, superClass);
       }
-      ClassBody(node.body, scope, { klass, superClass });
+      ClassBody$1(node.body, scope, { klass, superClass });
       define(klass, CLSCTOR, { value: true });
       define(klass, 'name', {
           value: node.id && node.id.name || '',
@@ -3638,26 +3895,26 @@
       });
       return klass;
   }
-  function ForXHandler$1(node, scope, options) {
+  function ForXHandler(node, scope, options) {
       const { value } = options;
       const left = node.left;
       const subScope = new Scope(scope);
       if (left.type === 'VariableDeclaration') {
-          VariableDeclaration(left, subScope, { feed: value });
+          VariableDeclaration$1(left, subScope, { feed: value });
       }
       else if (left.type === 'Identifier') {
-          const variable = Identifier(left, scope, { getVar: true });
+          const variable = Identifier$1(left, scope, { getVar: true });
           variable.set(value);
       }
       else {
-          pattern$3(left, scope, { feed: value });
+          pattern(left, scope, { feed: value });
       }
       let result;
       if (node.body.type === 'BlockStatement') {
-          result = BlockStatement(node.body, subScope, { invasived: true });
+          result = BlockStatement$1(node.body, subScope, { invasived: true });
       }
       else {
-          result = evaluate(node.body, subScope);
+          result = evaluate$1(node.body, subScope);
       }
       return result;
   }
@@ -3711,12 +3968,12 @@
       }
       run(code) {
           const ast = typeof code === 'string' ? acorn.parse(code, this.options) : code;
-          hoist$1(ast, this.scope);
-          evaluate(ast, this.scope);
+          hoist(ast, this.scope);
+          evaluate$1(ast, this.scope);
       }
   }
   Sval.version = version;
 
   return Sval;
 
-})));
+}));