runtime-type-inspector 2.0.2 → 2.0.3

package/build/rti-transpiler.cjs

@@ -0,0 +1,2359 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/parser'), require('typescript')) :
+	typeof define === 'function' && define.amd ? define(['exports', '@babel/parser', 'typescript'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.rtiTranspiler = {}, global.parser, global.ts));
+})(this, (function (exports, parser, ts) { 'use strict';
+
+	function _iterableToArrayLimit(r, l) {
+	  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	  if (null != t) {
+	    var e,
+	      n,
+	      i,
+	      u,
+	      a = [],
+	      f = !0,
+	      o = !1;
+	    try {
+	      if (i = (t = t.call(r)).next, 0 === l) {
+	        if (Object(t) !== t) return;
+	        f = !1;
+	      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+	    } catch (r) {
+	      o = !0, n = r;
+	    } finally {
+	      try {
+	        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+	      } finally {
+	        if (o) throw n;
+	      }
+	    }
+	    return a;
+	  }
+	}
+	function _classCallCheck(instance, Constructor) {
+	  if (!(instance instanceof Constructor)) {
+	    throw new TypeError("Cannot call a class as a function");
+	  }
+	}
+	function _defineProperties(target, props) {
+	  for (var i = 0; i < props.length; i++) {
+	    var descriptor = props[i];
+	    descriptor.enumerable = descriptor.enumerable || false;
+	    descriptor.configurable = true;
+	    if ("value" in descriptor) descriptor.writable = true;
+	    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+	  }
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	  if (staticProps) _defineProperties(Constructor, staticProps);
+	  Object.defineProperty(Constructor, "prototype", {
+	    writable: false
+	  });
+	  return Constructor;
+	}
+	function _defineProperty(obj, key, value) {
+	  key = _toPropertyKey(key);
+	  if (key in obj) {
+	    Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: true,
+	      configurable: true,
+	      writable: true
+	    });
+	  } else {
+	    obj[key] = value;
+	  }
+	  return obj;
+	}
+	function _inherits(subClass, superClass) {
+	  if (typeof superClass !== "function" && superClass !== null) {
+	    throw new TypeError("Super expression must either be null or a function");
+	  }
+	  subClass.prototype = Object.create(superClass && superClass.prototype, {
+	    constructor: {
+	      value: subClass,
+	      writable: true,
+	      configurable: true
+	    }
+	  });
+	  Object.defineProperty(subClass, "prototype", {
+	    writable: false
+	  });
+	  if (superClass) _setPrototypeOf(subClass, superClass);
+	}
+	function _getPrototypeOf(o) {
+	  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+	    return o.__proto__ || Object.getPrototypeOf(o);
+	  };
+	  return _getPrototypeOf(o);
+	}
+	function _setPrototypeOf(o, p) {
+	  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+	    o.__proto__ = p;
+	    return o;
+	  };
+	  return _setPrototypeOf(o, p);
+	}
+	function _isNativeReflectConstruct() {
+	  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+	  if (Reflect.construct.sham) return false;
+	  if (typeof Proxy === "function") return true;
+	  try {
+	    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+	    return true;
+	  } catch (e) {
+	    return false;
+	  }
+	}
+	function _assertThisInitialized(self) {
+	  if (self === void 0) {
+	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	  }
+	  return self;
+	}
+	function _possibleConstructorReturn(self, call) {
+	  if (call && (typeof call === "object" || typeof call === "function")) {
+	    return call;
+	  } else if (call !== void 0) {
+	    throw new TypeError("Derived constructors may only return object or undefined");
+	  }
+	  return _assertThisInitialized(self);
+	}
+	function _createSuper(Derived) {
+	  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+	  return function _createSuperInternal() {
+	    var Super = _getPrototypeOf(Derived),
+	      result;
+	    if (hasNativeReflectConstruct) {
+	      var NewTarget = _getPrototypeOf(this).constructor;
+	      result = Reflect.construct(Super, arguments, NewTarget);
+	    } else {
+	      result = Super.apply(this, arguments);
+	    }
+	    return _possibleConstructorReturn(this, result);
+	  };
+	}
+	function _superPropBase(object, property) {
+	  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+	    object = _getPrototypeOf(object);
+	    if (object === null) break;
+	  }
+	  return object;
+	}
+	function _get() {
+	  if (typeof Reflect !== "undefined" && Reflect.get) {
+	    _get = Reflect.get.bind();
+	  } else {
+	    _get = function _get(target, property, receiver) {
+	      var base = _superPropBase(target, property);
+	      if (!base) return;
+	      var desc = Object.getOwnPropertyDescriptor(base, property);
+	      if (desc.get) {
+	        return desc.get.call(arguments.length < 3 ? target : receiver);
+	      }
+	      return desc.value;
+	    };
+	  }
+	  return _get.apply(this, arguments);
+	}
+	function _slicedToArray(arr, i) {
+	  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+	}
+	function _toConsumableArray(arr) {
+	  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+	}
+	function _arrayWithoutHoles(arr) {
+	  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+	}
+	function _arrayWithHoles(arr) {
+	  if (Array.isArray(arr)) return arr;
+	}
+	function _iterableToArray(iter) {
+	  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+	  if (!o) return;
+	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+	  var n = Object.prototype.toString.call(o).slice(8, -1);
+	  if (n === "Object" && o.constructor) n = o.constructor.name;
+	  if (n === "Map" || n === "Set") return Array.from(o);
+	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+	  if (len == null || len > arr.length) len = arr.length;
+	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	  return arr2;
+	}
+	function _nonIterableSpread() {
+	  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _nonIterableRest() {
+	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _createForOfIteratorHelper(o, allowArrayLike) {
+	  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+	  if (!it) {
+	    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+	      if (it) o = it;
+	      var i = 0;
+	      var F = function () {};
+	      return {
+	        s: F,
+	        n: function () {
+	          if (i >= o.length) return {
+	            done: true
+	          };
+	          return {
+	            done: false,
+	            value: o[i++]
+	          };
+	        },
+	        e: function (e) {
+	          throw e;
+	        },
+	        f: F
+	      };
+	    }
+	    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	  }
+	  var normalCompletion = true,
+	    didErr = false,
+	    err;
+	  return {
+	    s: function () {
+	      it = it.call(o);
+	    },
+	    n: function () {
+	      var step = it.next();
+	      normalCompletion = step.done;
+	      return step;
+	    },
+	    e: function (e) {
+	      didErr = true;
+	      err = e;
+	    },
+	    f: function () {
+	      try {
+	        if (!normalCompletion && it.return != null) it.return();
+	      } finally {
+	        if (didErr) throw err;
+	      }
+	    }
+	  };
+	}
+	function _toPrimitive(input, hint) {
+	  if (typeof input !== "object" || input === null) return input;
+	  var prim = input[Symbol.toPrimitive];
+	  if (prim !== undefined) {
+	    var res = prim.call(input, hint || "default");
+	    if (typeof res !== "object") return res;
+	    throw new TypeError("@@toPrimitive must return a primitive value.");
+	  }
+	  return (hint === "string" ? String : Number)(input);
+	}
+	function _toPropertyKey(arg) {
+	  var key = _toPrimitive(arg, "string");
+	  return typeof key === "symbol" ? key : String(key);
+	}
+
+	function expandTypeDepFree(type) {
+	  type = type.trim();
+	  while (!type.includes('|') && type[0] == '(' && type[type.length - 1] == ')') {
+	    type = type.slice(1, -1).trim();
+	  }
+	  if (type[0] === '.' && type[1] === '.' && type[2] === '.') {
+	    return {
+	      type: 'array',
+	      elementType: type.slice(3)
+	    };
+	  }
+	  if (type.startsWith("Array<") && type.endsWith('>')) {
+	    var typeSlice = type.slice(6, -1);
+	    return {
+	      type: "array",
+	      elementType: expandTypeDepFree(typeSlice)
+	    };
+	  }
+	  if ((type.startsWith("Object<") || type.startsWith("Record<")) && type.endsWith('>')) {
+	    var recordSlice = type.slice(7, -1);
+	    var firstComma = recordSlice.indexOf(',');
+	    if (firstComma === -1) {
+	      console.warn("expandTypeDepFree> invalid Object/Record");
+	    }
+	    var key = recordSlice.slice(0, firstComma).trim();
+	    var val = recordSlice.slice(firstComma + 1).trim();
+	    return {
+	      type: "record",
+	      key: expandTypeDepFree(key),
+	      val: expandTypeDepFree(val)
+	    };
+	  }
+	  if (type[0] == '{' && type[type.length - 1] == '}') {
+	    var propertiesArray = type.slice(1, -1).split(',');
+	    var properties = {};
+	    propertiesArray.forEach(function (_) {
+	      var _$split$map = _.split(":").map(function (_) {
+	          return _.trim();
+	        }),
+	        _$split$map2 = _slicedToArray(_$split$map, 2),
+	        propName = _$split$map2[0],
+	        propType = _$split$map2[1];
+	      if (!propName || !propType) {
+	        console.warn('expandTypeDepFree> unexpected type format, fix');
+	        return false;
+	      }
+	      properties[propName] = propType;
+	    });
+	    return {
+	      type: 'object',
+	      properties: properties
+	    };
+	  }
+	  var members = type.split("|");
+	  if (members.length >= 2) {
+	    members.forEach(function (_, i) {
+	      return members[i] = _.trim();
+	    });
+	    return {
+	      type: 'union',
+	      members: members.map(expandTypeDepFree)
+	    };
+	  }
+	  if (type.endsWith("[]")) {
+	    var _typeSlice = type.slice(0, -2);
+	    return {
+	      type: 'array',
+	      elementType: expandTypeDepFree(_typeSlice)
+	    };
+	  }
+	  if (type[0] == '[' && type[type.length - 1] == ']') {
+	    var elements = type.slice(1, -1).split(',');
+	    return {
+	      type: 'tuple',
+	      elements: elements.map(expandTypeDepFree)
+	    };
+	  }
+	  if (type === 'object' || type === 'Object') {
+	    return {
+	      type: 'object',
+	      properties: {}
+	    };
+	  }
+	  return type;
+	}
+
+	function simplifyType(type, optional) {
+	  if (type instanceof Object) {
+	    type.optional = optional;
+	  } else if (typeof type === 'string') {
+	    type = type.trim();
+	    if (type != 'object' && type != 'object[]' && type != 'union' && !optional) {
+	      return type;
+	    }
+	    type = {
+	      type: type,
+	      optional: optional
+	    };
+	  } else {
+	    debugger;
+	    console.warn("simplifyType> neither object nor string for type", type);
+	  }
+	  if (type.type == 'object' && type.properties && Object.keys(type.properties).length === 0) {
+	    delete type.properties;
+	  }
+	  return type;
+	}
+
+	function parseJSDoc(src) {
+	  var expandType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : expandTypeDepFree;
+	  var regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
+	  var matches = _toConsumableArray(src.matchAll(regex));
+	  var params = Object.create(null);
+	  matches.forEach(function (_) {
+	    var type = expandType(_[1].trim());
+	    var name = _[2].trim();
+	    var optional = false;
+	    if (name[0] === '[') {
+	      var closer = name.lastIndexOf(']');
+	      name = name.substring(1, closer);
+	      optional = true;
+	    }
+	    name = name.split(' ')[0].split('=')[0].trim();
+	    var simplifiedType = simplifyType(type, optional);
+	    var parts = name.split(".");
+	    if (parts.length == 3) {
+	      var parts0 = parts[0];
+	      var parts1 = parts[1];
+	      var parts2 = parts[2];
+	      var toptype = params[parts0];
+	      toptype.properties[parts1].properties = toptype.properties[parts1].properties || {};
+	      toptype.properties[parts1].properties[parts2] = simplifiedType;
+	    } else if (parts.length == 2) {
+	      var _parts = parts[0];
+	      var _parts2 = parts[1];
+	      if (_parts.endsWith('[]')) {
+	        _parts = _parts.slice(0, -2);
+	      }
+	      var _toptype = params[_parts];
+	      if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) == "union") {
+	        var typeObject = _toptype.members.find(function (_) {
+	          return (_ === null || _ === void 0 ? void 0 : _.type) == 'object';
+	        });
+	        typeObject.properties[_parts2] = simplifiedType;
+	      } else if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) == "array") {
+	        _toptype.elementType.properties[_parts2] = simplifiedType;
+	      } else if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) == "object") {
+	        _toptype.properties = _toptype.properties || {};
+	        _toptype.properties[_parts2] = simplifiedType;
+	      } else {
+	        console.warn("parseJSDoc> skipping @param, unseen syntax detected, please check if your JSDoc is valid or open an issue about this", {
+	          src: src,
+	          toptype: _toptype,
+	          parts0: _parts,
+	          parts1: _parts2,
+	          simplifiedType: simplifiedType
+	        });
+	      }
+	    } else {
+	      params[name] = simplifiedType;
+	    }
+	  });
+	  if (Object.keys(params).length === 0) {
+	    return;
+	  }
+	  return params;
+	}
+
+	function parseJSDocSetter(src) {
+	  var expandType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : expandTypeDepFree;
+	  var regex = /@type \{(.*?)\}/g;
+	  var matches = _toConsumableArray(src.matchAll(regex));
+	  if (matches.length === 1) {
+	    var match = matches[0];
+	    var type = expandType(match[1]);
+	    var simplifiedType = simplifyType(type, false);
+	    return simplifiedType;
+	  }
+	}
+
+	function extractNameAndOptionality(rest) {
+	  rest = rest.trim();
+	  var optional = false;
+	  if (rest[0] === '[') {
+	    var closer = rest.lastIndexOf(']');
+	    rest = rest.substring(1, closer);
+	    optional = true;
+	  }
+	  var name = rest.split(' ')[0].split('=')[0].trim();
+	  return [name, optional];
+	}
+
+	function extractCurlyContent(line) {
+	  var firstCurly = line.indexOf('{');
+	  var k = firstCurly + 1;
+	  var count = 0;
+	  for (; k < line.length; k++) {
+	    var c = line[k];
+	    if (c === '{') {
+	      count++;
+	    } else if (c === '}') {
+	      count--;
+	    }
+	    if (count === -1) {
+	      break;
+	    }
+	  }
+	  var content = line.substring(firstCurly + 1, k);
+	  return {
+	    content: content,
+	    nextIndex: k + 1
+	  };
+	}
+	function parseJSDocTypedef(typedefs, warn, comment, expandType) {
+	  var type = comment.type,
+	    value = comment.value;
+	  if (type !== 'CommentBlock') {
+	    return;
+	  }
+	  var lines = value.split('\n');
+	  var lastTypedef = undefined;
+	  var _iterator = _createForOfIteratorHelper(lines),
+	    _step;
+	  try {
+	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	      var line = _step.value;
+	      line = line.trim();
+	      if (line[0] === '*') {
+	        line = line.slice(1).trim();
+	      }
+	      if (line.startsWith('@typedef')) {
+	        var _extractCurlyContent = extractCurlyContent(line),
+	          def = _extractCurlyContent.content,
+	          nextIndex = _extractCurlyContent.nextIndex;
+	        var name = line.substring(nextIndex).trim();
+	        name = name.split(' ')[0];
+	        lastTypedef = expandType(def);
+	        typedefs[name] = lastTypedef;
+	      } else if (line.startsWith('@property')) {
+	        var _lastTypedef;
+	        if (!lastTypedef) {
+	          continue;
+	        }
+	        var _extractCurlyContent2 = extractCurlyContent(line),
+	          content = _extractCurlyContent2.content,
+	          _nextIndex = _extractCurlyContent2.nextIndex;
+	        var rest = line.substring(_nextIndex);
+	        var propType = expandType(content);
+	        var _extractNameAndOption = extractNameAndOptionality(rest),
+	          _extractNameAndOption2 = _slicedToArray(_extractNameAndOption, 2),
+	          _name = _extractNameAndOption2[0],
+	          optional = _extractNameAndOption2[1];
+	        var finalType = simplifyType(propType, optional);
+	        if (((_lastTypedef = lastTypedef) === null || _lastTypedef === void 0 ? void 0 : _lastTypedef.type) === 'object') {
+	          lastTypedef.properties[_name] = finalType;
+	        } else {
+	          warn("not an extensible type", lastTypedef);
+	        }
+	      }
+	    }
+	  } catch (err) {
+	    _iterator.e(err);
+	  } finally {
+	    _iterator.f();
+	  }
+	}
+
+	function statReset(stat) {
+	  stat.checked = 0;
+	  stat.unchecked = 0;
+	}
+
+	var Stringifier = function () {
+	  function Stringifier() {
+	    _classCallCheck(this, Stringifier);
+	    _defineProperty(this, "forceCurly", false);
+	    _defineProperty(this, "parents", []);
+	  }
+	  _createClass(Stringifier, [{
+	    key: "toSource",
+	    value: function toSource(node) {
+	      var _node$extra;
+	      if (node === null) {
+	        return '';
+	      }
+	      if (node.type === 'File') {
+	        this.parents.length = 0;
+	      }
+	      this.parents.push(node);
+	      var out = '';
+	      var comments = '';
+	      if (node && node.leadingComments) {
+	        comments += this.mapToSource(node.leadingComments).join('');
+	      }
+	      if (node !== null && node !== void 0 && (_node$extra = node.extra) !== null && _node$extra !== void 0 && _node$extra.parenthesized) {
+	        out += "(".concat(comments).concat(this.toSource_(node), ")");
+	      } else {
+	        out += comments + this.toSource_(node);
+	      }
+	      this.parents.pop();
+	      return out;
+	    }
+	  }, {
+	    key: "toSource_",
+	    value: function toSource_(node) {
+	      if (!node) {
+	        return '';
+	      }
+	      var type = node.type;
+	      if (type === undefined) {
+	        console.log("toSource> node without type", node);
+	      }
+	      if (this[type]) {
+	        return this[type](node);
+	      }
+	      console.log(node);
+	      var notOfInterest = ["start", "end", "loc", "type"];
+	      var ofInterest = Object.keys(node).filter(function (_) {
+	        return !notOfInterest.includes(_);
+	      });
+	      var props = ofInterest.join(', ');
+	      var fn = "".concat(type, "(node) {\n  const {").concat(props, "} = node;\n  return ;\n}");
+	      console.warn('TODO ADD METHOD:', fn);
+	      return "rtiUnhandled(\"".concat(node.type, "\");\n");
+	    }
+	  }, {
+	    key: "toSourceCurly",
+	    value: function toSourceCurly(node) {
+	      if (!this.forceCurly) {
+	        return this.toSource(node);
+	      }
+	      var type = node.type;
+	      var needCurly = type != 'BlockStatement' && type != 'EmptyStatement';
+	      var spaces = this.spaces;
+	      var out = '';
+	      if (needCurly) {
+	        out += ' {\n';
+	      }
+	      out += this.toSource(node);
+	      if (needCurly) {
+	        out += '\n';
+	        out += spaces;
+	        out += '}';
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "parent",
+	    get: function get() {
+	      return this.parents[this.parents.length - 2];
+	    }
+	  }, {
+	    key: "parentType",
+	    get: function get() {
+	      var _this$parent;
+	      return (_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.type;
+	    }
+	  }, {
+	    key: "needSpaces",
+	    get: function get() {
+	      var t = this.parentType;
+	      return t != "ForStatement" && t != "ForInStatement" && t != "ForOfStatement";
+	    }
+	  }, {
+	    key: "mapToSource",
+	    value: function mapToSource(arr) {
+	      var _this = this;
+	      return arr.map(function (_) {
+	        return _this.toSource(_);
+	      });
+	    }
+	  }, {
+	    key: "generateTypeChecks",
+	    value: function generateTypeChecks(node) {
+	      var spaces = this.spaces;
+	      return "".concat(spaces, "/* Stub of Stringifier#generateTypeChecks({type=").concat(node.type, "}); */\n");
+	    }
+	  }, {
+	    key: "spaces",
+	    get: function get() {
+	      var _parents$, _parents$2;
+	      var parents = this.parents;
+	      var n = parents.length;
+	      if (((_parents$ = parents[0]) === null || _parents$ === void 0 ? void 0 : _parents$.type) == 'File') {
+	        n--;
+	      }
+	      if (((_parents$2 = parents[1]) === null || _parents$2 === void 0 ? void 0 : _parents$2.type) == 'Program') {
+	        n--;
+	      }
+	      n -= parents.filter(function (_) {
+	        return _.type === 'BlockStatement' || _.type === 'VariableDeclarator' || _.type === 'ObjectProperty' || _.type === 'ExportNamedDeclaration' || _.type === 'NewExpression' || _.type === 'AssignmentExpression' || _.type === 'ArrayExpression' || _.type === 'ClassBody';
+	      }).length;
+	      n -= 1;
+	      if (parents.some(function (_) {
+	        return _.type === 'CallExpression';
+	      }) && parents.some(function (_) {
+	        return _.type === 'ObjectExpression';
+	      })) {
+	        n--;
+	      }
+	      if (n < 0) {
+	        n = 0;
+	      }
+	      return '  '.repeat(n);
+	    }
+	  }, {
+	    key: "AwaitExpression",
+	    value: function AwaitExpression(node) {
+	      var argument = node.argument;
+	      return "await ".concat(this.toSource(argument));
+	    }
+	  }, {
+	    key: "ClassProperty",
+	    value: function ClassProperty(node) {
+	      var key = node.key,
+	        computed = node.computed,
+	        value = node.value;
+	        node.leadingComments;
+	      var static_ = node.static;
+	      var a = this.toSource(key);
+	      var b = this.toSource(value);
+	      var out = this.spaces;
+	      if (static_) {
+	        out += 'static ';
+	      }
+	      if (computed) {
+	        out += "[".concat(a, "]");
+	      } else {
+	        out += a;
+	      }
+	      if (b) {
+	        out += " = ".concat(b);
+	      }
+	      out += ';';
+	      return out;
+	    }
+	  }, {
+	    key: "FunctionDeclarationParams",
+	    value: function FunctionDeclarationParams(params) {
+	      return '(' + this.mapToSource(params).join(', ') + ')';
+	    }
+	  }, {
+	    key: "FunctionDeclaration",
+	    value: function FunctionDeclaration(node) {
+	      var async = node.async,
+	        body = node.body,
+	        generator = node.generator,
+	        id = node.id;
+	        node.leadingComments;
+	        var params = node.params;
+	      var out = '';
+	      if (this.parentType !== 'ExportNamedDeclaration') {
+	        out += this.spaces;
+	      }
+	      if (async) {
+	        out += 'async ';
+	      }
+	      var asterix = generator ? '*' : '';
+	      out += 'function' + asterix + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
+	      out += this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "FunctionExpression",
+	    value: function FunctionExpression(node) {
+	      var async = node.async,
+	        body = node.body,
+	        generator = node.generator,
+	        id = node.id,
+	        params = node.params;
+	      var out = '';
+	      if (async) {
+	        out += 'async ';
+	      }
+	      var star = generator ? '*' : '';
+	      out += 'function' + star + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
+	      out += this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "ArrowFunctionExpression",
+	    value: function ArrowFunctionExpression(node) {
+	      var async = node.async,
+	        body = node.body,
+	        generator = node.generator,
+	        params = node.params;
+	      var out = '';
+	      if (async) {
+	        out += 'async ';
+	      }
+	      if (generator) {
+	        out += ' * ';
+	      }
+	      out += this.FunctionDeclarationParams(params);
+	      out += ' => ';
+	      out += this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "BigIntLiteral",
+	    value: function BigIntLiteral(node) {
+	      var extra = node.extra;
+	        node.value;
+	      return extra.raw;
+	    }
+	  }, {
+	    key: "BlockStatement",
+	    value: function BlockStatement(node) {
+	      var body = node.body,
+	        directives = node.directives;
+	      var spaces = this.spaces;
+	      var out = '';
+	      out += ' {\n';
+	      if (directives && directives.length) {
+	        out += this.mapToSource(directives).join('\n') + '\n';
+	      }
+	      out += this.generateTypeChecks(node);
+	      out += this.mapToSource(body).join('\n') + '\n';
+	      out += spaces;
+	      out += '}';
+	      return out;
+	    }
+	  }, {
+	    key: "ClassExpression",
+	    value: function ClassExpression(node) {
+	      var id = node.id,
+	        superClass = node.superClass,
+	        body = node.body;
+	      var out = 'class ';
+	      if (id !== null) {
+	        out += this.toSource(id) + ' ';
+	      }
+	      if (superClass !== null) {
+	        var s = this.toSource(superClass);
+	        out += "extends ".concat(s, " ");
+	      }
+	      var c = this.toSource(body);
+	      out += "{\n".concat(c, "\n}");
+	      return out;
+	    }
+	  }, {
+	    key: "Directive",
+	    value: function Directive(node) {
+	      var value = node.value;
+	      return this.toSource(value);
+	    }
+	  }, {
+	    key: "DirectiveLiteral",
+	    value: function DirectiveLiteral(node) {
+	      var extra = node.extra;
+	        node.value;
+	      var spaces = this.spaces;
+	      return "".concat(spaces).concat(extra.raw, ";");
+	    }
+	  }, {
+	    key: "ReturnStatement",
+	    value: function ReturnStatement(node) {
+	      var argument = node.argument;
+	      var spaces = this.spaces;
+	      if (!argument) {
+	        return spaces + 'return;';
+	      }
+	      return spaces + 'return ' + this.toSource(argument) + ';';
+	    }
+	  }, {
+	    key: "Identifier",
+	    value: function Identifier(node) {
+	      return node.name;
+	    }
+	  }, {
+	    key: "IfStatement",
+	    value: function IfStatement(node) {
+	      var alternate = node.alternate,
+	        consequent = node.consequent,
+	        test = node.test;
+	      var spaces = this.spaces;
+	      var out = '';
+	      {
+	        out += spaces;
+	      }
+	      out += "if (".concat(this.toSource(test), ")");
+	      out += this.toSourceCurly(consequent);
+	      if (alternate) {
+	        out += " else".concat(this.toSourceCurly(alternate));
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "LabeledStatement",
+	    value: function LabeledStatement(node) {
+	      var body = node.body,
+	        label = node.label;
+	      var spaces = this.spaces;
+	      var out = '';
+	      out += spaces + this.toSource(label);
+	      out += ': \n';
+	      out += spaces + this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "UnaryExpression",
+	    value: function UnaryExpression(node) {
+	      var out = '';
+	      var argument = node.argument,
+	        operator = node.operator,
+	        prefix = node.prefix;
+	      if (!prefix) {
+	        console.warn("Stringifier#UnaryExpression> never considered !prefix", node);
+	      }
+	      var c = operator.charCodeAt(0);
+	      var op = operator;
+	      if (c >= 97 && c <= 122) {
+	        op += ' ';
+	      }
+	      out += op;
+	      out += this.toSource(argument);
+	      return out;
+	    }
+	  }, {
+	    key: "MemberExpression",
+	    value: function MemberExpression(node) {
+	      var computed = node.computed,
+	        object = node.object,
+	        property = node.property;
+	      if (computed) {
+	        return "".concat(this.toSource(object), "[").concat(this.toSource(property), "]");
+	      }
+	      return "".concat(this.toSource(object), ".").concat(this.toSource(property));
+	    }
+	  }, {
+	    key: "MetaProperty",
+	    value: function MetaProperty(node) {
+	      var meta = node.meta,
+	        property = node.property;
+	      var lhs = this.toSource(meta);
+	      var rhs = this.toSource(property);
+	      return "".concat(lhs, ".").concat(rhs);
+	    }
+	  }, {
+	    key: "ExpressionStatement",
+	    value: function ExpressionStatement(node) {
+	      var expression = node.expression;
+	      return this.spaces + this.toSource(expression) + ';';
+	    }
+	  }, {
+	    key: "CallExpression",
+	    value: function CallExpression(node) {
+	      var callee = node.callee,
+	        args = node.arguments,
+	        extra = node.extra;
+	      var out = this.toSource(callee);
+	      out += "(";
+	      out += this.mapToSource(args).join(', ');
+	      if (!!(extra !== null && extra !== void 0 && extra.trailingComma)) {
+	        out += ',';
+	      }
+	      out += ")";
+	      return out;
+	    }
+	  }, {
+	    key: "ObjectExpression",
+	    value: function ObjectExpression(node) {
+	      var properties = node.properties,
+	        extra = node.extra;
+	      var out = '{';
+	      if (properties.length) {
+	        var props = this.mapToSource(properties).join(',\n');
+	        out += '\n';
+	        out += props;
+	        if (extra !== null && extra !== void 0 && extra.trailingComma) {
+	          out += ',';
+	        }
+	        out += '\n';
+	        out += this.spaces.slice(2);
+	      }
+	      out += '}';
+	      return out;
+	    }
+	  }, {
+	    key: "ObjectProperty",
+	    value: function ObjectProperty(node) {
+	      var computed = node.computed,
+	        key = node.key,
+	        method = node.method,
+	        shorthand = node.shorthand,
+	        value = node.value;
+	      if (method) {
+	        console.warn("ObjectProperty> unhandled method property:", {
+	          method: method,
+	          shorthand: shorthand
+	        });
+	      }
+	      var spaces = this.spaces;
+	      var left = this.toSource(key);
+	      var right = this.toSource(value);
+	      var out = spaces;
+	      if (computed) {
+	        left = "[".concat(left, "]");
+	      }
+	      if (!shorthand) {
+	        out += left + ': ';
+	      }
+	      out += right;
+	      return out;
+	    }
+	  }, {
+	    key: "BooleanLiteral",
+	    value: function BooleanLiteral(node) {
+	      return node.value.toString();
+	    }
+	  }, {
+	    key: "AssignmentExpression",
+	    value: function AssignmentExpression(node) {
+	      var left = node.left,
+	        operator = node.operator,
+	        right = node.right;
+	      var left_ = this.toSource(left);
+	      var right_ = this.toSource(right);
+	      return "".concat(left_, " ").concat(operator, " ").concat(right_);
+	    }
+	  }, {
+	    key: "BinaryExpression",
+	    value: function BinaryExpression(node) {
+	      var left = node.left,
+	        operator = node.operator,
+	        right = node.right;
+	      var left_ = this.toSource(left);
+	      var right_ = this.toSource(right);
+	      return "".concat(left_, " ").concat(operator, " ").concat(right_);
+	    }
+	  }, {
+	    key: "ThisExpression",
+	    value: function ThisExpression(node) {
+	      return 'this';
+	    }
+	  }, {
+	    key: "ArrayExpression",
+	    value: function ArrayExpression(node) {
+	      var elements = node.elements,
+	        extra = node.extra;
+	      var e = !!(extra !== null && extra !== void 0 && extra.trailingComma) ? ',' : '';
+	      return '[' + this.mapToSource(elements).join(', ') + e + ']';
+	    }
+	  }, {
+	    key: "VariableDeclaration",
+	    value: function VariableDeclaration(node) {
+	      var declarations = node.declarations,
+	        kind = node.kind;
+	      var spaces = '';
+	      var semicolon = '';
+	      if (this.needSpaces) {
+	        semicolon = ';';
+	        spaces = this.spaces;
+	      }
+	      return "".concat(spaces).concat(kind, " ").concat(this.mapToSource(declarations).join(', ')).concat(semicolon);
+	    }
+	  }, {
+	    key: "VariableDeclarator",
+	    value: function VariableDeclarator(node) {
+	      var id = node.id,
+	        init = node.init;
+	      if (init) {
+	        return this.toSource(id) + ' = ' + this.toSource(init);
+	      }
+	      return this.toSource(id);
+	    }
+	  }, {
+	    key: "ConditionalExpression",
+	    value: function ConditionalExpression(node) {
+	      var alternate = node.alternate,
+	        consequent = node.consequent,
+	        test = node.test;
+	      return "".concat(this.toSource(test), " ? ").concat(this.toSource(consequent), " : ").concat(this.toSource(alternate));
+	    }
+	  }, {
+	    key: "LogicalExpression",
+	    value: function LogicalExpression(node) {
+	      var left = node.left,
+	        operator = node.operator,
+	        right = node.right;
+	      var l = this.toSource(left);
+	      var r = this.toSource(right);
+	      if (l === '') {
+	        console.warn("LogicalExpression> unhandled empty left", node);
+	      }
+	      if (r === '') {
+	        console.warn("LogicalExpression> unhandled empty right", node);
+	      }
+	      return "".concat(l, " ").concat(operator, " ").concat(r);
+	    }
+	  }, {
+	    key: "ForStatement",
+	    value: function ForStatement(node) {
+	      var init = node.init,
+	        test = node.test,
+	        update = node.update,
+	        body = node.body;
+	      var spaces = this.spaces;
+	      var i = this.toSource(init);
+	      var t = this.toSource(test);
+	      var u = this.toSource(update);
+	      var b = this.toSourceCurly(body);
+	      return "".concat(spaces, "for (").concat(i, "; ").concat(t, "; ").concat(u, ")").concat(b);
+	    }
+	  }, {
+	    key: "UpdateExpression",
+	    value: function UpdateExpression(node) {
+	      var operator = node.operator,
+	        prefix = node.prefix,
+	        argument = node.argument;
+	      if (prefix) {
+	        return "".concat(operator).concat(this.toSource(argument));
+	      } else {
+	        return "".concat(this.toSource(argument)).concat(operator);
+	      }
+	    }
+	  }, {
+	    key: "NewExpression",
+	    value: function NewExpression(node) {
+	      var callee = node.callee,
+	        args_ = node.arguments;
+	      var c = this.toSource(callee);
+	      var args = this.mapToSource(args_).join(', ');
+	      return "new ".concat(c, "(").concat(args, ")");
+	    }
+	  }, {
+	    key: "ClassDeclaration",
+	    value: function ClassDeclaration(node) {
+	      var id = node.id,
+	        superClass = node.superClass,
+	        body = node.body;
+	        node.trailingComments;
+	        node.leadingComments;
+	      var spaces = this.spaces;
+	      var out = spaces + 'class ' + this.toSource(id);
+	      if (superClass) {
+	        out += " extends ".concat(this.toSource(superClass));
+	      }
+	      out += ' {\n';
+	      out += this.toSource(body);
+	      out += spaces;
+	      out += '\n}\n';
+	      return out;
+	    }
+	  }, {
+	    key: "TemplateLiteral",
+	    value: function TemplateLiteral(node) {
+	      var expressions = node.expressions,
+	        quasis = node.quasis;
+	      var out = '`';
+	      for (var i = 0; i < quasis.length; i++) {
+	        out += this.toSource(quasis[i]);
+	        if (expressions[i]) {
+	          out += '${' + this.toSource(expressions[i]) + '}';
+	        }
+	      }
+	      out += '`';
+	      return out;
+	    }
+	  }, {
+	    key: "TemplateElement",
+	    value: function TemplateElement(node) {
+	      var value = node.value;
+	      return value.raw;
+	    }
+	  }, {
+	    key: "ContinueStatement",
+	    value: function ContinueStatement(node) {
+	      var label = node.label;
+	      var out = this.spaces + 'continue';
+	      if (label) {
+	        out += ' ' + this.toSource(label);
+	      }
+	      out += ';';
+	      return out;
+	    }
+	  }, {
+	    key: "ClassBody",
+	    value: function ClassBody(node) {
+	      var body = node.body;
+	      return this.mapToSource(body).join('\n');
+	    }
+	  }, {
+	    key: "ClassMethod",
+	    value: function ClassMethod(node) {
+	      var static_ = node.static,
+	        key = node.key,
+	        computed = node.computed,
+	        kind = node.kind,
+	        id = node.id,
+	        generator = node.generator,
+	        async = node.async,
+	        params = node.params,
+	        body = node.body;
+	      var out = this.spaces;
+	      if (generator) {
+	        out += '*';
+	      }
+	      if (id) {
+	        console.warn('Stringifier#ClassMethod> unhandled id', node);
+	      }
+	      if (static_) {
+	        out += 'static ';
+	      }
+	      if (async) {
+	        out += 'async ';
+	      }
+	      if (kind === 'get') {
+	        out += 'get ';
+	      } else if (kind === 'set') {
+	        out += 'set ';
+	      } else if (kind === 'constructor' || kind === 'method') ; else {
+	        console.warn("unhandled kind", kind, "for", node);
+	      }
+	      var methodName = this.toSource(key);
+	      if (computed) {
+	        methodName = "[".concat(methodName, "]");
+	      }
+	      out += methodName;
+	      out += "(".concat(this.mapToSource(params).join(', '), ")");
+	      out += this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "ExportAllDeclaration",
+	    value: function ExportAllDeclaration(node) {
+	      return "export * from ".concat(node.source.extra.raw, ";");
+	    }
+	  }, {
+	    key: "ExportNamedDeclaration",
+	    value: function ExportNamedDeclaration(node) {
+	      var _this2 = this;
+	      var declaration = node.declaration,
+	        source = node.source,
+	        specifiers = node.specifiers;
+	      var out = this.spaces;
+	      if (specifiers.length) {
+	        out += 'export {\n';
+	        out += this.mapToSource(specifiers).map(function (_) {
+	          return "  ".concat(_this2.spaces).concat(_);
+	        }).join(',\n');
+	        out += '\n';
+	        out += this.spaces;
+	        out += '}';
+	        if (source) {
+	          out += " from " + this.toSource(source);
+	        }
+	        out += ";\n";
+	      } else if (declaration) {
+	        out += 'export ' + this.toSource(declaration);
+	      } else {
+	        console.warn("ExportNamedDeclaration> unhandled case for", node);
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "ExportDefaultDeclaration",
+	    value: function ExportDefaultDeclaration(node) {
+	      var declaration = node.declaration;
+	      var a = this.toSource(declaration);
+	      return "export default ".concat(a, ";");
+	    }
+	  }, {
+	    key: "ExportSpecifier",
+	    value: function ExportSpecifier(node) {
+	      var exported = node.exported,
+	        local = node.local;
+	      var left = this.toSource(exported);
+	      var right = this.toSource(local);
+	      var spaces = this.spaces;
+	      if (left === right) {
+	        return "".concat(spaces).concat(left);
+	      }
+	      return "".concat(spaces).concat(right, " as ").concat(left);
+	    }
+	  }, {
+	    key: "Super",
+	    value: function Super(node) {
+	      return 'super';
+	    }
+	  }, {
+	    key: "ForInStatement",
+	    value: function ForInStatement(node) {
+	      var left = node.left,
+	        right = node.right,
+	        body = node.body;
+	      var spaces = this.spaces;
+	      var l = this.toSource(left);
+	      var r = this.toSource(right);
+	      var b = this.toSourceCurly(body);
+	      return "".concat(spaces, "for (").concat(l, " in ").concat(r, ")").concat(b);
+	    }
+	  }, {
+	    key: "ThrowStatement",
+	    value: function ThrowStatement(node) {
+	      var argument = node.argument;
+	      var spaces = this.spaces;
+	      var arg = this.toSource(argument);
+	      return "".concat(spaces, "throw ").concat(arg, ";");
+	    }
+	  }, {
+	    key: "WhileStatement",
+	    value: function WhileStatement(node) {
+	      var test = node.test,
+	        body = node.body;
+	      var spaces = this.spaces;
+	      var t = this.toSource(test);
+	      var b = this.toSourceCurly(body);
+	      return "".concat(spaces, "while (").concat(t, ")").concat(b);
+	    }
+	  }, {
+	    key: "BreakStatement",
+	    value: function BreakStatement(node) {
+	      var label = node.label;
+	      var out = this.spaces + 'break';
+	      if (label) {
+	        out += ' ' + this.toSource(label);
+	      }
+	      out += ';';
+	      return out;
+	    }
+	  }, {
+	    key: "ForOfStatement",
+	    value: function ForOfStatement(node) {
+	      var await_ = node.await,
+	        left = node.left,
+	        right = node.right,
+	        body = node.body;
+	      var spaces = this.spaces;
+	      var l = this.toSource(left);
+	      var r = this.toSource(right);
+	      var b = this.toSourceCurly(body);
+	      var a = await_ ? 'await ' : '';
+	      return "".concat(spaces, "for ").concat(a, "(").concat(l, " of ").concat(r, ")").concat(b);
+	    }
+	  }, {
+	    key: "ArrayPattern",
+	    value: function ArrayPattern(node) {
+	      var elements = node.elements;
+	      var e = this.mapToSource(elements).join(', ');
+	      return "[".concat(e, "]");
+	    }
+	  }, {
+	    key: "SwitchStatement",
+	    value: function SwitchStatement(node) {
+	      var discriminant = node.discriminant,
+	        cases = node.cases;
+	      var spaces = this.spaces;
+	      var out = '';
+	      out += spaces + "switch (".concat(this.toSource(discriminant), ") {\n");
+	      out += this.mapToSource(cases).join('\n') + '\n';
+	      out += spaces + '}';
+	      return out;
+	    }
+	  }, {
+	    key: "SwitchCase",
+	    value: function SwitchCase(node) {
+	      var consequent = node.consequent,
+	        test = node.test;
+	      var spaces = this.spaces;
+	      var c = this.mapToSource(consequent).join('\n');
+	      if (test) {
+	        var t = this.toSource(test);
+	        return "".concat(spaces, "case ").concat(t, ":\n").concat(c);
+	      }
+	      return "".concat(spaces, "default:\n").concat(c);
+	    }
+	  }, {
+	    key: "RegExpLiteral",
+	    value: function RegExpLiteral(node) {
+	      var extra = node.extra;
+	        node.value;
+	        node.pattern;
+	        node.flags;
+	      return extra.raw;
+	    }
+	  }, {
+	    key: "SequenceExpression",
+	    value: function SequenceExpression(node) {
+	      var expressions = node.expressions;
+	      return this.mapToSource(expressions).join(', ');
+	    }
+	  }, {
+	    key: "EmptyStatement",
+	    value: function EmptyStatement(node) {
+	      return ';';
+	    }
+	  }, {
+	    key: "SpreadElement",
+	    value: function SpreadElement(node) {
+	      var argument = node.argument;
+	      var a = this.toSource(argument);
+	      return "...".concat(a);
+	    }
+	  }, {
+	    key: "ObjectMethod",
+	    value: function ObjectMethod(node) {
+	      node.method;
+	        var key = node.key,
+	        computed = node.computed,
+	        kind = node.kind,
+	        id = node.id,
+	        generator = node.generator,
+	        async = node.async,
+	        params = node.params,
+	        body = node.body;
+	      if (id !== null) {
+	        console.warn("ObjectMethod> id !== null is unhandled", node);
+	        debugger;
+	      }
+	      var out = this.spaces;
+	      if (generator) {
+	        out += '*';
+	      }
+	      if (id) {
+	        console.warn('Stringifier#ClassMethod> unhandled id', node);
+	      }
+	      if (async) {
+	        out += 'async ';
+	      }
+	      if (kind === 'get') {
+	        out += 'get ';
+	      } else if (kind === 'set') {
+	        out += 'set ';
+	      } else if (kind === 'method') ; else {
+	        console.warn("unhandled kind", kind, "for", node);
+	      }
+	      var methodName = this.toSource(key);
+	      if (computed) {
+	        methodName = "[".concat(methodName, "]");
+	      }
+	      out += methodName;
+	      out += "(".concat(this.mapToSource(params).join(', '), ")");
+	      out += this.toSource(body);
+	      return out;
+	    }
+	  }, {
+	    key: "ObjectPattern",
+	    value: function ObjectPattern(node) {
+	      var properties = node.properties,
+	        extra = node.extra;
+	      var out = '{';
+	      if (properties.length) {
+	        out += '\n';
+	        out += this.mapToSource(properties).join(',\n');
+	        if (!!(extra !== null && extra !== void 0 && extra.trailingComma)) {
+	          out += ',';
+	        }
+	        out += '\n';
+	        out += this.spaces.slice(2);
+	      }
+	      out += '}';
+	      return out;
+	    }
+	  }, {
+	    key: "OptionalMemberExpression",
+	    value: function OptionalMemberExpression(node) {
+	      var object = node.object,
+	        computed = node.computed,
+	        property = node.property,
+	        optional = node.optional;
+	      var a = this.toSource(object);
+	      var b = this.toSource(property);
+	      if (!computed && !optional) {
+	        return "".concat(a, ".").concat(b);
+	      } else if (!computed && optional) {
+	        return "".concat(a, "?.").concat(b);
+	      } else if (computed && !optional) {
+	        return "".concat(a, "[").concat(b, "]");
+	      }
+	      return "".concat(a, "?.[").concat(b, "]");
+	    }
+	  }, {
+	    key: "OptionalCallExpression",
+	    value: function OptionalCallExpression(node) {
+	      var callee = node.callee,
+	        optional = node.optional,
+	        args = node.arguments;
+	      var a = this.toSource(callee);
+	      var b = this.mapToSource(args);
+	      if (optional) {
+	        return "".concat(a, "?.(").concat(b, ")");
+	      }
+	      return "".concat(a, "(").concat(b, ")");
+	    }
+	  }, {
+	    key: "DoWhileStatement",
+	    value: function DoWhileStatement(node) {
+	      var body = node.body,
+	        test = node.test;
+	        node.trailingComments;
+	      var spaces = this.spaces;
+	      var out = spaces;
+	      out += "do ";
+	      out += this.toSourceCurly(body);
+	      out += " while (".concat(this.toSource(test), ");");
+	      return out;
+	    }
+	  }, {
+	    key: "TryStatement",
+	    value: function TryStatement(node) {
+	      var block = node.block,
+	        handler = node.handler,
+	        finalizer = node.finalizer;
+	      var out = this.spaces;
+	      var b = this.toSource(block);
+	      out += "try ".concat(b);
+	      if (handler) {
+	        out += this.toSource(handler);
+	      }
+	      if (finalizer) {
+	        out += 'finally' + this.toSource(finalizer);
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "CatchClause",
+	    value: function CatchClause(node) {
+	      var param = node.param,
+	        body = node.body;
+	      var b = this.toSource(body);
+	      if (param) {
+	        var p = this.toSource(param);
+	        return " catch (".concat(p, ") ").concat(b);
+	      }
+	      return " catch ".concat(b);
+	    }
+	  }, {
+	    key: "RestElement",
+	    value: function RestElement(node) {
+	      var argument = node.argument;
+	      return "...".concat(this.toSource(argument));
+	    }
+	  }, {
+	    key: "DebuggerStatement",
+	    value: function DebuggerStatement(node) {
+	      return "".concat(this.spaces, "debugger;");
+	    }
+	  }, {
+	    key: "CommentBlock",
+	    value: function CommentBlock(node) {
+	      var value = node.value;
+	      var par = this.parents[this.parents.length - 3];
+	      var out = "".concat(this.spaces.slice(2), "/*").concat(value, "*/");
+	      if ((par === null || par === void 0 ? void 0 : par.type) === 'BlockStatement' || (par === null || par === void 0 ? void 0 : par.type) === 'Program') {
+	        return out + '\n';
+	      }
+	      return ' ' + out + ' ';
+	    }
+	  }, {
+	    key: "CommentLine",
+	    value: function CommentLine(node) {
+	      var value = node.value;
+	      return "".concat(this.spaces.slice(2), "//").concat(value, "\n");
+	    }
+	  }, {
+	    key: "Import",
+	    value: function Import(node) {
+	      return 'import';
+	    }
+	  }, {
+	    key: "ImportDeclaration",
+	    value: function ImportDeclaration(node) {
+	      var specifiers = node.specifiers,
+	        source = node.source;
+	      var a = this.mapToSource(specifiers).join(', ');
+	      var b = this.toSource(source);
+	      if (specifiers.length === 0) {
+	        return "import ".concat(b);
+	      }
+	      if (specifiers[0].type !== 'ImportSpecifier') {
+	        return "import ".concat(a, " from ").concat(b, ";");
+	      }
+	      return "import {".concat(a, "} from ").concat(b, ";");
+	    }
+	  }, {
+	    key: "ImportSpecifier",
+	    value: function ImportSpecifier(node) {
+	      var imported = node.imported,
+	        local = node.local;
+	      var a = this.toSource(imported);
+	      var b = this.toSource(local);
+	      if (a !== b) {
+	        return "".concat(a, " as ").concat(b);
+	      }
+	      return a;
+	    }
+	  }, {
+	    key: "ImportDefaultSpecifier",
+	    value: function ImportDefaultSpecifier(node) {
+	      var local = node.local;
+	      return this.toSource(local);
+	    }
+	  }, {
+	    key: "ImportNamespaceSpecifier",
+	    value: function ImportNamespaceSpecifier(node) {
+	      var local = node.local;
+	      return "* as ".concat(this.toSource(local));
+	    }
+	  }, {
+	    key: "File",
+	    value: function File(node) {
+	      return this.toSource(node.program) + '\n';
+	    }
+	  }, {
+	    key: "Program",
+	    value: function Program(node) {
+	      node.sourceType;
+	        node.interpreter;
+	        var body = node.body,
+	        directives = node.directives;
+	      var out = '';
+	      out += this.mapToSource(directives);
+	      out += this.mapToSource(body).join('\n');
+	      return out;
+	    }
+	  }, {
+	    key: "StringLiteral",
+	    value: function StringLiteral(node) {
+	      var extra = node.extra;
+	      if (!extra) {
+	        debugger;
+	        return '';
+	      }
+	      if (typeof extra.raw !== 'string') {
+	        debugger;
+	        return '';
+	      }
+	      return extra.raw;
+	    }
+	  }, {
+	    key: "NumericLiteral",
+	    value: function NumericLiteral(node) {
+	      return node.extra.raw;
+	    }
+	  }, {
+	    key: "AssignmentPattern",
+	    value: function AssignmentPattern(node) {
+	      var left = node.left,
+	        right = node.right;
+	      return "".concat(this.toSource(left), " = ").concat(this.toSource(right));
+	    }
+	  }, {
+	    key: "NullLiteral",
+	    value: function NullLiteral(node) {
+	      return 'null';
+	    }
+	  }, {
+	    key: "TaggedTemplateExpression",
+	    value: function TaggedTemplateExpression(node) {
+	      var tag = node.tag,
+	        quasi = node.quasi;
+	      var t = this.toSource(tag);
+	      var q = this.toSource(quasi);
+	      return t + q;
+	    }
+	  }, {
+	    key: "YieldExpression",
+	    value: function YieldExpression(node) {
+	      var delegate = node.delegate,
+	        argument = node.argument;
+	      var keyword = 'yield';
+	      if (delegate) {
+	        keyword += '*';
+	      }
+	      var a = this.toSource(argument);
+	      return "".concat(keyword, " ").concat(a);
+	    }
+	  }]);
+	  return Stringifier;
+	}();
+
+	var Asserter = function (_Stringifier) {
+	  _inherits(Asserter, _Stringifier);
+	  var _super = _createSuper(Asserter);
+	  function Asserter() {
+	    var _this;
+	    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+	      _ref$forceCurly = _ref.forceCurly,
+	      forceCurly = _ref$forceCurly === void 0 ? true : _ref$forceCurly,
+	      _ref$validateDivision = _ref.validateDivision,
+	      validateDivision = _ref$validateDivision === void 0 ? true : _ref$validateDivision,
+	      _ref$expandType = _ref.expandType,
+	      expandType = _ref$expandType === void 0 ? expandTypeDepFree : _ref$expandType,
+	      filename = _ref.filename;
+	    _classCallCheck(this, Asserter);
+	    _this = _super.call(this);
+	    _defineProperty(_assertThisInitialized(_this), "stats", {
+	      'FunctionDeclaration': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'FunctionExpression': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'ArrowFunctionExpression': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'ClassMethod#constructor': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'ClassMethod#method': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'ClassMethod#set': {
+	        checked: 0,
+	        unchecked: 0
+	      },
+	      'ClassMethod#get': {
+	        checked: 0,
+	        unchecked: 0
+	      }
+	    });
+	    _defineProperty(_assertThisInitialized(_this), "typedefs", {});
+	    _this.forceCurly = forceCurly;
+	    _this.validateDivision = validateDivision;
+	    _this.expandType = expandType;
+	    _this.filename = filename;
+	    return _this;
+	  }
+	  _createClass(Asserter, [{
+	    key: "ArrowFunctionExpression",
+	    value: function ArrowFunctionExpression(node) {
+	      var async = node.async,
+	        body = node.body,
+	        generator = node.generator,
+	        params = node.params;
+	      var out = '';
+	      if (async) {
+	        out += 'async ';
+	      }
+	      if (generator) {
+	        out += ' * ';
+	      }
+	      out += this.FunctionDeclarationParams(params);
+	      out += ' =>';
+	      if (body.type === 'BlockStatement') {
+	        out += this.toSource(body);
+	      } else {
+	        out += ' {\n';
+	        out += this.generateTypeChecks(node);
+	        out += this.spaces + 'return ' + this.toSource(body) + ';\n';
+	        out += '}';
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "ClassDeclaration",
+	    value: function ClassDeclaration(node) {
+	      var id = node.id;
+	      var id_ = this.toSource(id);
+	      var out = _get(_getPrototypeOf(Asserter.prototype), "ClassDeclaration", this).call(this, node);
+	      out += "".concat(this.spaces, "registerClass(").concat(id_, ");");
+	      return out;
+	    }
+	  }, {
+	    key: "findParentOfType",
+	    value: function findParentOfType(node, type) {
+	      var currentIndex = this.parents.findLastIndex(function (_) {
+	        return _ == node;
+	      });
+	      return this.parents.findLast(function (_, i) {
+	        if (i > currentIndex) {
+	          return false;
+	        }
+	        return _.type === type;
+	      });
+	    }
+	  }, {
+	    key: "findParentOfTypeWithPredicate",
+	    value: function findParentOfTypeWithPredicate(node, type, predicate) {
+	      var parents = this.parents;
+	      var i = parents.findLastIndex(function (_) {
+	        return _ == node;
+	      });
+	      i--;
+	      while (i >= 0) {
+	        var parent = parents[i];
+	        if (predicate(parent)) {
+	          return;
+	        }
+	        if (parent.type === type) {
+	          return parent;
+	        }
+	        i--;
+	      }
+	    }
+	  }, {
+	    key: "warn",
+	    value: function warn() {
+	      var _console;
+	      if (this.filename) {
+	        console.warn("[WARN]", this.filename);
+	      }
+	      (_console = console).warn.apply(_console, arguments);
+	    }
+	  }, {
+	    key: "getJSDoc",
+	    value: function getJSDoc(node) {
+	      if (node.type === 'BlockStatement') {
+	        node = this.parent;
+	      }
+	      if (node.type === 'FunctionExpression') {
+	        if (node.leadingComments) {
+	          this.warn("Case of FunctionExpression containing its own leadingComments is not handled");
+	          return;
+	        }
+	        node = this.findParentOfType(node, 'ExpressionStatement');
+	        if (!node) {
+	          node = this.parents.findLast(function (_) {
+	            return _.type == 'VariableDeclaration';
+	          });
+	          if (!node) {
+	            return;
+	          }
+	        }
+	      }
+	      var _node = node,
+	        leadingComments = _node.leadingComments;
+	      if (!leadingComments) {
+	        if (node.type === 'FunctionDeclaration') {
+	          var exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
+	          leadingComments = exportNamedDeclaration === null || exportNamedDeclaration === void 0 ? void 0 : exportNamedDeclaration.leadingComments;
+	        }
+	        if (node.type === 'ArrowFunctionExpression') {
+	          var _tmp, _tmp2;
+	          var tmp = this.findParentOfType(node, 'VariableDeclaration');
+	          if (!((_tmp = tmp) !== null && _tmp !== void 0 && _tmp.leadingComments)) {
+	            function isFunc(node) {
+	              return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration';
+	            }
+	            tmp = this.findParentOfTypeWithPredicate(node, 'ExportNamedDeclaration', isFunc);
+	          }
+	          leadingComments = (_tmp2 = tmp) === null || _tmp2 === void 0 ? void 0 : _tmp2.leadingComments;
+	        }
+	      }
+	      if (leadingComments && leadingComments.length) {
+	        var lastComment = leadingComments[leadingComments.length - 1];
+	        if (lastComment.type == "CommentBlock") {
+	          if (lastComment.value.includes('@event')) {
+	            return;
+	          }
+	          if (node.type === 'ClassMethod' && node.kind === 'set') {
+	            var paramName = this.getNameOfParam(node.params[0]);
+	            if (node.params.length !== 1) {
+	              this.warn("getJSDoc> setters require exactly one argument");
+	            }
+	            return _defineProperty({}, paramName, parseJSDocSetter(lastComment.value, this.expandType));
+	          }
+	          return parseJSDoc(lastComment.value, this.expandType);
+	        }
+	      }
+	    }
+	  }, {
+	    key: "getNameOfParam",
+	    value: function getNameOfParam(param) {
+	      if (param.type === 'Identifier') {
+	        return param.name;
+	      } else if (param.type === 'AssignmentPattern') {
+	        if (param.left.type === 'Identifier') {
+	          return param.left.name;
+	        }
+	      }
+	      debugger;
+	      this.warn("unable to extra name from param in specified way - may contain too much information");
+	      return this.toSource(param);
+	    }
+	  }, {
+	    key: "statsReset",
+	    value: function statsReset() {
+	      Object.values(this.stats).forEach(statReset);
+	    }
+	  }, {
+	    key: "statsPrint",
+	    value: function statsPrint() {
+	      console.table(this.stats);
+	    }
+	  }, {
+	    key: "getStatsForNode",
+	    value: function getStatsForNode(node) {
+	      var parentType = this.parentType,
+	        stats = this.stats;
+	      if (parentType == 'ClassMethod') {
+	        var kind = this.parent.kind;
+	        return stats["ClassMethod#".concat(kind)];
+	      } else if (node.type === 'ArrowFunctionExpression') {
+	        return stats.ArrowFunctionExpression;
+	      }
+	      var stat = stats[parentType];
+	      if (!stat) {
+	        this.warn("getStatsForNode> dummy, but unhandled... fix for node type", node);
+	        return {
+	          checked: 0,
+	          unchecked: 0
+	        };
+	      }
+	      return stat;
+	    }
+	  }, {
+	    key: "nodeHasParamName",
+	    value: function nodeHasParamName(node, name) {
+	      if (node.type === 'BlockStatement') {
+	        node = this.parent;
+	      }
+	      var _node2 = node,
+	        params = _node2.params;
+	      if (!params) {
+	        this.warn("nodeHasParamName> Expected params for", {
+	          node: node,
+	          name: name
+	        });
+	        return false;
+	      }
+	      return params.some(function (node) {
+	        var type = node.type;
+	        if (type === "AssignmentPattern") {
+	          var left = node.left;
+	          console.assert(left.type === 'Identifier' || left.type === 'ObjectPattern' || left.type === 'ArrayPattern' || left.type === 'AssignmentPattern', 'Expected Identifier or ObjectPattern');
+	          return left.name === name;
+	        } else if (type === 'Identifier') {
+	          return node.name === name;
+	        } else if (type === 'ArrayPattern' || type === 'ObjectPattern' || type === 'RestElement') {
+	          return false;
+	        } else {
+	          var _ = new Stringifier();
+	          var code = _.toSource(node);
+	          console.log("Unknown type to test params for", type, code);
+	        }
+	        return false;
+	      });
+	    }
+	  }, {
+	    key: "generateTypeChecks",
+	    value: function generateTypeChecks(node) {
+	      var _this2 = this;
+	      var parentType = this.parentType;
+	      if (node.type === 'BlockStatement' && parentType != 'FunctionDeclaration' && parentType != 'ClassMethod' && parentType != 'FunctionExpression') {
+	        return '';
+	      }
+	      var jsdoc = this.getJSDoc(node);
+	      var stat = this.getStatsForNode(node);
+	      if (!jsdoc) {
+	        stat.unchecked++;
+	        return '';
+	      }
+	      stat.checked++;
+	      var spaces = this.spaces;
+	      if (node.type !== 'ArrowFunctionExpression') {
+	        spaces += '  ';
+	      }
+	      var out = '';
+	      var _loop = function _loop(name) {
+	          var type = jsdoc[name];
+	          var hasParam = _this2.nodeHasParamName(node, name);
+	          if (!hasParam) {
+	            var testNode = node;
+	            if (node.type === 'BlockStatement') {
+	              testNode = _this2.parent;
+	            }
+	            var paramIndex = Object.keys(jsdoc).findIndex(function (_) {
+	              return _ === name;
+	            });
+	            var param = testNode.params[paramIndex];
+	            if (param) {
+	              var isObjectPattern = param.type === 'ObjectPattern';
+	              var isArrayPattern = param.type === 'ArrayPattern';
+	              var isSupportedPattern = isObjectPattern || isArrayPattern;
+	              if (isSupportedPattern) {
+	                name = "arguments[".concat(paramIndex, "]");
+	              } else if (param.type === 'AssignmentPattern') {
+	                var _loc = _this2.getName(node);
+	                if (param.left.type === 'ArrayPattern' && type.type === 'array') {
+	                  var _iterator = _createForOfIteratorHelper(param.left.elements),
+	                    _step;
+	                  try {
+	                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	                      var element = _step.value;
+	                      if (element.type !== 'Identifier') {
+	                        _this2.warn('Only Identifier case handled right now');
+	                        continue;
+	                      }
+	                      var _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
+	                      out += "".concat(spaces, "if (!assertType(").concat(element.name, ", ").concat(_t, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
+	                    }
+	                  } catch (err) {
+	                    _iterator.e(err);
+	                  } finally {
+	                    _iterator.f();
+	                  }
+	                  return 0;
+	                } else if (param.left.type === 'ObjectPattern' && type.type === 'object') {
+	                  var _iterator2 = _createForOfIteratorHelper(param.left.properties),
+	                    _step2;
+	                  try {
+	                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	                      var property = _step2.value;
+	                      if (property.key.type !== 'Identifier') {
+	                        _this2.warn('ObjectPattern> Only Identifier case handled right now');
+	                        continue;
+	                      }
+	                      var keyName = property.key.name;
+	                      var subType = type.properties[keyName];
+	                      if (!subType) {
+	                        _this2.warn("missing subtype information in JSDoc");
+	                        continue;
+	                      }
+	                      var _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
+	                      out += "".concat(spaces, "if (!assertType(").concat(keyName, ", ").concat(_t2, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
+	                    }
+	                  } catch (err) {
+	                    _iterator2.e(err);
+	                  } finally {
+	                    _iterator2.f();
+	                  }
+	                  return 0;
+	                }
+	                _this2.warn("generateTypeChecks> ".concat(_loc, "> todo implement"), "AssignmentPattern for parameter ".concat(name));
+	                return 0;
+	              }
+	            } else {
+	              var _loc2 = _this2.getName(node);
+	              _this2.warn("generateTypeChecks> ".concat(_loc2, "> Missing param: ").concat(name));
+	              return 0;
+	            }
+	          }
+	          var t = JSON.stringify(type, null, 2).replaceAll('\n', '\n' + spaces);
+	          if (type === 'this') {
+	            var classDecl = _this2.findParentOfType(node, 'ClassDeclaration');
+	            if (!(classDecl !== null && classDecl !== void 0 && classDecl.id)) {
+	              _this2.warn('generateTypeChecks> !classDecl?.id');
+	            }
+	            t = '"' + _this2.toSource(classDecl.id) + '"';
+	          }
+	          var loc = _this2.getName(node);
+	          var prevCheck = '';
+	          if (loc === 'ContactPoint#constructor' || loc === 'ContactResult#constructor' || loc === 'SingleContactResult#constructor') {
+	            prevCheck = 'arguments.length !== 0 && ';
+	          }
+	          out += "".concat(spaces, "if (").concat(prevCheck, "!assertType(").concat(name, ", ").concat(t, ", '").concat(loc, "', '").concat(name, "')) {\n");
+	          out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
+	        },
+	        _ret;
+	      for (var name in jsdoc) {
+	        _ret = _loop(name);
+	        if (_ret === 0) continue;
+	      }
+	      return out;
+	    }
+	  }, {
+	    key: "getName",
+	    value: function getName(node) {
+	      var toSource = this.toSource.bind(this);
+	      if (node.type === 'BlockStatement') {
+	        node = this.parent;
+	      }
+	      var _node3 = node,
+	        type = _node3.type,
+	        key = _node3.key,
+	        id = _node3.id;
+	      switch (type) {
+	        case 'FunctionDeclaration':
+	          return toSource(id);
+	        case "ClassMethod":
+	          var classDecl = this.parents.findLast(function (_) {
+	            return _.type == 'ClassDeclaration';
+	          });
+	          var out = '';
+	          if (classDecl) {
+	            out += toSource(classDecl.id) + '#';
+	          }
+	          out += toSource(key);
+	          return out;
+	        case 'FunctionExpression':
+	          if (id) {
+	            return toSource(id);
+	          }
+	          var expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
+	          if (!expressionStatement) {
+	            return "unnamed function expression";
+	          }
+	          return toSource(expressionStatement.expression.left);
+	        case 'ArrowFunctionExpression':
+	          var parent = this.findParentOfType(node, 'VariableDeclarator');
+	          if (parent) {
+	            return toSource(parent.id);
+	          } else {
+	            return "getName> missing parent for " + node.type;
+	          }
+	        default:
+	          this.warn("getName> unhandled type", type, "for", node);
+	          return '/*MISSING*/';
+	      }
+	    }
+	  }, {
+	    key: "BinaryExpression",
+	    value: function BinaryExpression(node) {
+	      if (!this.validateDivision) {
+	        return _get(_getPrototypeOf(Asserter.prototype), "BinaryExpression", this).call(this, node);
+	      }
+	      var left = node.left,
+	        operator = node.operator,
+	        right = node.right;
+	      var left_ = this.toSource(left);
+	      var right_ = this.toSource(right);
+	      if (operator === '/') {
+	        return "validateDivision(".concat(left_, ", ").concat(right_, ")");
+	      }
+	      return "".concat(left_, " ").concat(operator, " ").concat(right_);
+	    }
+	  }, {
+	    key: "File",
+	    value: function File(node) {
+	      node.errors;
+	        var program = node.program,
+	        comments = node.comments;
+	      if (comments) {
+	        var _iterator3 = _createForOfIteratorHelper(comments),
+	          _step3;
+	        try {
+	          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+	            var comment = _step3.value;
+	            var warn = this.warn.bind(this);
+	            parseJSDocTypedef(this.typedefs, warn, comment, this.expandType);
+	          }
+	        } catch (err) {
+	          _iterator3.e(err);
+	        } finally {
+	          _iterator3.f();
+	        }
+	      }
+	      var out = '';
+	      for (var name in this.typedefs) {
+	        var typedef = this.typedefs[name];
+	        var json = JSON.stringify(typedef, null, 2);
+	        out += "registerTypedef('".concat(name, "', ").concat(json, ");\n");
+	      }
+	      var code = this.toSource(program) + '\n';
+	      out += code;
+	      return out;
+	    }
+	  }]);
+	  return Asserter;
+	}(Stringifier);
+
+	function addTypeChecks(src, options) {
+	  try {
+	    var asserter = new Asserter(options);
+	    var ast = parser.parse(src, {
+	      sourceType: 'module'
+	    });
+	    var out = asserter.toSource(ast);
+	    return out;
+	  } catch (e) {
+	    console.error(e);
+	    return "/*<addTypeChecks-error>*/".concat(src, "/*</addTypeChecks-error>*/");
+	  }
+	}
+
+	function ast2json(ast) {
+	  return JSON.stringify(ast, function (name, val) {
+	    if (name == "loc" || name == "start" || name == "end") {
+	      return undefined;
+	    }
+	    return val;
+	  }, 2);
+	}
+
+	var drop = ['loc', 'start', 'end', 'leadingComments', 'trailingComments', 'innerComments', 'innerComments', 'comments'];
+	function ast2jsonForComparison(ast) {
+	  return JSON.stringify(ast, function (name, val) {
+	    if (name === 'trailingComma' || name === 'parenStart') {
+	      return 'offset removed for better comparison';
+	    }
+	    if (drop.includes(name)) {
+	      return undefined;
+	    }
+	    return val;
+	  }, 2);
+	}
+
+	function code2ast2code(code) {
+	  var stringifier = new Stringifier();
+	  var ast = parser.parse(code, {
+	    sourceType: 'module'
+	  });
+	  if (!ast) {
+	    return;
+	  }
+	  var out = stringifier.toSource(ast);
+	  return out;
+	}
+
+	function expandType(type) {
+	  var ast = parseType(type);
+	  return toSourceTS(ast);
+	}
+	function parseType(str) {
+	  if (str.startsWith('...')) {
+	    str = str.slice(3);
+	    str += '[]';
+	  }
+	  str = "type tmp = ".concat(str, ";");
+	  var ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true);
+	  return ast.statements[0].type;
+	}
+	function toSourceTS(node) {
+	  var typeArguments = node.typeArguments,
+	    typeName = node.typeName;
+	  var kind_ = ts.SyntaxKind[node.kind];
+	  var _ts$SyntaxKind = ts.SyntaxKind,
+	    AnyKeyword = _ts$SyntaxKind.AnyKeyword,
+	    ArrayType = _ts$SyntaxKind.ArrayType,
+	    BooleanKeyword = _ts$SyntaxKind.BooleanKeyword,
+	    FunctionType = _ts$SyntaxKind.FunctionType,
+	    Identifier = _ts$SyntaxKind.Identifier,
+	    IntersectionType = _ts$SyntaxKind.IntersectionType,
+	    JSDocAllType = _ts$SyntaxKind.JSDocAllType,
+	    LastTypeNode = _ts$SyntaxKind.LastTypeNode,
+	    LiteralType = _ts$SyntaxKind.LiteralType,
+	    NullKeyword = _ts$SyntaxKind.NullKeyword,
+	    NumberKeyword = _ts$SyntaxKind.NumberKeyword,
+	    NumericLiteral = _ts$SyntaxKind.NumericLiteral,
+	    ObjectKeyword = _ts$SyntaxKind.ObjectKeyword,
+	    Parameter = _ts$SyntaxKind.Parameter,
+	    ParenthesizedType = _ts$SyntaxKind.ParenthesizedType,
+	    PropertySignature = _ts$SyntaxKind.PropertySignature,
+	    StringKeyword = _ts$SyntaxKind.StringKeyword,
+	    StringLiteral = _ts$SyntaxKind.StringLiteral,
+	    ThisType = _ts$SyntaxKind.ThisType,
+	    TupleType = _ts$SyntaxKind.TupleType,
+	    TypeLiteral = _ts$SyntaxKind.TypeLiteral,
+	    TypeReference = _ts$SyntaxKind.TypeReference,
+	    UndefinedKeyword = _ts$SyntaxKind.UndefinedKeyword,
+	    UnionType = _ts$SyntaxKind.UnionType,
+	    JSDocNullableType = _ts$SyntaxKind.JSDocNullableType;
+	  switch (node.kind) {
+	    case FunctionType:
+	      var parameters = node.parameters.map(toSourceTS);
+	      return {
+	        type: 'function',
+	        parameters: parameters
+	      };
+	    case JSDocNullableType:
+	      var t = toSourceTS(node.type);
+	      return {
+	        type: 'union',
+	        members: [t, 'null']
+	      };
+	    case Parameter:
+	      var type = node.type ? toSourceTS(node.type) : 'any';
+	      var name = toSourceTS(node.name);
+	      var ret = {
+	        type: type,
+	        name: name
+	      };
+	      if (node.dotDotDotToken) {
+	        return {
+	          type: 'array',
+	          elementType: ret
+	        };
+	      }
+	      return ret;
+	    case TypeReference:
+	      if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 2) {
+	        return {
+	          type: 'record',
+	          key: toSourceTS(typeArguments[0]),
+	          val: toSourceTS(typeArguments[1])
+	        };
+	      } else if (typeName.text === 'Object' && (!typeArguments || (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 0)) {
+	        return {
+	          type: 'object',
+	          properties: {}
+	        };
+	      } else if (typeName.text === 'Map' && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 2) {
+	        return {
+	          type: 'map',
+	          key: toSourceTS(typeArguments[0]),
+	          val: toSourceTS(typeArguments[1])
+	        };
+	      } else if (typeName.text === 'Array' && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 1) {
+	        var elementType = toSourceTS(typeArguments[0]);
+	        return {
+	          type: 'array',
+	          elementType: elementType
+	        };
+	      } else if (typeName.text === 'Set' && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 1) {
+	        var _elementType = toSourceTS(typeArguments[0]);
+	        return {
+	          type: 'set',
+	          elementType: _elementType
+	        };
+	      } else if (typeName.text === 'Class' && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 1) {
+	        return {
+	          type: 'class',
+	          elementType: toSourceTS(typeArguments[0])
+	        };
+	      } else {
+	        if (!typeArguments) {
+	          return typeName.getText();
+	        }
+	        console.warn('unhandled TypeReference', kind_, node);
+	        return {
+	          type: 'unhandled TypeReference'
+	        };
+	      }
+	    case StringKeyword:
+	      return node.getText();
+	    case NumberKeyword:
+	      return node.getText();
+	    case IntersectionType:
+	      return {
+	        type: 'intersection',
+	        members: node.types.map(toSourceTS)
+	      };
+	    case TupleType:
+	      return {
+	        type: 'tuple',
+	        elements: node.elements.map(toSourceTS)
+	      };
+	    case UnionType:
+	      return {
+	        type: 'union',
+	        members: node.types.map(toSourceTS)
+	      };
+	    case TypeLiteral:
+	      var properties = {};
+	      node.members.forEach(function (member) {
+	        var name = toSourceTS(member.name);
+	        var type = toSourceTS(member.type);
+	        properties[name] = type;
+	      });
+	      return {
+	        type: 'object',
+	        properties: properties
+	      };
+	    case PropertySignature:
+	      console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
+	      return "".concat(toSourceTS(node.name), ": ").concat(toSourceTS(node.type));
+	    case Identifier:
+	      return node.text;
+	    case ArrayType:
+	      return {
+	        type: 'array',
+	        elementType: toSourceTS(node.elementType)
+	      };
+	    case LiteralType:
+	      return toSourceTS(node.literal);
+	    case AnyKeyword:
+	    case BooleanKeyword:
+	    case JSDocAllType:
+	    case NullKeyword:
+	    case NumericLiteral:
+	    case StringLiteral:
+	    case ThisType:
+	    case UndefinedKeyword:
+	      return node.getText();
+	    case ObjectKeyword:
+	      return {
+	        type: 'object',
+	        properties: {}
+	      };
+	    case ParenthesizedType:
+	      return toSourceTS(node.type);
+	    case LastTypeNode:
+	      return toSourceTS(node.qualifier);
+	    default:
+	      console.warn('toSourceTS> unhandled kind - make sure to understand you cannot reverse TS enums');
+	      console.warn('if they contain range aliases, for example:');
+	      console.warn('ts.SyntaxKind.NumericLiteral === ts.SyntaxKind.FirstLiteralToken');
+	      console.warn('so this "kind" could be wrong, but requires handling anyway:', kind_, node);
+	      debugger;
+	  }
+	}
+
+	exports.Asserter = Asserter;
+	exports.Stringifier = Stringifier;
+	exports.addTypeChecks = addTypeChecks;
+	exports.ast2json = ast2json;
+	exports.ast2jsonForComparison = ast2jsonForComparison;
+	exports.code2ast2code = code2ast2code;
+	exports.expandType = expandType;
+	exports.expandTypeDepFree = expandTypeDepFree;
+	exports.extractCurlyContent = extractCurlyContent;
+	exports.extractNameAndOptionality = extractNameAndOptionality;
+	exports.parseJSDoc = parseJSDoc;
+	exports.parseJSDocSetter = parseJSDocSetter;
+	exports.parseJSDocTypedef = parseJSDocTypedef;
+	exports.parseType = parseType;
+	exports.simplifyType = simplifyType;
+	exports.toSourceTS = toSourceTS;
+
+}));