runtime-type-inspector 2.0.2 → 2.0.3

package/build/rti-transpiler.mjs

@@ -0,0 +1,1979 @@
+import { parse } from '@babel/parser';
+import ts from 'typescript';
+
+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('>')) {
+    const typeSlice = type.slice(6, -1);
+    return {
+      type: "array",
+      elementType: expandTypeDepFree(typeSlice)
+    };
+  }
+  if ((type.startsWith("Object<") || type.startsWith("Record<")) && type.endsWith('>')) {
+    const recordSlice = type.slice(7, -1);
+    const firstComma = recordSlice.indexOf(',');
+    if (firstComma === -1) {
+      console.warn("expandTypeDepFree> invalid Object/Record");
+    }
+    const key = recordSlice.slice(0, firstComma).trim();
+    const val = recordSlice.slice(firstComma + 1).trim();
+    return {
+      type: "record",
+      key: expandTypeDepFree(key),
+      val: expandTypeDepFree(val)
+    };
+  }
+  if (type[0] == '{' && type[type.length - 1] == '}') {
+    const propertiesArray = type.slice(1, -1).split(',');
+    const properties = {};
+    propertiesArray.forEach(_ => {
+      const [propName, propType] = _.split(":").map(_ => _.trim());
+      if (!propName || !propType) {
+        console.warn('expandTypeDepFree> unexpected type format, fix');
+        return false;
+      }
+      properties[propName] = propType;
+    });
+    return {
+      type: 'object',
+      properties
+    };
+  }
+  const members = type.split("|");
+  if (members.length >= 2) {
+    members.forEach((_, i) => members[i] = _.trim());
+    return {
+      type: 'union',
+      members: members.map(expandTypeDepFree)
+    };
+  }
+  if (type.endsWith("[]")) {
+    const typeSlice = type.slice(0, -2);
+    return {
+      type: 'array',
+      elementType: expandTypeDepFree(typeSlice)
+    };
+  }
+  if (type[0] == '[' && type[type.length - 1] == ']') {
+    const 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,
+      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, expandType = expandTypeDepFree) {
+  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
+  const matches = [...src.matchAll(regex)];
+  const params = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    let name = _[2].trim();
+    let optional = false;
+    if (name[0] === '[') {
+      const closer = name.lastIndexOf(']');
+      name = name.substring(1, closer);
+      optional = true;
+    }
+    name = name.split(' ')[0].split('=')[0].trim();
+    const simplifiedType = simplifyType(type, optional);
+    const parts = name.split(".");
+    if (parts.length == 3) {
+      let parts0 = parts[0];
+      let parts1 = parts[1];
+      let parts2 = parts[2];
+      const toptype = params[parts0];
+      toptype.properties[parts1].properties = toptype.properties[parts1].properties || {};
+      toptype.properties[parts1].properties[parts2] = simplifiedType;
+    } else if (parts.length == 2) {
+      let parts0 = parts[0];
+      let parts1 = parts[1];
+      if (parts0.endsWith('[]')) {
+        parts0 = parts0.slice(0, -2);
+      }
+      const toptype = params[parts0];
+      if ((toptype == null ? void 0 : toptype.type) == "union") {
+        const typeObject = toptype.members.find(_ => (_ == null ? void 0 : _.type) == 'object');
+        typeObject.properties[parts1] = simplifiedType;
+      } else if ((toptype == null ? void 0 : toptype.type) == "array") {
+        toptype.elementType.properties[parts1] = simplifiedType;
+      } else if ((toptype == null ? void 0 : toptype.type) == "object") {
+        toptype.properties = toptype.properties || {};
+        toptype.properties[parts1] = simplifiedType;
+      } else {
+        console.warn("parseJSDoc> skipping @param, unseen syntax detected, please check if your JSDoc is valid or open an issue about this", {
+          src,
+          toptype,
+          parts0,
+          parts1,
+          simplifiedType
+        });
+      }
+    } else {
+      params[name] = simplifiedType;
+    }
+  });
+  if (Object.keys(params).length === 0) {
+    return;
+  }
+  return params;
+}
+
+function parseJSDocSetter(src, expandType = expandTypeDepFree) {
+  const regex = /@type \{(.*?)\}/g;
+  const matches = [...src.matchAll(regex)];
+  if (matches.length === 1) {
+    const match = matches[0];
+    const type = expandType(match[1]);
+    const simplifiedType = simplifyType(type, false);
+    return simplifiedType;
+  }
+}
+
+function extractNameAndOptionality(rest) {
+  rest = rest.trim();
+  let optional = false;
+  if (rest[0] === '[') {
+    const closer = rest.lastIndexOf(']');
+    rest = rest.substring(1, closer);
+    optional = true;
+  }
+  const name = rest.split(' ')[0].split('=')[0].trim();
+  return [name, optional];
+}
+
+function extractCurlyContent(line) {
+  const firstCurly = line.indexOf('{');
+  let k = firstCurly + 1;
+  let count = 0;
+  for (; k < line.length; k++) {
+    const c = line[k];
+    if (c === '{') {
+      count++;
+    } else if (c === '}') {
+      count--;
+    }
+    if (count === -1) {
+      break;
+    }
+  }
+  const content = line.substring(firstCurly + 1, k);
+  return {
+    content,
+    nextIndex: k + 1
+  };
+}
+function parseJSDocTypedef(typedefs, warn, comment, expandType) {
+  const {
+    type,
+    value
+  } = comment;
+  if (type !== 'CommentBlock') {
+    return;
+  }
+  const lines = value.split('\n');
+  let lastTypedef = undefined;
+  for (let line of lines) {
+    line = line.trim();
+    if (line[0] === '*') {
+      line = line.slice(1).trim();
+    }
+    if (line.startsWith('@typedef')) {
+      const {
+        content: def,
+        nextIndex
+      } = extractCurlyContent(line);
+      let 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;
+      }
+      const {
+        content,
+        nextIndex
+      } = extractCurlyContent(line);
+      const rest = line.substring(nextIndex);
+      const propType = expandType(content);
+      const [name, optional] = extractNameAndOptionality(rest);
+      const finalType = simplifyType(propType, optional);
+      if (((_lastTypedef = lastTypedef) == null ? void 0 : _lastTypedef.type) === 'object') {
+        lastTypedef.properties[name] = finalType;
+      } else {
+        warn("not an extensible type", lastTypedef);
+      }
+    }
+  }
+}
+
+function statReset(stat) {
+  stat.checked = 0;
+  stat.unchecked = 0;
+}
+
+class Stringifier {
+  constructor() {
+    this.forceCurly = false;
+    this.parents = [];
+  }
+  toSource(node) {
+    var _node$extra;
+    if (node === null) {
+      return '';
+    }
+    if (node.type === 'File') {
+      this.parents.length = 0;
+    }
+    this.parents.push(node);
+    let out = '';
+    let comments = '';
+    if (node && node.leadingComments) {
+      comments += this.mapToSource(node.leadingComments).join('');
+    }
+    if (node != null && (_node$extra = node.extra) != null && _node$extra.parenthesized) {
+      out += `(${comments}${this.toSource_(node)})`;
+    } else {
+      out += comments + this.toSource_(node);
+    }
+    this.parents.pop();
+    return out;
+  }
+  toSource_(node) {
+    if (!node) {
+      return '';
+    }
+    const {
+      type
+    } = node;
+    if (type === undefined) {
+      console.log("toSource> node without type", node);
+    }
+    if (this[type]) {
+      return this[type](node);
+    }
+    console.log(node);
+    const notOfInterest = ["start", "end", "loc", "type"];
+    const ofInterest = Object.keys(node).filter(_ => !notOfInterest.includes(_));
+    const props = ofInterest.join(', ');
+    const fn = `${type}(node) {\n  const {${props}} = node;\n  return ;\n}`;
+    console.warn('TODO ADD METHOD:', fn);
+    return `rtiUnhandled("${node.type}");\n`;
+  }
+  toSourceCurly(node) {
+    if (!this.forceCurly) {
+      return this.toSource(node);
+    }
+    const {
+      type
+    } = node;
+    const needCurly = type != 'BlockStatement' && type != 'EmptyStatement';
+    const spaces = this.spaces;
+    let out = '';
+    if (needCurly) {
+      out += ' {\n';
+    }
+    out += this.toSource(node);
+    if (needCurly) {
+      out += '\n';
+      out += spaces;
+      out += '}';
+    }
+    return out;
+  }
+  get parent() {
+    return this.parents[this.parents.length - 2];
+  }
+  get parentType() {
+    var _this$parent;
+    return (_this$parent = this.parent) == null ? void 0 : _this$parent.type;
+  }
+  get needSpaces() {
+    const t = this.parentType;
+    return t != "ForStatement" && t != "ForInStatement" && t != "ForOfStatement";
+  }
+  mapToSource(arr) {
+    return arr.map(_ => this.toSource(_));
+  }
+  generateTypeChecks(node) {
+    const {
+      spaces
+    } = this;
+    return `${spaces}/* Stub of Stringifier#generateTypeChecks({type=${node.type}}); */\n`;
+  }
+  get spaces() {
+    var _parents$, _parents$2;
+    const {
+      parents
+    } = this;
+    let n = parents.length;
+    if (((_parents$ = parents[0]) == null ? void 0 : _parents$.type) == 'File') {
+      n--;
+    }
+    if (((_parents$2 = parents[1]) == null ? void 0 : _parents$2.type) == 'Program') {
+      n--;
+    }
+    n -= parents.filter(_ => _.type === 'BlockStatement' || _.type === 'VariableDeclarator' || _.type === 'ObjectProperty' || _.type === 'ExportNamedDeclaration' || _.type === 'NewExpression' || _.type === 'AssignmentExpression' || _.type === 'ArrayExpression' || _.type === 'ClassBody').length;
+    n -= 1;
+    if (parents.some(_ => _.type === 'CallExpression') && parents.some(_ => _.type === 'ObjectExpression')) {
+      n--;
+    }
+    if (n < 0) {
+      n = 0;
+    }
+    return '  '.repeat(n);
+  }
+  AwaitExpression(node) {
+    const {
+      argument
+    } = node;
+    return `await ${this.toSource(argument)}`;
+  }
+  ClassProperty(node) {
+    const {
+      key,
+      computed,
+      value,
+      leadingComments
+    } = node;
+    const static_ = node.static;
+    const a = this.toSource(key);
+    const b = this.toSource(value);
+    let out = this.spaces;
+    if (static_) {
+      out += 'static ';
+    }
+    if (computed) {
+      out += `[${a}]`;
+    } else {
+      out += a;
+    }
+    if (b) {
+      out += ` = ${b}`;
+    }
+    out += ';';
+    return out;
+  }
+  FunctionDeclarationParams(params) {
+    return '(' + this.mapToSource(params).join(', ') + ')';
+  }
+  FunctionDeclaration(node) {
+    const {
+      async,
+      body,
+      generator,
+      id,
+      leadingComments,
+      params
+    } = node;
+    let out = '';
+    if (this.parentType !== 'ExportNamedDeclaration') {
+      out += this.spaces;
+    }
+    if (async) {
+      out += 'async ';
+    }
+    const asterix = generator ? '*' : '';
+    out += 'function' + asterix + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
+    out += this.toSource(body);
+    return out;
+  }
+  FunctionExpression(node) {
+    const {
+      async,
+      body,
+      generator,
+      id,
+      params
+    } = node;
+    let out = '';
+    if (async) {
+      out += 'async ';
+    }
+    const star = generator ? '*' : '';
+    out += 'function' + star + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
+    out += this.toSource(body);
+    return out;
+  }
+  ArrowFunctionExpression(node) {
+    const {
+      async,
+      body,
+      generator,
+      params
+    } = node;
+    let out = '';
+    if (async) {
+      out += 'async ';
+    }
+    if (generator) {
+      out += ' * ';
+    }
+    out += this.FunctionDeclarationParams(params);
+    out += ' => ';
+    out += this.toSource(body);
+    return out;
+  }
+  BigIntLiteral(node) {
+    const {
+      extra,
+      value
+    } = node;
+    return extra.raw;
+  }
+  BlockStatement(node) {
+    const {
+      body,
+      directives
+    } = node;
+    const spaces = this.spaces;
+    let 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;
+  }
+  ClassExpression(node) {
+    const {
+      id,
+      superClass,
+      body
+    } = node;
+    let out = 'class ';
+    if (id !== null) {
+      out += this.toSource(id) + ' ';
+    }
+    if (superClass !== null) {
+      const s = this.toSource(superClass);
+      out += `extends ${s} `;
+    }
+    const c = this.toSource(body);
+    out += `{\n${c}\n}`;
+    return out;
+  }
+  Directive(node) {
+    const {
+      value
+    } = node;
+    return this.toSource(value);
+  }
+  DirectiveLiteral(node) {
+    const {
+      extra,
+      value
+    } = node;
+    const {
+      spaces
+    } = this;
+    return `${spaces}${extra.raw};`;
+  }
+  ReturnStatement(node) {
+    const {
+      argument
+    } = node;
+    const {
+      spaces
+    } = this;
+    if (!argument) {
+      return spaces + 'return;';
+    }
+    return spaces + 'return ' + this.toSource(argument) + ';';
+  }
+  Identifier(node) {
+    return node.name;
+  }
+  IfStatement(node) {
+    const {
+      alternate,
+      consequent,
+      test
+    } = node;
+    const spaces = this.spaces;
+    let out = '';
+    {
+      out += spaces;
+    }
+    out += `if (${this.toSource(test)})`;
+    out += this.toSourceCurly(consequent);
+    if (alternate) {
+      out += ` else${this.toSourceCurly(alternate)}`;
+    }
+    return out;
+  }
+  LabeledStatement(node) {
+    const {
+      body,
+      label
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = '';
+    out += spaces + this.toSource(label);
+    out += ': \n';
+    out += spaces + this.toSource(body);
+    return out;
+  }
+  UnaryExpression(node) {
+    let out = '';
+    const {
+      argument,
+      operator,
+      prefix
+    } = node;
+    if (!prefix) {
+      console.warn("Stringifier#UnaryExpression> never considered !prefix", node);
+    }
+    const c = operator.charCodeAt(0);
+    let op = operator;
+    if (c >= 97 && c <= 122) {
+      op += ' ';
+    }
+    out += op;
+    out += this.toSource(argument);
+    return out;
+  }
+  MemberExpression(node) {
+    const {
+      computed,
+      object,
+      property
+    } = node;
+    if (computed) {
+      return `${this.toSource(object)}[${this.toSource(property)}]`;
+    }
+    return `${this.toSource(object)}.${this.toSource(property)}`;
+  }
+  MetaProperty(node) {
+    const {
+      meta,
+      property
+    } = node;
+    const lhs = this.toSource(meta);
+    const rhs = this.toSource(property);
+    return `${lhs}.${rhs}`;
+  }
+  ExpressionStatement(node) {
+    const {
+      expression
+    } = node;
+    return this.spaces + this.toSource(expression) + ';';
+  }
+  CallExpression(node) {
+    const {
+      callee,
+      arguments: args,
+      extra
+    } = node;
+    let out = this.toSource(callee);
+    out += "(";
+    out += this.mapToSource(args).join(', ');
+    if (!!(extra != null && extra.trailingComma)) {
+      out += ',';
+    }
+    out += ")";
+    return out;
+  }
+  ObjectExpression(node) {
+    const {
+      properties,
+      extra
+    } = node;
+    let out = '{';
+    if (properties.length) {
+      const props = this.mapToSource(properties).join(',\n');
+      out += '\n';
+      out += props;
+      if (extra != null && extra.trailingComma) {
+        out += ',';
+      }
+      out += '\n';
+      out += this.spaces.slice(2);
+    }
+    out += '}';
+    return out;
+  }
+  ObjectProperty(node) {
+    const {
+      computed,
+      key,
+      method,
+      shorthand,
+      value
+    } = node;
+    if (method) {
+      console.warn("ObjectProperty> unhandled method property:", {
+        method,
+        shorthand
+      });
+    }
+    const spaces = this.spaces;
+    let left = this.toSource(key);
+    const right = this.toSource(value);
+    let out = spaces;
+    if (computed) {
+      left = `[${left}]`;
+    }
+    if (!shorthand) {
+      out += left + ': ';
+    }
+    out += right;
+    return out;
+  }
+  BooleanLiteral(node) {
+    return node.value.toString();
+  }
+  AssignmentExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const left_ = this.toSource(left);
+    const right_ = this.toSource(right);
+    return `${left_} ${operator} ${right_}`;
+  }
+  BinaryExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const left_ = this.toSource(left);
+    const right_ = this.toSource(right);
+    return `${left_} ${operator} ${right_}`;
+  }
+  ThisExpression(node) {
+    return 'this';
+  }
+  ArrayExpression(node) {
+    const {
+      elements,
+      extra
+    } = node;
+    const e = !!(extra != null && extra.trailingComma) ? ',' : '';
+    return '[' + this.mapToSource(elements).join(', ') + e + ']';
+  }
+  VariableDeclaration(node) {
+    const {
+      declarations,
+      kind
+    } = node;
+    let spaces = '';
+    let semicolon = '';
+    if (this.needSpaces) {
+      semicolon = ';';
+      spaces = this.spaces;
+    }
+    return `${spaces}${kind} ${this.mapToSource(declarations).join(', ')}${semicolon}`;
+  }
+  VariableDeclarator(node) {
+    const {
+      id,
+      init
+    } = node;
+    if (init) {
+      return this.toSource(id) + ' = ' + this.toSource(init);
+    }
+    return this.toSource(id);
+  }
+  ConditionalExpression(node) {
+    const {
+      alternate,
+      consequent,
+      test
+    } = node;
+    return `${this.toSource(test)} ? ${this.toSource(consequent)} : ${this.toSource(alternate)}`;
+  }
+  LogicalExpression(node) {
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const l = this.toSource(left);
+    const r = this.toSource(right);
+    if (l === '') {
+      console.warn("LogicalExpression> unhandled empty left", node);
+    }
+    if (r === '') {
+      console.warn("LogicalExpression> unhandled empty right", node);
+    }
+    return `${l} ${operator} ${r}`;
+  }
+  ForStatement(node) {
+    const {
+      init,
+      test,
+      update,
+      body
+    } = node;
+    const spaces = this.spaces;
+    const i = this.toSource(init);
+    const t = this.toSource(test);
+    const u = this.toSource(update);
+    const b = this.toSourceCurly(body);
+    return `${spaces}for (${i}; ${t}; ${u})${b}`;
+  }
+  UpdateExpression(node) {
+    const {
+      operator,
+      prefix,
+      argument
+    } = node;
+    if (prefix) {
+      return `${operator}${this.toSource(argument)}`;
+    } else {
+      return `${this.toSource(argument)}${operator}`;
+    }
+  }
+  NewExpression(node) {
+    const {
+      callee,
+      arguments: args_
+    } = node;
+    const c = this.toSource(callee);
+    const args = this.mapToSource(args_).join(', ');
+    return `new ${c}(${args})`;
+  }
+  ClassDeclaration(node) {
+    const {
+      id,
+      superClass,
+      body,
+      trailingComments,
+      leadingComments
+    } = node;
+    const spaces = this.spaces;
+    let out = spaces + 'class ' + this.toSource(id);
+    if (superClass) {
+      out += ` extends ${this.toSource(superClass)}`;
+    }
+    out += ' {\n';
+    out += this.toSource(body);
+    out += spaces;
+    out += '\n}\n';
+    return out;
+  }
+  TemplateLiteral(node) {
+    const {
+      expressions,
+      quasis
+    } = node;
+    let 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;
+  }
+  TemplateElement(node) {
+    const {
+      value
+    } = node;
+    return value.raw;
+  }
+  ContinueStatement(node) {
+    const {
+      label
+    } = node;
+    let out = this.spaces + 'continue';
+    if (label) {
+      out += ' ' + this.toSource(label);
+    }
+    out += ';';
+    return out;
+  }
+  ClassBody(node) {
+    const {
+      body
+    } = node;
+    return this.mapToSource(body).join('\n');
+  }
+  ClassMethod(node) {
+    const {
+      static: static_,
+      key,
+      computed,
+      kind,
+      id,
+      generator,
+      async,
+      params,
+      body
+    } = node;
+    let 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);
+    }
+    let methodName = this.toSource(key);
+    if (computed) {
+      methodName = `[${methodName}]`;
+    }
+    out += methodName;
+    out += `(${this.mapToSource(params).join(', ')})`;
+    out += this.toSource(body);
+    return out;
+  }
+  ExportAllDeclaration(node) {
+    return `export * from ${node.source.extra.raw};`;
+  }
+  ExportNamedDeclaration(node) {
+    const {
+      declaration,
+      source,
+      specifiers
+    } = node;
+    let out = this.spaces;
+    if (specifiers.length) {
+      out += 'export {\n';
+      out += this.mapToSource(specifiers).map(_ => `  ${this.spaces}${_}`).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;
+  }
+  ExportDefaultDeclaration(node) {
+    const {
+      declaration
+    } = node;
+    const a = this.toSource(declaration);
+    return `export default ${a};`;
+  }
+  ExportSpecifier(node) {
+    const {
+      exported,
+      local
+    } = node;
+    const left = this.toSource(exported);
+    const right = this.toSource(local);
+    const {
+      spaces
+    } = this;
+    if (left === right) {
+      return `${spaces}${left}`;
+    }
+    return `${spaces}${right} as ${left}`;
+  }
+  Super(node) {
+    return 'super';
+  }
+  ForInStatement(node) {
+    const {
+      left,
+      right,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    const l = this.toSource(left);
+    const r = this.toSource(right);
+    const b = this.toSourceCurly(body);
+    return `${spaces}for (${l} in ${r})${b}`;
+  }
+  ThrowStatement(node) {
+    const {
+      argument
+    } = node;
+    const {
+      spaces
+    } = this;
+    const arg = this.toSource(argument);
+    return `${spaces}throw ${arg};`;
+  }
+  WhileStatement(node) {
+    const {
+      test,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    const t = this.toSource(test);
+    const b = this.toSourceCurly(body);
+    return `${spaces}while (${t})${b}`;
+  }
+  BreakStatement(node) {
+    const {
+      label
+    } = node;
+    let out = this.spaces + 'break';
+    if (label) {
+      out += ' ' + this.toSource(label);
+    }
+    out += ';';
+    return out;
+  }
+  ForOfStatement(node) {
+    const {
+      await: await_,
+      left,
+      right,
+      body
+    } = node;
+    const {
+      spaces
+    } = this;
+    const l = this.toSource(left);
+    const r = this.toSource(right);
+    const b = this.toSourceCurly(body);
+    const a = await_ ? 'await ' : '';
+    return `${spaces}for ${a}(${l} of ${r})${b}`;
+  }
+  ArrayPattern(node) {
+    const {
+      elements
+    } = node;
+    const e = this.mapToSource(elements).join(', ');
+    return `[${e}]`;
+  }
+  SwitchStatement(node) {
+    const {
+      discriminant,
+      cases
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = '';
+    out += spaces + `switch (${this.toSource(discriminant)}) {\n`;
+    out += this.mapToSource(cases).join('\n') + '\n';
+    out += spaces + '}';
+    return out;
+  }
+  SwitchCase(node) {
+    const {
+      consequent,
+      test
+    } = node;
+    const {
+      spaces
+    } = this;
+    const c = this.mapToSource(consequent).join('\n');
+    if (test) {
+      const t = this.toSource(test);
+      return `${spaces}case ${t}:\n${c}`;
+    }
+    return `${spaces}default:\n${c}`;
+  }
+  RegExpLiteral(node) {
+    const {
+      extra,
+      value,
+      pattern,
+      flags
+    } = node;
+    return extra.raw;
+  }
+  SequenceExpression(node) {
+    const {
+      expressions
+    } = node;
+    return this.mapToSource(expressions).join(', ');
+  }
+  EmptyStatement(node) {
+    return ';';
+  }
+  SpreadElement(node) {
+    const {
+      argument
+    } = node;
+    const a = this.toSource(argument);
+    return `...${a}`;
+  }
+  ObjectMethod(node) {
+    const {
+      method,
+      key,
+      computed,
+      kind,
+      id,
+      generator,
+      async,
+      params,
+      body
+    } = node;
+    if (id !== null) {
+      console.warn("ObjectMethod> id !== null is unhandled", node);
+      debugger;
+    }
+    let 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);
+    }
+    let methodName = this.toSource(key);
+    if (computed) {
+      methodName = `[${methodName}]`;
+    }
+    out += methodName;
+    out += `(${this.mapToSource(params).join(', ')})`;
+    out += this.toSource(body);
+    return out;
+  }
+  ObjectPattern(node) {
+    const {
+      properties,
+      extra
+    } = node;
+    let out = '{';
+    if (properties.length) {
+      out += '\n';
+      out += this.mapToSource(properties).join(',\n');
+      if (!!(extra != null && extra.trailingComma)) {
+        out += ',';
+      }
+      out += '\n';
+      out += this.spaces.slice(2);
+    }
+    out += '}';
+    return out;
+  }
+  OptionalMemberExpression(node) {
+    const {
+      object,
+      computed,
+      property,
+      optional
+    } = node;
+    const a = this.toSource(object);
+    const b = this.toSource(property);
+    if (!computed && !optional) {
+      return `${a}.${b}`;
+    } else if (!computed && optional) {
+      return `${a}?.${b}`;
+    } else if (computed && !optional) {
+      return `${a}[${b}]`;
+    }
+    return `${a}?.[${b}]`;
+  }
+  OptionalCallExpression(node) {
+    const {
+      callee,
+      optional,
+      arguments: args
+    } = node;
+    const a = this.toSource(callee);
+    const b = this.mapToSource(args);
+    if (optional) {
+      return `${a}?.(${b})`;
+    }
+    return `${a}(${b})`;
+  }
+  DoWhileStatement(node) {
+    const {
+      body,
+      test,
+      trailingComments
+    } = node;
+    const {
+      spaces
+    } = this;
+    let out = spaces;
+    out += "do ";
+    out += this.toSourceCurly(body);
+    out += ` while (${this.toSource(test)});`;
+    return out;
+  }
+  TryStatement(node) {
+    const {
+      block,
+      handler,
+      finalizer
+    } = node;
+    let out = this.spaces;
+    const b = this.toSource(block);
+    out += `try ${b}`;
+    if (handler) {
+      out += this.toSource(handler);
+    }
+    if (finalizer) {
+      out += 'finally' + this.toSource(finalizer);
+    }
+    return out;
+  }
+  CatchClause(node) {
+    const {
+      param,
+      body
+    } = node;
+    const b = this.toSource(body);
+    if (param) {
+      const p = this.toSource(param);
+      return ` catch (${p}) ${b}`;
+    }
+    return ` catch ${b}`;
+  }
+  RestElement(node) {
+    const {
+      argument
+    } = node;
+    return `...${this.toSource(argument)}`;
+  }
+  DebuggerStatement(node) {
+    return `${this.spaces}debugger;`;
+  }
+  CommentBlock(node) {
+    const {
+      value
+    } = node;
+    const par = this.parents[this.parents.length - 3];
+    const out = `${this.spaces.slice(2)}/*${value}*/`;
+    if ((par == null ? void 0 : par.type) === 'BlockStatement' || (par == null ? void 0 : par.type) === 'Program') {
+      return out + '\n';
+    }
+    return ' ' + out + ' ';
+  }
+  CommentLine(node) {
+    const {
+      value
+    } = node;
+    return `${this.spaces.slice(2)}//${value}\n`;
+  }
+  Import(node) {
+    return 'import';
+  }
+  ImportDeclaration(node) {
+    const {
+      specifiers,
+      source
+    } = node;
+    const a = this.mapToSource(specifiers).join(', ');
+    const b = this.toSource(source);
+    if (specifiers.length === 0) {
+      return `import ${b}`;
+    }
+    if (specifiers[0].type !== 'ImportSpecifier') {
+      return `import ${a} from ${b};`;
+    }
+    return `import {${a}} from ${b};`;
+  }
+  ImportSpecifier(node) {
+    const {
+      imported,
+      local
+    } = node;
+    const a = this.toSource(imported);
+    const b = this.toSource(local);
+    if (a !== b) {
+      return `${a} as ${b}`;
+    }
+    return a;
+  }
+  ImportDefaultSpecifier(node) {
+    const {
+      local
+    } = node;
+    return this.toSource(local);
+  }
+  ImportNamespaceSpecifier(node) {
+    const {
+      local
+    } = node;
+    return `* as ${this.toSource(local)}`;
+  }
+  File(node) {
+    return this.toSource(node.program) + '\n';
+  }
+  Program(node) {
+    const {
+      sourceType,
+      interpreter,
+      body,
+      directives
+    } = node;
+    let out = '';
+    out += this.mapToSource(directives);
+    out += this.mapToSource(body).join('\n');
+    return out;
+  }
+  StringLiteral(node) {
+    const {
+      extra
+    } = node;
+    if (!extra) {
+      debugger;
+      return '';
+    }
+    if (typeof extra.raw !== 'string') {
+      debugger;
+      return '';
+    }
+    return extra.raw;
+  }
+  NumericLiteral(node) {
+    return node.extra.raw;
+  }
+  AssignmentPattern(node) {
+    const {
+      left,
+      right
+    } = node;
+    return `${this.toSource(left)} = ${this.toSource(right)}`;
+  }
+  NullLiteral(node) {
+    return 'null';
+  }
+  TaggedTemplateExpression(node) {
+    const {
+      tag,
+      quasi
+    } = node;
+    const t = this.toSource(tag);
+    const q = this.toSource(quasi);
+    return t + q;
+  }
+  YieldExpression(node) {
+    const {
+      delegate,
+      argument
+    } = node;
+    let keyword = 'yield';
+    if (delegate) {
+      keyword += '*';
+    }
+    const a = this.toSource(argument);
+    return `${keyword} ${a}`;
+  }
+}
+
+class Asserter extends Stringifier {
+  constructor({
+    forceCurly = true,
+    validateDivision = true,
+    expandType = expandTypeDepFree,
+    filename
+  } = {}) {
+    super();
+    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
+      }
+    };
+    this.typedefs = {};
+    this.forceCurly = forceCurly;
+    this.validateDivision = validateDivision;
+    this.expandType = expandType;
+    this.filename = filename;
+  }
+  ArrowFunctionExpression(node) {
+    const {
+      async,
+      body,
+      generator,
+      params
+    } = node;
+    let 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;
+  }
+  ClassDeclaration(node) {
+    const {
+      id
+    } = node;
+    const id_ = this.toSource(id);
+    let out = super.ClassDeclaration(node);
+    out += `${this.spaces}registerClass(${id_});`;
+    return out;
+  }
+  findParentOfType(node, type) {
+    const currentIndex = this.parents.findLastIndex(_ => _ == node);
+    return this.parents.findLast((_, i) => {
+      if (i > currentIndex) {
+        return false;
+      }
+      return _.type === type;
+    });
+  }
+  findParentOfTypeWithPredicate(node, type, predicate) {
+    const {
+      parents
+    } = this;
+    let i = parents.findLastIndex(_ => _ == node);
+    i--;
+    while (i >= 0) {
+      const parent = parents[i];
+      if (predicate(parent)) {
+        return;
+      }
+      if (parent.type === type) {
+        return parent;
+      }
+      i--;
+    }
+  }
+  warn(...args) {
+    if (this.filename) {
+      console.warn("[WARN]", this.filename);
+    }
+    console.warn(...args);
+  }
+  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(_ => _.type == 'VariableDeclaration');
+        if (!node) {
+          return;
+        }
+      }
+    }
+    let {
+      leadingComments
+    } = node;
+    if (!leadingComments) {
+      if (node.type === 'FunctionDeclaration') {
+        const exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
+        leadingComments = exportNamedDeclaration == null ? void 0 : exportNamedDeclaration.leadingComments;
+      }
+      if (node.type === 'ArrowFunctionExpression') {
+        var _tmp, _tmp2;
+        let tmp = this.findParentOfType(node, 'VariableDeclaration');
+        if (!((_tmp = tmp) != null && _tmp.leadingComments)) {
+          function isFunc(node) {
+            return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration';
+          }
+          tmp = this.findParentOfTypeWithPredicate(node, 'ExportNamedDeclaration', isFunc);
+        }
+        leadingComments = (_tmp2 = tmp) == null ? void 0 : _tmp2.leadingComments;
+      }
+    }
+    if (leadingComments && leadingComments.length) {
+      const lastComment = leadingComments[leadingComments.length - 1];
+      if (lastComment.type == "CommentBlock") {
+        if (lastComment.value.includes('@event')) {
+          return;
+        }
+        if (node.type === 'ClassMethod' && node.kind === 'set') {
+          const paramName = this.getNameOfParam(node.params[0]);
+          if (node.params.length !== 1) {
+            this.warn("getJSDoc> setters require exactly one argument");
+          }
+          return {
+            [paramName]: parseJSDocSetter(lastComment.value, this.expandType)
+          };
+        }
+        return parseJSDoc(lastComment.value, this.expandType);
+      }
+    }
+  }
+  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);
+  }
+  statsReset() {
+    Object.values(this.stats).forEach(statReset);
+  }
+  statsPrint() {
+    console.table(this.stats);
+  }
+  getStatsForNode(node) {
+    const {
+      parentType,
+      stats
+    } = this;
+    if (parentType == 'ClassMethod') {
+      const kind = this.parent.kind;
+      return stats[`ClassMethod#${kind}`];
+    } else if (node.type === 'ArrowFunctionExpression') {
+      return stats.ArrowFunctionExpression;
+    }
+    const stat = stats[parentType];
+    if (!stat) {
+      this.warn("getStatsForNode> dummy, but unhandled... fix for node type", node);
+      return {
+        checked: 0,
+        unchecked: 0
+      };
+    }
+    return stat;
+  }
+  nodeHasParamName(node, name) {
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
+    }
+    const {
+      params
+    } = node;
+    if (!params) {
+      this.warn("nodeHasParamName> Expected params for", {
+        node,
+        name
+      });
+      return false;
+    }
+    return params.some(node => {
+      const {
+        type
+      } = node;
+      if (type === "AssignmentPattern") {
+        const {
+          left
+        } = node;
+        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 {
+        const _ = new Stringifier();
+        const code = _.toSource(node);
+        console.log("Unknown type to test params for", type, code);
+      }
+      return false;
+    });
+  }
+  generateTypeChecks(node) {
+    const {
+      parentType
+    } = this;
+    if (node.type === 'BlockStatement' && parentType != 'FunctionDeclaration' && parentType != 'ClassMethod' && parentType != 'FunctionExpression') {
+      return '';
+    }
+    const jsdoc = this.getJSDoc(node);
+    const stat = this.getStatsForNode(node);
+    if (!jsdoc) {
+      stat.unchecked++;
+      return '';
+    }
+    stat.checked++;
+    let spaces = this.spaces;
+    if (node.type !== 'ArrowFunctionExpression') {
+      spaces += '  ';
+    }
+    let out = '';
+    for (let name in jsdoc) {
+      const type = jsdoc[name];
+      const hasParam = this.nodeHasParamName(node, name);
+      if (!hasParam) {
+        let testNode = node;
+        if (node.type === 'BlockStatement') {
+          testNode = this.parent;
+        }
+        const paramIndex = Object.keys(jsdoc).findIndex(_ => _ === name);
+        const param = testNode.params[paramIndex];
+        if (param) {
+          const isObjectPattern = param.type === 'ObjectPattern';
+          const isArrayPattern = param.type === 'ArrayPattern';
+          const isSupportedPattern = isObjectPattern || isArrayPattern;
+          if (isSupportedPattern) {
+            name = `arguments[${paramIndex}]`;
+          } else if (param.type === 'AssignmentPattern') {
+            const _loc = this.getName(node);
+            if (param.left.type === 'ArrayPattern' && type.type === 'array') {
+              for (const element of param.left.elements) {
+                if (element.type !== 'Identifier') {
+                  this.warn('Only Identifier case handled right now');
+                  continue;
+                }
+                const _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
+                out += `${spaces}if (!assertType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+              }
+              continue;
+            } else if (param.left.type === 'ObjectPattern' && type.type === 'object') {
+              for (const property of param.left.properties) {
+                if (property.key.type !== 'Identifier') {
+                  this.warn('ObjectPattern> Only Identifier case handled right now');
+                  continue;
+                }
+                const keyName = property.key.name;
+                const subType = type.properties[keyName];
+                if (!subType) {
+                  this.warn("missing subtype information in JSDoc");
+                  continue;
+                }
+                const _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
+                out += `${spaces}if (!assertType(${keyName}, ${_t2}, '${_loc}', '${name}')) {\n`;
+                out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+              }
+              continue;
+            }
+            this.warn(`generateTypeChecks> ${_loc}> todo implement`, `AssignmentPattern for parameter ${name}`);
+            continue;
+          }
+        } else {
+          const _loc2 = this.getName(node);
+          this.warn(`generateTypeChecks> ${_loc2}> Missing param: ${name}`);
+          continue;
+        }
+      }
+      let t = JSON.stringify(type, null, 2).replaceAll('\n', '\n' + spaces);
+      if (type === 'this') {
+        const classDecl = this.findParentOfType(node, 'ClassDeclaration');
+        if (!(classDecl != null && classDecl.id)) {
+          this.warn('generateTypeChecks> !classDecl?.id');
+        }
+        t = '"' + this.toSource(classDecl.id) + '"';
+      }
+      const loc = this.getName(node);
+      let prevCheck = '';
+      if (loc === 'ContactPoint#constructor' || loc === 'ContactResult#constructor' || loc === 'SingleContactResult#constructor') {
+        prevCheck = 'arguments.length !== 0 && ';
+      }
+      out += `${spaces}if (${prevCheck}!assertType(${name}, ${t}, '${loc}', '${name}')) {\n`;
+      out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+    }
+    return out;
+  }
+  getName(node) {
+    const toSource = this.toSource.bind(this);
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
+    }
+    const {
+      type,
+      key,
+      id
+    } = node;
+    switch (type) {
+      case 'FunctionDeclaration':
+        return toSource(id);
+      case "ClassMethod":
+        const classDecl = this.parents.findLast(_ => _.type == 'ClassDeclaration');
+        let out = '';
+        if (classDecl) {
+          out += toSource(classDecl.id) + '#';
+        }
+        out += toSource(key);
+        return out;
+      case 'FunctionExpression':
+        if (id) {
+          return toSource(id);
+        }
+        const expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
+        if (!expressionStatement) {
+          return "unnamed function expression";
+        }
+        return toSource(expressionStatement.expression.left);
+      case 'ArrowFunctionExpression':
+        const 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*/';
+    }
+  }
+  BinaryExpression(node) {
+    if (!this.validateDivision) {
+      return super.BinaryExpression(node);
+    }
+    const {
+      left,
+      operator,
+      right
+    } = node;
+    const left_ = this.toSource(left);
+    const right_ = this.toSource(right);
+    if (operator === '/') {
+      return `validateDivision(${left_}, ${right_})`;
+    }
+    return `${left_} ${operator} ${right_}`;
+  }
+  File(node) {
+    const {
+      errors,
+      program,
+      comments
+    } = node;
+    if (comments) {
+      for (const comment of comments) {
+        const warn = this.warn.bind(this);
+        parseJSDocTypedef(this.typedefs, warn, comment, this.expandType);
+      }
+    }
+    let out = '';
+    for (const name in this.typedefs) {
+      const typedef = this.typedefs[name];
+      const json = JSON.stringify(typedef, null, 2);
+      out += `registerTypedef('${name}', ${json});\n`;
+    }
+    const code = this.toSource(program) + '\n';
+    out += code;
+    return out;
+  }
+}
+
+function addTypeChecks(src, options) {
+  try {
+    const asserter = new Asserter(options);
+    const ast = parse(src, {
+      sourceType: 'module'
+    });
+    const out = asserter.toSource(ast);
+    return out;
+  } catch (e) {
+    console.error(e);
+    return `/*<addTypeChecks-error>*/${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);
+}
+
+const 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) {
+  const stringifier = new Stringifier();
+  const ast = parse(code, {
+    sourceType: 'module'
+  });
+  if (!ast) {
+    return;
+  }
+  const out = stringifier.toSource(ast);
+  return out;
+}
+
+function expandType(type) {
+  const ast = parseType(type);
+  return toSourceTS(ast);
+}
+function parseType(str) {
+  if (str.startsWith('...')) {
+    str = str.slice(3);
+    str += '[]';
+  }
+  str = `type tmp = ${str};`;
+  const ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true);
+  return ast.statements[0].type;
+}
+function toSourceTS(node) {
+  const {
+    typeArguments,
+    typeName
+  } = node;
+  const kind_ = ts.SyntaxKind[node.kind];
+  const {
+    AnyKeyword,
+    ArrayType,
+    BooleanKeyword,
+    FunctionType,
+    Identifier,
+    IntersectionType,
+    JSDocAllType,
+    LastTypeNode,
+    LiteralType,
+    NullKeyword,
+    NumberKeyword,
+    NumericLiteral,
+    ObjectKeyword,
+    Parameter,
+    ParenthesizedType,
+    PropertySignature,
+    StringKeyword,
+    StringLiteral,
+    ThisType,
+    TupleType,
+    TypeLiteral,
+    TypeReference,
+    UndefinedKeyword,
+    UnionType,
+    JSDocNullableType
+  } = ts.SyntaxKind;
+  switch (node.kind) {
+    case FunctionType:
+      const parameters = node.parameters.map(toSourceTS);
+      return {
+        type: 'function',
+        parameters
+      };
+    case JSDocNullableType:
+      const t = toSourceTS(node.type);
+      return {
+        type: 'union',
+        members: [t, 'null']
+      };
+    case Parameter:
+      const type = node.type ? toSourceTS(node.type) : 'any';
+      const name = toSourceTS(node.name);
+      const ret = {
+        type,
+        name
+      };
+      if (node.dotDotDotToken) {
+        return {
+          type: 'array',
+          elementType: ret
+        };
+      }
+      return ret;
+    case TypeReference:
+      if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments == null ? void 0 : typeArguments.length) === 2) {
+        return {
+          type: 'record',
+          key: toSourceTS(typeArguments[0]),
+          val: toSourceTS(typeArguments[1])
+        };
+      } else if (typeName.text === 'Object' && (!typeArguments || (typeArguments == null ? void 0 : typeArguments.length) === 0)) {
+        return {
+          type: 'object',
+          properties: {}
+        };
+      } else if (typeName.text === 'Map' && (typeArguments == null ? void 0 : typeArguments.length) === 2) {
+        return {
+          type: 'map',
+          key: toSourceTS(typeArguments[0]),
+          val: toSourceTS(typeArguments[1])
+        };
+      } else if (typeName.text === 'Array' && (typeArguments == null ? void 0 : typeArguments.length) === 1) {
+        const elementType = toSourceTS(typeArguments[0]);
+        return {
+          type: 'array',
+          elementType
+        };
+      } else if (typeName.text === 'Set' && (typeArguments == null ? void 0 : typeArguments.length) === 1) {
+        const elementType = toSourceTS(typeArguments[0]);
+        return {
+          type: 'set',
+          elementType
+        };
+      } else if (typeName.text === 'Class' && (typeArguments == null ? 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:
+      const properties = {};
+      node.members.forEach(member => {
+        const name = toSourceTS(member.name);
+        const type = toSourceTS(member.type);
+        properties[name] = type;
+      });
+      return {
+        type: 'object',
+        properties
+      };
+    case PropertySignature:
+      console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
+      return `${toSourceTS(node.name)}: ${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;
+  }
+}
+
+export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, expandType, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, parseJSDoc, parseJSDocSetter, parseJSDocTypedef, parseType, simplifyType, toSourceTS };