@runtime-type-inspector/transpiler 3.0.5 → 3.0.7

package/index.mjs

@@ -2,223 +2,612 @@ import { parse } from '@babel/parser';
 import ts from 'typescript';
 
 /**
- * @todo expandTypeDepFree doesn't support "complicated" types.
- * For actual builds, we use expandType() anyway (which is based on TypeScript).
- * But since TypeScript is a huge dependency, I'm looking into BabelFlow/BabelTypescript parser.
- * Comparing AST's like this usually helps to find bugs or potential issues,
- * while we can benchmark for best performance too.
- * @example
- * const tooComplex = 'Array<string|{chunks?: undefined|Array<{language: string|null, timestamp: Array<number|null>, text: string}>}>';
- * console.log(expandTypeDepFree(tooComplex));
- */
-/**
- * @typedef {object} ExpandTypeReturnValue
- * @property {'array' | 'union' | 'record' | 'tuple' | 'object' | 'promise' | 'typeof'} type - The type.
- * @property {object | string} [elementType] - For Array.
- * @property {object | string} [key] - For Record<key, val>
- * @property {object | string} [val] - For Record<key, val>
- * @property {(object | string)[]} [members] - For unions.
- * @property {object | string} [properties] - For objects.
- * @property {(object | string)[]} [elements] - For tuples.
- * @property {object | string} [argument] - For typeof.
- */
-/**
- * 'DepFree' refers to the fact that this function has no dependencies,
- * while `expandType` depends on TypeScript itself for maximum compatibility.
- * @example
- * expandTypeDepFree('(123)                   '); // Outputs: '123'
- * expandTypeDepFree('Array<number>           '); // Outputs: { type: 'array', elementType: 'number' }
- * expandTypeDepFree('Array<(123) >           '); // Outputs: { type: 'array', elementType: '123' }
- * expandTypeDepFree('  ( ( 123 ) )           '); // Outputs: '123'
- * expandTypeDepFree('  (string ) |(number )  '); // Outputs: { type: 'union', members: ['string', 'number'] }
- * expandTypeDepFree(' ((  Object  ) )        '); // Outputs: { type: 'object', properties: {} }
- * @param {string} type - The input type to expand.
- * @returns {string | ExpandTypeReturnValue} Object containing parsed information from type string.
- */
-function expandTypeDepFree(type) {
-  type = type.trim();
-  // '(123)' -> '123'
-  while (!type.includes('|') && type[0] === '(' && type[type.length - 1] === ')') {
-    type = type.slice(1, -1).trim();
-  }
-  // (1) Rest parameters like ...string
-  if (type[0] === '.' && type[1] === '.' && type[2] === '.') {
-    const elementType = type.slice(3);
-    return {
-      type: 'array',
-      elementType
-    };
-  }
-  // (2)
-  // Array<...>
-  if (type.startsWith("Array<") && type.endsWith('>')) {
-    const typeSlice = type.slice(6, -1);
-    const elementType = expandTypeDepFree(typeSlice);
-    return {
-      type: "array",
-      elementType
-    };
-  }
-  // Promise<...>
-  if (type.startsWith("Promise<") && type.endsWith('>')) {
-    const typeSlice = type.slice(8, -1);
-    const elementType = expandTypeDepFree(typeSlice);
-    return {
-      type: "promise",
-      elementType
-    };
-  }
-  // (3) Object<...> or Record<...>
-  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)
-    };
-  }
-  // (4) {...}
-  if (type[0] === '{' && type[type.length - 1] === '}') {
-    const propertiesArray = type.slice(1, -1).split(','); // ['entity: Entity', ' app: AppBase']
-    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
-    };
-  }
-  // (5) expand unions
-  const members = type.split("|");
-  if (members.length >= 2) {
-    members.forEach((_, i) => members[i] = _.trim());
-    return {
-      type: 'union',
-      members: members.map(expandTypeDepFree)
-    };
-  }
-  // (6) expand [] Arrays
-  // Test arrays: new pc.Mat3().set([1, 2, 3, "asd"])
-  if (type.endsWith("[]")) {
-    const typeSlice = type.slice(0, -2);
-    return {
-      type: 'array',
-      elementType: expandTypeDepFree(typeSlice)
-    };
-  }
-  // (7) expand tuples
-  if (type[0] === '[' && type[type.length - 1] === ']') {
-    const elements = type.slice(1, -1).split(','); // ['null', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture']
-    return {
-      type: 'tuple',
-      elements: elements.map(expandTypeDepFree)
-    };
-  }
-  // (8) expand typeof expressions
-  if (type.startsWith('typeof ')) {
-    const argument = expandTypeDepFree(type.substring(7));
-    return {
-      type: 'typeof',
-      argument
-    };
-  }
-  if (type === 'object' || type === 'Object') {
-    return {
-      type: 'object',
-      properties: {}
-    };
-  }
-  return type;
-}
-
-/** @typedef {import('@babel/types').Node} Node */
-/** @typedef {import('@babel/types').Function} Function */
-/**
- * Checks if the provided node is a function-like structure.
+ * Transforms a type string into a structured type representation.
  *
- * @param {Node} node - The Babel AST node to be tested.
- * @returns {node is Function} - `true` if the node is a function-like structure, otherwise `false`.
+ * This function parses a given type string and converts it into a TypeScript
+ * Abstract Syntax Tree (AST), then uses that AST to return a structured type
+ * representation that can be further utilized or interpreted.
+ *
+ * @todo Better handling of weird case: Array<>
+ * @example
+ * const {expandType} = await import("./src-transpiler/expandType.mjs");
+ * expandType('[string, Array|AnyTypedArray, number[]]|[ONNXTensor]');
+ * expandType('(123)                    '); // Outputs: '123'
+ * expandType('  ( ( 123 ) )            '); // Outputs: '123'
+ * expandType('Array<number>            '); // Outputs: {type: 'array', elementType: 'number'}
+ * expandType('Array<(123) >            '); // Outputs: {type: 'array', elementType: '123'}
+ * expandType('Array<"abc" | 123>       '); // Outputs: {type: 'array', elementType: {type: 'union', members: ['"abc"', '123']}}
+ * expandType('  (string ) |(number )   '); // Outputs: {type: 'union', members: [ 'string', 'number']}
+ * expandType(' "apples" | ( "bananas") '); // Outputs: {type: 'union', members: [ '"apples"', '"bananas"']}
+ * expandType('123?                     '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('123|null                 '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('Map<string, any>         '); // Outputs:
+ * expandType('typeof Number            '); // Outputs:
+ * @param {string} type - The type string to be expanded into a structured representation.
+ * @todo Share type with expandTypeBabelTS and expandTypeDepFree
+ * @returns {string | {type: string, [key: string]: any} | undefined} The structured type
+ * representation obtained from parsing and converting the provided type string.
  */
-function nodeIsFunction(node) {
-  switch (node.type) {
-    case 'ArrowFunctionExpression':
-    case 'ClassMethod':
-    case 'ClassPrivateMethod':
-    case 'FunctionDeclaration':
-    case 'FunctionExpression':
-    case 'ObjectMethod':
-      return true;
-  }
-  return false;
+function expandType(type) {
+  const ast = parseType(type);
+  return toSourceTS(ast);
 }
-
 /**
- * @typedef DocType
- * @property {boolean} optional - Type is optional.
+ * @todo I want to use for example: import('typescript').Node
+ * But the TS types make no sense to me so far ... need to investigate more.
+ * @typedef TypeScriptType
+ * @property {object[]|undefined} typeArguments - The type arguments.
+ * @property {import('typescript').Node} typeName - The type name.
+ * @property {number} kind - The kind for `ts.SyntaxKind[kind]`.
  */
 /**
- * @param {string | DocType} type - The type.
- * @param {boolean} optional - Optionality
- * @returns {string | DocType} The simplified type.
+ * @param {string} str - The type string.
+ * @returns {TypeScriptType} - The node containing all the information about the input type string.
  */
-function simplifyType(type, optional) {
-  // If it's already an object, just set optionality.
-  if (type instanceof Object) {
-    type.optional = optional;
-  } else if (typeof type === 'string') {
-    type = type.trim();
-    if (type !== 'object' && type !== 'object[]' && type !== 'union' && !optional) {
-      // console.log("simplify", type);
-      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;
-    // console.log("delete empty", type);
+function parseType(str) {
+  // TS doesn't like ... notation in this context
+  if (str.startsWith('...')) {
+    str = str.slice(3); // remove dots
+    str += '[]'; // turn into array
   }
-
-  return type;
+  // type tmp = (...string) => 123; to have a function context
+  str = `type tmp = ${str};`;
+  const ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true /*setParentNodes*/);
+  return ast.statements[0].type;
 }
-
+/** @type {Record<string, 'missing'|'found'>} */
+const requiredTypeofs = {};
 /**
- * Parses JSDoc comments to extract parameter type information.
+ * Converts a TypeScript AST node to a source string representation or to an intermediate object describing the type.
  *
- * @param {string} src - The JSDoc comment string to parse.
- * @param {Function} [expandType] - An optional function to process the types found in the JSDoc.
- * @returns {Record<string, any> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ * This function handles various TypeScript AST node types and converts them into a string
+ * or an object representing the type.
+ *
+ * @param {TypeScriptType} node - The TypeScript AST node to convert.
+ * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The source string/number,
+ * or an object with type information based on the node, or `undefined` if the node kind is not handled.
  */
-function parseJSDoc(src, expandType = expandTypeDepFree) {
-  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
-  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
-  const matches = [...src.matchAll(regex)];
-  /** @type {Record<string, any>} */
-  const params = Object.create(null);
-  matches.forEach(_ => {
-    const type = expandType(_[1].trim());
-    let name = _[2].trim();
-    let optional = false;
-    // Examples:
-    //   name: [kwargs={}] The configuration parameters.
-    //   name: [d = 1.0] Sample spacing
+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,
+    TrueKeyword,
+    FalseKeyword,
+    VoidKeyword,
+    UnknownKeyword,
+    NeverKeyword,
+    BigIntKeyword,
+    BigIntLiteral,
+    ConditionalType,
+    IndexedAccessType,
+    RestType,
+    TypeQuery,
+    // parseType('typeof Number')
+    TypeOperator,
+    // parseType('keyof typeof obj')
+    KeyOfKeyword,
+    // "operator" key in TypeOperator node
+    ConstructorType,
+    // parseType('new (...args: any[]) => any');
+    NamedTupleMember,
+    MappedType,
+    // parseType('{[K in TaskType]: InstanceType<typeof SUPPORTED_TASKS[K]["pipeline"]>}')
+    TypeParameter // Basically K and TaskType of MappedType
+  } = ts.SyntaxKind;
+  // console.log({typeArguments, typeName, kind_, node});
+  switch (node.kind) {
+    case BigIntKeyword:
+      return {
+        type: 'bigint'
+      };
+    case BigIntLiteral:
+      const literal = node.text.slice(0, -1); // Remove the "n"
+      return {
+        type: 'bigint',
+        literal
+      };
+    case ConditionalType:
+      // Keys on node:
+      // ['pos', 'end', 'flags', 'modifierFlagsCache', 'transformFlags', 'parent', 'kind', 'checkType',
+      // 'extendsType', 'trueType', 'falseType', 'locals', 'nextContainer']
+      const checkType = toSourceTS(node.checkType);
+      const extendsType = toSourceTS(node.extendsType);
+      const trueType = toSourceTS(node.trueType);
+      const falseType = toSourceTS(node.falseType);
+      return {
+        type: 'condition',
+        checkType,
+        extendsType,
+        trueType,
+        falseType
+      };
+    case ConstructorType:
+      {
+        const _parameters = node.parameters.map(toSourceTS);
+        const _ret = toSourceTS(node.type);
+        return {
+          type: 'new',
+          parameters: _parameters,
+          ret: _ret
+        };
+      }
+    case FunctionType:
+      const parameters = node.parameters.map(toSourceTS);
+      return {
+        type: 'function',
+        parameters
+      };
+    case IndexedAccessType:
+      const index = toSourceTS(node.indexType);
+      const object = toSourceTS(node.objectType);
+      return {
+        type: 'indexedAccess',
+        index,
+        object
+      };
+    case RestType:
+      const annotation = toSourceTS(node.type);
+      return {
+        type: 'rest',
+        annotation
+      };
+    case JSDocNullableType:
+      const t = toSourceTS(node.type);
+      return {
+        type: 'union',
+        members: [t, 'null']
+      };
+    case MappedType:
+      {
+        const result = toSourceTS(node.type);
+        const parameter = node.typeParameter;
+        if (parameter.kind === TypeParameter) {
+          // For example: {[K in TaskType]: InstanceType etc.
+          const iterable = toSourceTS(parameter.constraint); // TaskType
+          const element = toSourceTS(parameter.name); // K
+          return {
+            type: 'mapping',
+            iterable,
+            element,
+            result
+          };
+        }
+        console.warn("MappedType: expected TypeParameter");
+        return 'transpiler-error';
+      }
+    // todo work out more: const jsdoc = `(...a: ...number) => 123
+    // TS even thinks it's two parameters... just go for array/[]
+    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 TypeQuery:
+      const argument = toSourceTS(node.exprName);
+      // Notify Asserter class that we have to register variables with this name
+      if (!requiredTypeofs[argument]) {
+        requiredTypeofs[argument] = 'missing';
+      }
+      return {
+        type: 'typeof',
+        argument
+      };
+    case TypeOperator:
+      if (node.operator === KeyOfKeyword) {
+        const _argument = toSourceTS(node.type);
+        return {
+          type: 'keyof',
+          argument: _argument
+        };
+      }
+      console.warn("unimplemented TypeOperator", node);
+    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) {
+          const key = toSourceTS(typeArguments[0]);
+          const val = toSourceTS(typeArguments[1]);
+          return {
+            type: 'map',
+            key,
+            val
+          };
+        } 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 === 'Promise' && (typeArguments == null ? void 0 : typeArguments.length) === 1) {
+          const elementType = toSourceTS(typeArguments[0]);
+          return {
+            type: 'promise',
+            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) {
+          const elementType = toSourceTS(typeArguments[0]);
+          return {
+            type: 'class',
+            elementType
+          };
+        }
+        if (!typeArguments) {
+          return typeName.getText();
+        }
+        const _name = typeName.text;
+        const args = typeArguments.map(toSourceTS);
+        return {
+          type: 'reference',
+          name: _name,
+          args
+        };
+      }
+    case StringKeyword:
+      return node.getText();
+    case NumberKeyword:
+      return node.getText();
+    case NamedTupleMember:
+      return toSourceTS(node.type);
+    case IntersectionType:
+      {
+        const _members = node.types.map(toSourceTS);
+        return {
+          type: 'intersection',
+          members: _members
+        };
+      }
+    case TupleType:
+      const elements = node.elements.map(toSourceTS);
+      return {
+        type: 'tuple',
+        elements
+      };
+    case UnionType:
+      const members = node.types.map(toSourceTS);
+      return {
+        type: 'union',
+        members
+      };
+    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:
+      {
+        const elementType = toSourceTS(node.elementType);
+        return {
+          type: 'array',
+          elementType
+        };
+      }
+    case LiteralType:
+      return toSourceTS(node.literal);
+    case AnyKeyword:
+    case BooleanKeyword:
+    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
+    case JSDocAllType:
+    case NullKeyword:
+    case StringLiteral:
+    case ThisType:
+    case UndefinedKeyword:
+    case VoidKeyword:
+    case UnknownKeyword:
+    case NeverKeyword:
+      return node.getText();
+    case TrueKeyword:
+      return true;
+    case FalseKeyword:
+      return false;
+    case NumericLiteral:
+      return Number(node.getText());
+    case ObjectKeyword:
+      return {
+        type: 'object',
+        properties: {}
+      };
+    case ParenthesizedType:
+      // fall-through for parentheses
+      return toSourceTS(node.type);
+    case LastTypeNode:
+      return toSourceTS(node.qualifier);
+    default:
+      // const test = {};
+      // Object.entries(ts.SyntaxKind).forEach(([name, id]) => {
+      //     test[id] = (test[id] || []);
+      //     test[id].push(name);
+      // });
+      // console.log(test);
+      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;
+  }
+}
+
+/**
+ * @todo expandTypeDepFree doesn't support "complicated" types.
+ * For actual builds, we use expandType() anyway (which is based on TypeScript).
+ * But since TypeScript is a huge dependency, I'm looking into BabelFlow/BabelTypescript parser.
+ * Comparing AST's like this usually helps to find bugs or potential issues,
+ * while we can benchmark for best performance too.
+ * @example
+ * const tooComplex = 'Array<string|{chunks?: undefined|Array<{language: string|null, timestamp: Array<number|null>, text: string}>}>';
+ * console.log(expandTypeDepFree(tooComplex));
+ */
+/**
+ * @typedef {object} ExpandTypeReturnValue
+ * @property {'array' | 'union' | 'record' | 'tuple' | 'object' | 'promise' | 'typeof'} type - The type.
+ * @property {object | string} [elementType] - For Array.
+ * @property {object | string} [key] - For Record<key, val>
+ * @property {object | string} [val] - For Record<key, val>
+ * @property {(object | string)[]} [members] - For unions.
+ * @property {object | string} [properties] - For objects.
+ * @property {(object | string)[]} [elements] - For tuples.
+ * @property {object | string} [argument] - For typeof.
+ */
+/**
+ * 'DepFree' refers to the fact that this function has no dependencies,
+ * while `expandType` depends on TypeScript itself for maximum compatibility.
+ * @example
+ * expandTypeDepFree('(123)                   '); // Outputs: '123'
+ * expandTypeDepFree('Array<number>           '); // Outputs: { type: 'array', elementType: 'number' }
+ * expandTypeDepFree('Array<(123) >           '); // Outputs: { type: 'array', elementType: '123' }
+ * expandTypeDepFree('  ( ( 123 ) )           '); // Outputs: '123'
+ * expandTypeDepFree('  (string ) |(number )  '); // Outputs: { type: 'union', members: ['string', 'number'] }
+ * expandTypeDepFree(' ((  Object  ) )        '); // Outputs: { type: 'object', properties: {} }
+ * @param {string} type - The input type to expand.
+ * @returns {string | ExpandTypeReturnValue} Object containing parsed information from type string.
+ */
+function expandTypeDepFree(type) {
+  type = type.trim();
+  // '(123)' -> '123'
+  while (!type.includes('|') && type[0] === '(' && type[type.length - 1] === ')') {
+    type = type.slice(1, -1).trim();
+  }
+  // (1) Rest parameters like ...string
+  if (type[0] === '.' && type[1] === '.' && type[2] === '.') {
+    const elementType = type.slice(3);
+    return {
+      type: 'array',
+      elementType
+    };
+  }
+  // (2)
+  // Array<...>
+  if (type.startsWith("Array<") && type.endsWith('>')) {
+    const typeSlice = type.slice(6, -1);
+    const elementType = expandTypeDepFree(typeSlice);
+    return {
+      type: "array",
+      elementType
+    };
+  }
+  // Promise<...>
+  if (type.startsWith("Promise<") && type.endsWith('>')) {
+    const typeSlice = type.slice(8, -1);
+    const elementType = expandTypeDepFree(typeSlice);
+    return {
+      type: "promise",
+      elementType
+    };
+  }
+  // (3) Object<...> or Record<...>
+  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)
+    };
+  }
+  // (4) {...}
+  if (type[0] === '{' && type[type.length - 1] === '}') {
+    const propertiesArray = type.slice(1, -1).split(','); // ['entity: Entity', ' app: AppBase']
+    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
+    };
+  }
+  // (5) expand unions
+  const members = type.split("|");
+  if (members.length >= 2) {
+    members.forEach((_, i) => members[i] = _.trim());
+    return {
+      type: 'union',
+      members: members.map(expandTypeDepFree)
+    };
+  }
+  // (6) expand [] Arrays
+  // Test arrays: new pc.Mat3().set([1, 2, 3, "asd"])
+  if (type.endsWith("[]")) {
+    const typeSlice = type.slice(0, -2);
+    return {
+      type: 'array',
+      elementType: expandTypeDepFree(typeSlice)
+    };
+  }
+  // (7) expand tuples
+  if (type[0] === '[' && type[type.length - 1] === ']') {
+    const elements = type.slice(1, -1).split(','); // ['null', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture']
+    return {
+      type: 'tuple',
+      elements: elements.map(expandTypeDepFree)
+    };
+  }
+  // (8) expand typeof expressions
+  if (type.startsWith('typeof ')) {
+    const argument = expandTypeDepFree(type.substring(7));
+    return {
+      type: 'typeof',
+      argument
+    };
+  }
+  if (type === 'object' || type === 'Object') {
+    return {
+      type: 'object',
+      properties: {}
+    };
+  }
+  return type;
+}
+
+/** @typedef {import('@babel/types').Node} Node */
+/** @typedef {import('@babel/types').Function} Function */
+/**
+ * Checks if the provided node is a function-like structure.
+ *
+ * @param {Node} node - The Babel AST node to be tested.
+ * @returns {node is Function} - `true` if the node is a function-like structure, otherwise `false`.
+ */
+function nodeIsFunction(node) {
+  switch (node.type) {
+    case 'ArrowFunctionExpression':
+    case 'ClassMethod':
+    case 'ClassPrivateMethod':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ObjectMethod':
+      return true;
+  }
+  return false;
+}
+
+/**
+ * @typedef DocType
+ * @property {boolean} optional - Type is optional.
+ */
+/**
+ * @param {string | DocType} type - The type.
+ * @param {boolean} optional - Optionality
+ * @returns {string | DocType} The simplified type.
+ */
+function simplifyType(type, optional) {
+  // If it's already an object, just set optionality.
+  if (type instanceof Object) {
+    type.optional = optional;
+  } else if (typeof type === 'string') {
+    type = type.trim();
+    if (type !== 'object' && type !== 'object[]' && type !== 'union' && !optional) {
+      // console.log("simplify", type);
+      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;
+    // console.log("delete empty", type);
+  }
+
+  return type;
+}
+
+/**
+ * Parses JSDoc comments to extract parameter type information.
+ *
+ * @param {string} src - The JSDoc comment string to parse.
+ * @param {Function} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, any> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ */
+function parseJSDoc(src, expandType = expandTypeDepFree) {
+  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
+  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
+  const matches = [...src.matchAll(regex)];
+  /** @type {Record<string, any>} */
+  const params = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    let name = _[2].trim();
+    let optional = false;
+    // Examples:
+    //   name: [kwargs={}] The configuration parameters.
+    //   name: [d = 1.0] Sample spacing
     if (name[0] === '[') {
       // Possible improvement: counting opening/closing brackets for perfect match
       const closer = name.lastIndexOf(']');
@@ -2117,1284 +2506,924 @@ class Stringifier {
     const b = this.toSource(local);
     if (a !== b) {
       return `${a} as ${b}`;
-    }
-    return a;
-  }
-  /**
-   * @param {import("@babel/types").ImportDefaultSpecifier} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  ImportDefaultSpecifier(node) {
-    const {
-      local
-    } = node;
-    return this.toSource(local);
-  }
-  /**
-   * @param {import("@babel/types").ImportNamespaceSpecifier} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  ImportNamespaceSpecifier(node) {
-    const {
-      local
-    } = node;
-    return `* as ${this.toSource(local)}`;
-  }
-  /**
-   * @param {import("@babel/types").File} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  File(node) {
-    return this.toSource(node.program) + '\n';
-  }
-  /**
-   * @param {import("@babel/types").Program} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  Program(node) {
-    const {
-      /*sourceType, interpreter,*/body,
-      directives
-    } = node;
-    let out = '';
-    // @todo I would like to keep comments above and below,
-    // but below one is currently dropped (does't matter for AST)
-    // See: test/typechecking/directive.mjs
-    out += this.mapToSource(directives);
-    out += this.mapToSource(body).join('\n');
-    return out;
-  }
-  /**
-   * @param {import("@babel/types").StringLiteral} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  StringLiteral(node) {
-    const {
-      extra
-    } = node;
-    // Never experienced this so far, but types are types...
-    if (!extra) {
-      debugger;
-      return '';
-    }
-    if (typeof extra.raw !== 'string') {
-      debugger;
-      return '';
-    }
-    return extra.raw;
-  }
-  /**
-   * @param {import("@babel/types").NumericLiteral} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  NumericLiteral(node) {
-    return node.extra.raw;
-  }
-  /**
-   * @param {import("@babel/types").AssignmentPattern} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  AssignmentPattern(node) {
-    const {
-      left,
-      right
-    } = node;
-    return `${this.toSource(left)} = ${this.toSource(right)}`;
-  }
-  /**
-   * @param {import("@babel/types").NullLiteral} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  NullLiteral(node) {
-    return 'null';
-  }
-  /**
-   * @param {import("@babel/types").TaggedTemplateExpression} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  TaggedTemplateExpression(node) {
-    const {
-      tag,
-      quasi
-    } = node;
-    const t = this.toSource(tag);
-    const q = this.toSource(quasi);
-    return t + q;
-  }
-  /**
-   * @param {import("@babel/types").YieldExpression} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  YieldExpression(node) {
-    const {
-      delegate,
-      argument
-    } = node;
-    let keyword = 'yield';
-    if (delegate) {
-      keyword += '*';
-    }
-    const a = this.toSource(argument);
-    return `${keyword} ${a}`;
-  }
-}
-
-/** @typedef {import('@babel/types').Node              } Node               */
-/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
-/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
-/** @typedef {import('./stat.mjs').Stat                } Stat               */
-/**
- * @typedef {object} Options
- * @property {boolean} [forceCurly] - Determines whether curly braces are enforced in Stringifier.
- * @property {boolean} [validateDivision] - Indicates whether division operations should be validated.
- * @property {Function} [expandType] - A function that expands shorthand types into full descriptions.
- * @property {string} [filename] - The name of a file to which the instance pertains.
- * @property {boolean} [addHeader] - Whether to add import declarations headers. Defaults to true.
- * @property {string[]} [ignoreLocations] - Ignore these locations because they are known false-positives.
- */
-class Asserter extends Stringifier {
-  /**
-   * @param {Options} [options] - The options.
-   */
-  constructor({
-    forceCurly = true,
-    validateDivision = true,
-    expandType = expandTypeDepFree,
-    filename,
-    addHeader = true,
-    ignoreLocations = []
-  } = {}) {
-    super();
-    /** @type {Record<string, Stat>} */
-    this.stats = {
-      'ArrowFunctionExpression': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassMethod#constructor': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassMethod#get': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassMethod#method': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassMethod#set': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassPrivateMethod#get': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassPrivateMethod#method': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ClassPrivateMethod#set': {
-        checked: 0,
-        unchecked: 0
-      },
-      'FunctionDeclaration': {
-        checked: 0,
-        unchecked: 0
-      },
-      'FunctionExpression': {
-        checked: 0,
-        unchecked: 0
-      },
-      'ObjectMethod': {
-        checked: 0,
-        unchecked: 0
-      }
-    };
-    /** @type {Record<string, object>} */
-    this.typedefs = {};
-    this.forceCurly = forceCurly;
-    this.validateDivision = validateDivision;
-    // @todo collect every type + manually validate as test set
-    // + implement expandType using Babel Flow type parser aswell
-    this.expandType = expandType;
-    this.filename = filename;
-    this.addHeader = addHeader;
-    this.ignoreLocations = ignoreLocations;
+    }
+    return a;
   }
   /**
-   * We expand type-asserted ArrowFunctionExpressions in order to add type assertions.
-   * @override
-   * @param {import("@babel/types").ArrowFunctionExpression} node - The Babel AST node.
+   * @param {import("@babel/types").ImportDefaultSpecifier} node - The Babel AST node.
    * @returns {string} Stringification of the node.
    */
-  ArrowFunctionExpression(node) {
+  ImportDefaultSpecifier(node) {
     const {
-      async,
-      body,
-      generator,
-      params /*, extra*/
+      local
     } = 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;
+    return this.toSource(local);
   }
   /**
-   * @override
-   * @param {import("@babel/types").ClassDeclaration} node - The Babel AST node.
+   * @param {import("@babel/types").ImportNamespaceSpecifier} node - The Babel AST node.
    * @returns {string} Stringification of the node.
    */
-  ClassDeclaration(node) {
+  ImportNamespaceSpecifier(node) {
     const {
-      id
+      local
     } = node;
-    const id_ = this.toSource(id);
-    let out = super.ClassDeclaration(node);
-    out += `${this.spaces}registerClass(${id_});`;
-    return out;
+    return `* as ${this.toSource(local)}`;
   }
   /**
-   * Finds the closest ancestor of the given node that matches the specified type.
-   *
-   * @param {Node} node - The starting node to search from.
-   * @param {T} type - Type name of the node to search for.
-   * @template {Node['type']} T
-   * @returns {Extract<Node, {type: T}>|undefined} The first ancestor node of the specified type, or undefined if none is found.
+   * @param {import("@babel/types").File} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  findParentOfType(node, type) {
-    const currentIndex = this.parents.findLastIndex(_ => _ === node);
-    return this.parents.findLast((_, i) => {
-      if (i > currentIndex) {
-        return false;
-      }
-      return _.type === type;
-    });
+  File(node) {
+    return this.toSource(node.program) + '\n';
   }
   /**
-   * Alternatively "import * as rti from ..." would also prevent "Unused external imports" warning...
-   * or keeping log of every single call during RTI parsing.
-   * @todo
-   * Once we went over every node, we can see if we really require registerTypef, registerClass etc.
-   * @returns {string} The import declaration header for importing RTI.
+   * @param {import("@babel/types").Program} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  getHeader() {
-    if (!this.addHeader) {
-      return '';
-    }
-    let header = "import {inspectType, youCanAddABreakpointHere";
-    if (this.validateDivision) {
-      header += ", validateDivision";
-    }
-    header += ", registerTypedef, registerClass} from '@runtime-type-inspector/runtime';\n";
-    // Prevent tree-shaking in UMD build so we can always "add a breakpoint here".
-    header += "export * from '@runtime-type-inspector/runtime';\n";
-    return header;
+  Program(node) {
+    const {
+      /*sourceType, interpreter,*/body,
+      directives
+    } = node;
+    let out = '';
+    // @todo I would like to keep comments above and below,
+    // but below one is currently dropped (does't matter for AST)
+    // See: test/typechecking/directive.mjs
+    out += this.mapToSource(directives);
+    out += this.mapToSource(body).join('\n');
+    return out;
   }
   /**
-   * Retrieves the node associated with the leading comments for an arrow function expression.
-   *
-   * This method travels up the syntax tree from the given node to find a parent node with leading comments.
-   * This search is bounded by function boundaries or a 'CallExpression' node, as per the logic defined within the loop.
-   * @param {Node} node - The node representing the arrow function expression for which to find the leading comments node.
-   * @returns {Node|undefined} The node that contains the leading comments, or `undefined`
-   * if none is found before reaching a different function or 'CallExpression'.
+   * @param {import("@babel/types").StringLiteral} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  getLeadingCommentsNodeForArrowFunctionExpression(node) {
+  StringLiteral(node) {
     const {
-      parents
-    } = this;
-    let i = parents.findLastIndex(_ => _ === node);
-    let parent = parents[i];
-    if (parent.leadingComments) {
-      return parent;
+      extra
+    } = node;
+    // Never experienced this so far, but types are types...
+    if (!extra) {
+      debugger;
+      return '';
     }
-    // Skip now, if we find another function first,
-    // there is no JSDoc for our function anymore.
-    // Not interested in our start node if it didn't
-    // contain leadingComments.
-    i--;
-    while (i >= 0) {
-      parent = parents[i];
-      //if (parent.type === 'CallExpression') {
-      //  break;
-      //}
-      if (nodeIsFunction(parent)) {
-        break;
-      }
-      if (parent.leadingComments) {
-        return parent;
-      }
-      i--;
+    if (typeof extra.raw !== 'string') {
+      debugger;
+      return '';
     }
+    return extra.raw;
   }
   /**
-   * Emits a warning message to the console, optionally prefixed with the instance's filename.
-   * @param {...any} args - A list of arguments to be passed to the console.warn function.
+   * @param {import("@babel/types").NumericLiteral} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  warn(...args) {
-    if (this.filename) {
-      console.warn("[WARN]", this.filename);
-    }
-    console.warn(...args);
+  NumericLiteral(node) {
+    return node.extra.raw;
   }
-  getLeadingCommentsNodeForFunctionExpression(node) {
+  /**
+   * @param {import("@babel/types").AssignmentPattern} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  AssignmentPattern(node) {
     const {
-      parents
-    } = this;
-    let i = parents.findLastIndex(_ => _ === node);
-    let parent = parents[i];
-    if (parent.leadingComments) {
-      return parent;
-    }
-    // Skip now, if we find another function first,
-    // there is no JSDoc for our function anymore.
-    // Not interested in our start node if it didn't
-    // contain leadingComments.
-    i--;
-    while (i >= 0) {
-      parent = parents[i];
-      //if (parent.type === 'CallExpression') {
-      //  break;
-      //}
-      if (nodeIsFunction(parent)) {
-        break;
-      }
-      if (parent.leadingComments) {
-        return parent;
-      }
-      i--;
-    }
-    /** @todo convert all files in test/typechecking/*.mjs into full unit tests */
-    // Old way:
-    // if (node.leadingComments) {
-    //   return node.leadingComments;
-    // }
-    // node = this.findParentOfType(node, 'ExpressionStatement');
-    // if (!node) {
-    //   /**
-    //    * @todo Need more refactoring, see missing type-assertions in test/typechecking/good-old-es5.mjs
-    //    */
-    //   node = this.parents.findLast(_ => _.type === 'VariableDeclaration');
-    //   if (!node) {
-    //     return;
-    //   }
-    // }
+      left,
+      right
+    } = node;
+    return `${this.toSource(left)} = ${this.toSource(right)}`;
   }
   /**
-   * @param {Node} node - The Babel AST node.
-   * @returns {undefined | {}} The return value of `parseJSDoc`.
+   * @param {import("@babel/types").NullLiteral} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  getJSDoc(node) {
-    if (node.type === 'BlockStatement') {
-      node = this.parent;
-    }
-    let {
-      leadingComments
-    } = node;
-    // Receive the leadingComments from the ExpressionStatement, not the FunctionExpression itself.
-    if (node.type === 'FunctionExpression') {
-      const tmp = this.getLeadingCommentsNodeForFunctionExpression(node);
-      leadingComments = tmp == null ? void 0 : tmp.leadingComments;
-    }
-    // Receive the leadingComments from ExportNamedDeclaration, if FunctionDeclaration has none
-    if (!leadingComments) {
-      if (node.type === 'FunctionDeclaration') {
-        const exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
-        leadingComments = exportNamedDeclaration == null ? void 0 : exportNamedDeclaration.leadingComments;
-      }
-      if (node.type === 'ArrowFunctionExpression') {
-        const tmp = this.getLeadingCommentsNodeForArrowFunctionExpression(node);
-        leadingComments = tmp == null ? void 0 : tmp.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)
-          };
-        }
-        if (lastComment.value.includes('@ignoreRTI')) {
-          return;
-        }
-        return parseJSDoc(lastComment.value, this.expandType);
-      }
-    }
+  NullLiteral(node) {
+    return 'null';
+  }
+  /**
+   * @param {import("@babel/types").TaggedTemplateExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  TaggedTemplateExpression(node) {
+    const {
+      tag,
+      quasi
+    } = node;
+    const t = this.toSource(tag);
+    const q = this.toSource(quasi);
+    return t + q;
   }
   /**
-   * Retrieves the name of a parameter from a Babel AST node.
-   *
-   * This function expects a node representing a function parameter and attempts to extract
-   * the parameter's name directly or from an AssignmentPattern.
-   *
-   * @param {Node} param - The AST node representing the function parameter from which to extract the name.
-   * @returns {string} The name of the parameter as a string, or the parameter's source code if the extraction fails.
+   * @param {import("@babel/types").YieldExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  getNameOfParam(param) {
-    if (param.type === 'Identifier') {
-      return param.name;
-    } else if (param.type === 'AssignmentPattern') {
-      if (param.left.type === 'Identifier') {
-        return param.left.name;
-      }
+  YieldExpression(node) {
+    const {
+      delegate,
+      argument
+    } = node;
+    let keyword = 'yield';
+    if (delegate) {
+      keyword += '*';
     }
-    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);
+    const a = this.toSource(argument);
+    return `${keyword} ${a}`;
   }
-  statsPrint() {
-    console.table(this.stats);
+}
+
+/** @typedef {import('@babel/types').Node              } Node               */
+/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
+/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
+/** @typedef {import('./stat.mjs').Stat                } Stat               */
+/**
+ * @typedef {object} Options
+ * @property {boolean} [forceCurly] - Determines whether curly braces are enforced in Stringifier.
+ * @property {boolean} [validateDivision] - Indicates whether division operations should be validated.
+ * @property {Function} [expandType] - A function that expands shorthand types into full descriptions.
+ * @property {string} [filename] - The name of a file to which the instance pertains.
+ * @property {boolean} [addHeader] - Whether to add import declarations headers. Defaults to true.
+ * @property {string[]} [ignoreLocations] - Ignore these locations because they are known false-positives.
+ */
+class Asserter extends Stringifier {
+  /**
+   * @param {Options} [options] - The options.
+   */
+  constructor({
+    forceCurly = true,
+    validateDivision = true,
+    expandType = expandTypeDepFree,
+    filename,
+    addHeader = true,
+    ignoreLocations = []
+  } = {}) {
+    super();
+    /** @type {Record<string, Stat>} */
+    this.stats = {
+      'ArrowFunctionExpression': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassMethod#constructor': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassMethod#get': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassMethod#method': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassMethod#set': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassPrivateMethod#get': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassPrivateMethod#method': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ClassPrivateMethod#set': {
+        checked: 0,
+        unchecked: 0
+      },
+      'FunctionDeclaration': {
+        checked: 0,
+        unchecked: 0
+      },
+      'FunctionExpression': {
+        checked: 0,
+        unchecked: 0
+      },
+      'ObjectMethod': {
+        checked: 0,
+        unchecked: 0
+      }
+    };
+    /** @type {Record<string, object>} */
+    this.typedefs = {};
+    this.forceCurly = forceCurly;
+    this.validateDivision = validateDivision;
+    // @todo collect every type + manually validate as test set
+    // + implement expandType using Babel Flow type parser aswell
+    this.expandType = expandType;
+    this.filename = filename;
+    this.addHeader = addHeader;
+    this.ignoreLocations = ignoreLocations;
   }
   /**
-   * Retrieves statistical information for a given Babel AST node of this instance.
-   *
-   * @param {Node} node - The Babel AST node for which the statistical data is retrieved.
-   * @returns {Stat} An object containing the statistical data for the specified node. If the
-   * node type is unhandled, defaults to returning a dummy object with 'checked' and 'unchecked'
-   * properties both set to 0.
+   * We expand type-asserted ArrowFunctionExpressions in order to add type assertions.
+   * @override
+   * @param {import("@babel/types").ArrowFunctionExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  getStatsForNode(node) {
+  ArrowFunctionExpression(node) {
     const {
-      stats
-    } = this;
-    const type = nodeIsFunction(node) ? node.type : this.parentType;
-    if (type === 'ClassMethod') {
-      const parent = /** @type {ClassMethod} */
-      this.parent;
-      const {
-        kind
-      } = parent;
-      return stats[`ClassMethod#${kind}`];
-    } else if (type === 'ClassPrivateMethod') {
-      const parent = /** @type {ClassPrivateMethod} */
-      this.parent;
-      const {
-        kind
-      } = parent;
-      return stats[`ClassPrivateMethod#${kind}`];
+      async,
+      body,
+      generator,
+      params /*, extra*/
+    } = node;
+    let out = '';
+    if (async) {
+      out += 'async ';
     }
-    const stat = stats[type];
-    if (!stat) {
-      this.warn("getStatsForNode> dummy, but unhandled... fix for node type", node);
-      return {
-        checked: 0,
-        unchecked: 0
-      };
+    if (generator) {
+      out += ' * ';
     }
-    return stat;
+    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;
   }
   /**
-   * Checks if a provided Babel AST node has a parameter with the given name.
-   *
-   * This function will look at the node's parameters if available and determine whether
-   * one of them matches the provided name. Supports various parameter types such as Identifiers
-   * and AssignmentPatterns.
-   *
-   * @param {Node} node - The Babel AST node to inspect. If it's a BlockStatement, the parent node is used instead.
-   * @param {string} name - The name of the parameter to look for within the node's parameters.
-   * @returns {boolean} True if the node has a parameter with the given name; false otherwise.
+   * @override
+   * @param {import("@babel/types").ClassDeclaration} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
    */
-  nodeHasParamName(node, name) {
-    if (node.type === 'BlockStatement') {
-      node = this.parent;
-    }
+  ClassDeclaration(node) {
     const {
-      params
+      id
     } = 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') {
+    const id_ = this.toSource(id);
+    let out = super.ClassDeclaration(node);
+    out += `${this.spaces}registerClass(${id_});`;
+    return out;
+  }
+  /**
+   * Finds the closest ancestor of the given node that matches the specified type.
+   *
+   * @param {Node} node - The starting node to search from.
+   * @param {T} type - Type name of the node to search for.
+   * @template {Node['type']} T
+   * @returns {Extract<Node, {type: T}>|undefined} The first ancestor node of the specified type, or undefined if none is found.
+   */
+  findParentOfType(node, type) {
+    const currentIndex = this.parents.findLastIndex(_ => _ === node);
+    return this.parents.findLast((_, i) => {
+      if (i > currentIndex) {
         return false;
       }
-      const _ = new Stringifier();
-      const code = _.toSource(node);
-      console.log("Unknown type to test params for", type, code);
-      return false;
+      return _.type === type;
     });
   }
   /**
-   * Generates a string containing type checks for a given Babel AST node based on associated JSDoc information.
-   *
-   * This function analyzes the node and its JSDoc annotations to construct runtime type
-   * check expressions. It handles various parameter patterns and outputs code that performs
-   * actual type assertions. If a node does not correspond to any known or supported pattern,
-   * it returns an empty string.
-   *
-   * @override
-   * @param {Node} node - The Babel AST node for which to generate type checks.
-   * @returns {string} A string of code with type check assertions, based on the JSDoc comments associated with the given node.
+   * Alternatively "import * as rti from ..." would also prevent "Unused external imports" warning...
+   * or keeping log of every single call during RTI parsing.
+   * @todo
+   * Once we went over every node, we can see if we really require registerTypef, registerClass etc.
+   * @returns {string} The import declaration header for importing RTI.
    */
-  generateTypeChecks(node) {
-    const {
-      parent
-    } = this;
-    if (node.type === 'BlockStatement' && !nodeIsFunction(parent)) {
+  getHeader() {
+    if (!this.addHeader) {
       return '';
     }
-    const jsdoc = this.getJSDoc(node);
-    // return '// ' + JSON.stringify(jsdoc) + '\n';
-    const stat = this.getStatsForNode(node);
-    if (!jsdoc) {
-      stat.unchecked++;
-      return '';
+    let header = "import {inspectType, youCanAddABreakpointHere, registerVariable";
+    if (this.validateDivision) {
+      header += ", validateDivision";
     }
-    stat.checked++;
+    header += ", registerTypedef, registerClass} from '@runtime-type-inspector/runtime';\n";
+    // Prevent tree-shaking in UMD build so we can always "add a breakpoint here".
+    header += "export * from '@runtime-type-inspector/runtime';\n";
+    return header;
+  }
+  /**
+   * Retrieves the node associated with the leading comments for an arrow function expression.
+   *
+   * This method travels up the syntax tree from the given node to find a parent node with leading comments.
+   * This search is bounded by function boundaries or a 'CallExpression' node, as per the logic defined within the loop.
+   * @param {Node} node - The node representing the arrow function expression for which to find the leading comments node.
+   * @returns {Node|undefined} The node that contains the leading comments, or `undefined`
+   * if none is found before reaching a different function or 'CallExpression'.
+   */
+  getLeadingCommentsNodeForArrowFunctionExpression(node) {
     const {
-      spaces
+      parents
     } = this;
-    let out = '';
-    let first = true;
-    const loc = this.getName(node);
-    if (this.ignoreLocations.includes(loc)) {
-      return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
+    let i = parents.findLastIndex(_ => _ === node);
+    let parent = parents[i];
+    if (parent.leadingComments) {
+      return parent;
     }
-    //out += `${spaces}/*${spaces}  node.type=${node.type}\n${spaces}
-    //  ${JSON.stringify(jsdoc)}\n${parent}\n${spaces}*/\n`;
-    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;
-          // There are four kinds of patterns:
-          //   ObjectPattern:
-          //     function test({x = 123}) {return x;} test({x: 456});
-          //   ArrayPattern:
-          //     function test([x = 123]) {return x;}; test([456]);
-          //   AssignmentPattern made up of ObjectPattern:
-          //     function test({x = 123} = {}) {return x;} test();
-          //   AssignmentPattern made up of ArrayPattern:
-          //     function test([x = 123] = []) {return x;} test();
-          if (isSupportedPattern) {
-            // The name doesn't matter any longer, because any pattern inherently
-            // drops the identifier from the AST. But we can access it
-            // via arguments[paramIndex] anyway.
-            name = `arguments[${paramIndex}]`;
-          } else if (param.type === 'AssignmentPattern') {
-            const _loc = this.getName(node);
-            if (param.left.type === 'ArrayPattern' && type.type === 'array') {
-              // Add a type assertion for each element of the ArrayPattern
-              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 (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
-                out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
-              }
-              continue;
-            } else if (param.left.type === 'ObjectPattern' && type.type === 'object') {
-              // Add a type assertion for each property of the ObjectPattern
-              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;
-                if (type.type !== 'object' || !type.properties) {
-                  this.warn("missing subtype information in JSDoc> in type", JSON.stringify(type, null, 2), "for ObjectPattern:", this.toSource(property).trim());
-                  continue;
-                }
-                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 (!inspectType(${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 _loc3 = this.getName(node);
-      let prevCheck = '';
-      // JSDoc doesn't support multiple function signatures yet, but this is
-      // exactly what we would need to deal with ObjectPool'ing
-      if (_loc3 === 'ContactPoint#constructor' || _loc3 === 'ContactResult#constructor' || _loc3 === 'SingleContactResult#constructor') {
-        prevCheck = 'arguments.length !== 0 && ';
+    // Skip now, if we find another function first,
+    // there is no JSDoc for our function anymore.
+    // Not interested in our start node if it didn't
+    // contain leadingComments.
+    i--;
+    while (i >= 0) {
+      parent = parents[i];
+      //if (parent.type === 'CallExpression') {
+      //  break;
+      //}
+      if (nodeIsFunction(parent)) {
+        break;
       }
-      if (first) {
-        out += '\n';
-        first = false;
+      if (parent.leadingComments) {
+        return parent;
       }
-      out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
-      out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+      i--;
     }
-    return out;
   }
   /**
-   * @param {Node} node - The Babel AST node.
-   * @returns {string} Best possible human-readable name of given node.
+   * Emits a warning message to the console, optionally prefixed with the instance's filename.
+   * @param {...any} args - A list of arguments to be passed to the console.warn function.
    */
-  getNameForFunctionExpression(node) {
-    const objectProperty = this.findParentOfType(node, 'ObjectProperty');
-    if (objectProperty) {
-      // See good-old-es5.mjs example for a test case
-      // TODO: Make an even better name based on Object.assign(ScopeSpace.prototype
-      // Ideally we would figure out the name: ScopeSpace#resolve
-      // Currently we only find "resolve" (still better than 'unnamed function expression'...)
-      return this.toSource(objectProperty.key);
-    }
-    const expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
-    if (expressionStatement) {
-      // There are many kinds of expressions
-      // type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ...
-      const {
-        left
-      } = expressionStatement.expression;
-      if (left) {
-        return this.toSource(left);
-      }
-      console.warn("Asserter#getNameForFunctionExpression> expression without left");
+  warn(...args) {
+    if (this.filename) {
+      console.warn("[WARN]", this.filename);
     }
-    return 'unnamed function expression';
+    console.warn(...args);
   }
-  /**
-   * @param {Node} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  getName(node) {
-    const toSource = this.toSource.bind(this);
-    if (node.type === 'BlockStatement') {
-      node = this.parent;
-    }
+  getLeadingCommentsNodeForFunctionExpression(node) {
     const {
-      type,
-      key,
-      id
-    } = node;
-    switch (type) {
-      case 'FunctionDeclaration':
-        return toSource(id);
-      case 'ClassMethod':
-      case 'ClassPrivateMethod':
-        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);
-        }
-        return this.getNameForFunctionExpression(node);
-      case 'ArrowFunctionExpression':
-        const parent = this.findParentOfType(node, 'VariableDeclarator');
-        if (parent) {
-          return toSource(parent.id);
-        }
-        return 'getName> missing parent for ' + node.type;
-      case 'ObjectMethod':
-        return toSource(key);
-      default:
-        this.warn('getName> unhandled type', type, 'for', node);
-        return '/*MISSING*/';
+      parents
+    } = this;
+    let i = parents.findLastIndex(_ => _ === node);
+    let parent = parents[i];
+    if (parent.leadingComments) {
+      return parent;
+    }
+    // Skip now, if we find another function first,
+    // there is no JSDoc for our function anymore.
+    // Not interested in our start node if it didn't
+    // contain leadingComments.
+    i--;
+    while (i >= 0) {
+      parent = parents[i];
+      //if (parent.type === 'CallExpression') {
+      //  break;
+      //}
+      if (nodeIsFunction(parent)) {
+        break;
+      }
+      if (parent.leadingComments) {
+        return parent;
+      }
+      i--;
     }
+    /** @todo convert all files in test/typechecking/*.mjs into full unit tests */
+    // Old way:
+    // if (node.leadingComments) {
+    //   return node.leadingComments;
+    // }
+    // node = this.findParentOfType(node, 'ExpressionStatement');
+    // if (!node) {
+    //   /**
+    //    * @todo Need more refactoring, see missing type-assertions in test/typechecking/good-old-es5.mjs
+    //    */
+    //   node = this.parents.findLast(_ => _.type === 'VariableDeclaration');
+    //   if (!node) {
+    //     return;
+    //   }
+    // }
   }
   /**
-   * @override
-   * @param {import("@babel/types").BinaryExpression} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
+   * @param {Node} node - The Babel AST node.
+   * @returns {undefined | {}} The return value of `parseJSDoc`.
    */
-  BinaryExpression(node) {
-    if (!this.validateDivision) {
-      return super.BinaryExpression(node);
+  getJSDoc(node) {
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
     }
-    const {
-      left,
-      operator,
-      right
+    let {
+      leadingComments
     } = node;
-    const left_ = this.toSource(left);
-    const right_ = this.toSource(right);
-    if (operator === '/') {
-      return `validateDivision(${left_}, ${right_})`;
+    // Receive the leadingComments from the ExpressionStatement, not the FunctionExpression itself.
+    if (node.type === 'FunctionExpression') {
+      const tmp = this.getLeadingCommentsNodeForFunctionExpression(node);
+      leadingComments = tmp == null ? void 0 : tmp.leadingComments;
     }
-    return `${left_} ${operator} ${right_}`;
-  }
-  /**
-   * @override
-   * @param {import("@babel/types").File} node - The Babel AST node.
-   * @returns {string} Stringification of the node.
-   */
-  File(node) {
-    // @todo figure out why errors is in Babel node and not in @babel/types...
-    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);
+    // Receive the leadingComments from ExportNamedDeclaration, if FunctionDeclaration has none
+    if (!leadingComments) {
+      if (node.type === 'FunctionDeclaration') {
+        const exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
+        leadingComments = exportNamedDeclaration == null ? void 0 : exportNamedDeclaration.leadingComments;
+      }
+      if (node.type === 'ArrowFunctionExpression') {
+        const tmp = this.getLeadingCommentsNodeForArrowFunctionExpression(node);
+        leadingComments = tmp == null ? void 0 : tmp.leadingComments;
       }
     }
-    //console.log("this.typedefs", this.typedefs);
-    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`;
+    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)
+          };
+        }
+        if (lastComment.value.includes('@ignoreRTI')) {
+          return;
+        }
+        return parseJSDoc(lastComment.value, this.expandType);
+      }
     }
-    const code = this.toSource(program) + '\n';
-    out += code;
-    return out;
-  }
-}
-
-/**
- * Simple facade which does all the processing. Processes the input
- * source string, adding runtime type checks based on JSDoc comments.
- *
- * This function takes JavaScript source code as input, parses it to an AST, traverses the
- * AST to find type annotations in JSDoc comments, and generates appropriate runtime type
- * assertions. These are then inserted into the source, producing a new version of the code
- * that includes runtime type checking based on the original JSDoc annotations.
- *
- * @param {string} src - The input source code containing JSDoc comments to be processed
- * for type checks.
- * @param {import('./Asserter.mjs').Options} [options] - Configuration options that dictate
- * how the processing is performed.
- * @returns {string} The transformed source code with inserted runtime type checks, or the
- * original source code commented with an error if processing fails.
- */
-function addTypeChecks(src, options) {
-  try {
-    const asserter = new Asserter(options);
-    const ast = parse(src, {
-      sourceType: 'module',
-      createParenthesizedExpressions: true
-    });
-    const out = asserter.getHeader() + asserter.toSource(ast);
-    return out;
-  } catch (e) {
-    console.error(e);
-    return `/*<addTypeChecks-error>*/${src}/*</addTypeChecks-error>*/`;
   }
-}
-
-/**
- * @param {object} ast - The Babel AST.
- * @returns {string} String representation in JSON format for debugging/inspecting the AST.
- */
-function ast2json(ast) {
-  return JSON.stringify(ast, function (name, val) {
-    if (name === "loc" || name === "start" || name === "end") {
-      return; // remove
-    }
-
-    return val; // keep
-  }, 2);
-}
-
-const drop = ['loc', 'start', 'end', 'leadingComments', 'trailingComments', 'innerComments', 'innerComments', 'comments'];
-/**
- * @example
- * setRight(ast2jsonForComparison(parseSync("/** *"))); // Close comment with / after last *
- * @param {object} ast - The Babel AST.
- * @returns {string} String representation in JSON format for debugging/inspecting the AST.
- */
-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; // remove
+  /**
+   * Retrieves the name of a parameter from a Babel AST node.
+   *
+   * This function expects a node representing a function parameter and attempts to extract
+   * the parameter's name directly or from an AssignmentPattern.
+   *
+   * @param {Node} param - The AST node representing the function parameter from which to extract the name.
+   * @returns {string} The name of the parameter as a string, or the parameter's source code if the extraction fails.
+   */
+  getNameOfParam(param) {
+    if (param.type === 'Identifier') {
+      return param.name;
+    } else if (param.type === 'AssignmentPattern') {
+      if (param.left.type === 'Identifier') {
+        return param.left.name;
+      }
     }
-
-    return val; // keep
-  }, 2);
-}
-
-/**
- * A roundtrip between code -> AST -> code to validate Stringifier.
- * @param {string} code - The code.
- * @returns {string | undefined} The new and once parsed and stringified code.
- */
-function code2ast2code(code) {
-  const stringifier = new Stringifier();
-  const ast = parse(code, {
-    sourceType: 'module'
-  });
-  if (!ast) {
-    return;
-  }
-  const out = stringifier.toSource(ast);
-  return out;
-}
-
-/**
- * @param {string} left - Left source code.
- * @param {string} right - Right source code.
- * @returns {boolean} Whether source codes are identical on the AST level.
- */
-function compareAST(left, right) {
-  const l = parse(left, {
-    sourceType: 'module'
-  });
-  const r = parse(right, {
-    sourceType: 'module'
-  });
-  const ljson = ast2jsonForComparison(l);
-  const rjson = ast2jsonForComparison(r);
-  const test = ljson === rjson;
-  return test;
-}
-
-/**
- * Transforms a type string into a structured type representation.
- *
- * This function parses a given type string and converts it into a TypeScript
- * Abstract Syntax Tree (AST), then uses that AST to return a structured type
- * representation that can be further utilized or interpreted.
- *
- * @todo Better handling of weird case: Array<>
- * @example
- * const {expandType} = await import("./src-transpiler/expandType.mjs");
- * expandType('[string, Array|AnyTypedArray, number[]]|[ONNXTensor]');
- * expandType('(123)                    '); // Outputs: '123'
- * expandType('  ( ( 123 ) )            '); // Outputs: '123'
- * expandType('Array<number>            '); // Outputs: {type: 'array', elementType: 'number'}
- * expandType('Array<(123) >            '); // Outputs: {type: 'array', elementType: '123'}
- * expandType('Array<"abc" | 123>       '); // Outputs: {type: 'array', elementType: {type: 'union', members: ['"abc"', '123']}}
- * expandType('  (string ) |(number )   '); // Outputs: {type: 'union', members: [ 'string', 'number']}
- * expandType(' "apples" | ( "bananas") '); // Outputs: {type: 'union', members: [ '"apples"', '"bananas"']}
- * expandType('123?                     '); // Outputs: {"type":"union","members":["123","null"]}
- * expandType('123|null                 '); // Outputs: {"type":"union","members":["123","null"]}
- * expandType('Map<string, any>         '); // Outputs:
- * expandType('typeof Number            '); // Outputs:
- * @param {string} type - The type string to be expanded into a structured representation.
- * @todo Share type with expandTypeBabelTS and expandTypeDepFree
- * @returns {string | {type: string, [key: string]: any} | undefined} The structured type
- * representation obtained from parsing and converting the provided type string.
- */
-function expandType(type) {
-  const ast = parseType(type);
-  return toSourceTS(ast);
-}
-/**
- * @todo I want to use for example: import('typescript').Node
- * But the TS types make no sense to me so far ... need to investigate more.
- * @typedef TypeScriptType
- * @property {object[]|undefined} typeArguments - The type arguments.
- * @property {import('typescript').Node} typeName - The type name.
- * @property {number} kind - The kind for `ts.SyntaxKind[kind]`.
- */
-/**
- * @param {string} str - The type string.
- * @returns {TypeScriptType} - The node containing all the information about the input type string.
- */
-function parseType(str) {
-  // TS doesn't like ... notation in this context
-  if (str.startsWith('...')) {
-    str = str.slice(3); // remove dots
-    str += '[]'; // turn into array
+    debugger;
+    this.warn("unable to extra name from param in specified way - may contain too much information");
+    return this.toSource(param);
   }
-  // type tmp = (...string) => 123; to have a function context
-  str = `type tmp = ${str};`;
-  const ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true /*setParentNodes*/);
-  return ast.statements[0].type;
-}
-/**
- * Converts a TypeScript AST node to a source string representation or to an intermediate object describing the type.
- *
- * This function handles various TypeScript AST node types and converts them into a string
- * or an object representing the type.
- *
- * @param {TypeScriptType} node - The TypeScript AST node to convert.
- * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The source string/number,
- * or an object with type information based on the node, or `undefined` if the node kind is not handled.
- */
-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,
-    TrueKeyword,
-    FalseKeyword,
-    VoidKeyword,
-    UnknownKeyword,
-    NeverKeyword,
-    BigIntKeyword,
-    BigIntLiteral,
-    ConditionalType,
-    IndexedAccessType,
-    RestType,
-    TypeQuery,
-    // parseType('typeof Number')
-    TypeOperator,
-    // parseType('keyof typeof obj')
-    KeyOfKeyword,
-    // "operator" key in TypeOperator node
-    ConstructorType,
-    // parseType('new (...args: any[]) => any');
-    NamedTupleMember,
-    MappedType,
-    // parseType('{[K in TaskType]: InstanceType<typeof SUPPORTED_TASKS[K]["pipeline"]>}')
-    TypeParameter // Basically K and TaskType of MappedType
-  } = ts.SyntaxKind;
-  // console.log({typeArguments, typeName, kind_, node});
-  switch (node.kind) {
-    case BigIntKeyword:
-      return {
-        type: 'bigint'
-      };
-    case BigIntLiteral:
-      const literal = node.text.slice(0, -1); // Remove the "n"
-      return {
-        type: 'bigint',
-        literal
-      };
-    case ConditionalType:
-      // Keys on node:
-      // ['pos', 'end', 'flags', 'modifierFlagsCache', 'transformFlags', 'parent', 'kind', 'checkType',
-      // 'extendsType', 'trueType', 'falseType', 'locals', 'nextContainer']
-      const checkType = toSourceTS(node.checkType);
-      const extendsType = toSourceTS(node.extendsType);
-      const trueType = toSourceTS(node.trueType);
-      const falseType = toSourceTS(node.falseType);
+  statsReset() {
+    Object.values(this.stats).forEach(statReset);
+  }
+  statsPrint() {
+    console.table(this.stats);
+  }
+  /**
+   * Retrieves statistical information for a given Babel AST node of this instance.
+   *
+   * @param {Node} node - The Babel AST node for which the statistical data is retrieved.
+   * @returns {Stat} An object containing the statistical data for the specified node. If the
+   * node type is unhandled, defaults to returning a dummy object with 'checked' and 'unchecked'
+   * properties both set to 0.
+   */
+  getStatsForNode(node) {
+    const {
+      stats
+    } = this;
+    const type = nodeIsFunction(node) ? node.type : this.parentType;
+    if (type === 'ClassMethod') {
+      const parent = /** @type {ClassMethod} */
+      this.parent;
+      const {
+        kind
+      } = parent;
+      return stats[`ClassMethod#${kind}`];
+    } else if (type === 'ClassPrivateMethod') {
+      const parent = /** @type {ClassPrivateMethod} */
+      this.parent;
+      const {
+        kind
+      } = parent;
+      return stats[`ClassPrivateMethod#${kind}`];
+    }
+    const stat = stats[type];
+    if (!stat) {
+      this.warn("getStatsForNode> dummy, but unhandled... fix for node type", node);
       return {
-        type: 'condition',
-        checkType,
-        extendsType,
-        trueType,
-        falseType
+        checked: 0,
+        unchecked: 0
       };
-    case ConstructorType:
-      {
-        const _parameters = node.parameters.map(toSourceTS);
-        const _ret = toSourceTS(node.type);
-        return {
-          type: 'new',
-          parameters: _parameters,
-          ret: _ret
-        };
+    }
+    return stat;
+  }
+  /**
+   * Checks if a provided Babel AST node has a parameter with the given name.
+   *
+   * This function will look at the node's parameters if available and determine whether
+   * one of them matches the provided name. Supports various parameter types such as Identifiers
+   * and AssignmentPatterns.
+   *
+   * @param {Node} node - The Babel AST node to inspect. If it's a BlockStatement, the parent node is used instead.
+   * @param {string} name - The name of the parameter to look for within the node's parameters.
+   * @returns {boolean} True if the node has a parameter with the given name; false otherwise.
+   */
+  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;
+      }
+      const _ = new Stringifier();
+      const code = _.toSource(node);
+      console.log("Unknown type to test params for", type, code);
+      return false;
+    });
+  }
+  /**
+   * Generates a string containing type checks for a given Babel AST node based on associated JSDoc information.
+   *
+   * This function analyzes the node and its JSDoc annotations to construct runtime type
+   * check expressions. It handles various parameter patterns and outputs code that performs
+   * actual type assertions. If a node does not correspond to any known or supported pattern,
+   * it returns an empty string.
+   *
+   * @override
+   * @param {Node} node - The Babel AST node for which to generate type checks.
+   * @returns {string} A string of code with type check assertions, based on the JSDoc comments associated with the given node.
+   */
+  generateTypeChecks(node) {
+    const {
+      parent
+    } = this;
+    if (node.type === 'BlockStatement' && !nodeIsFunction(parent)) {
+      return '';
+    }
+    const jsdoc = this.getJSDoc(node);
+    // return '// ' + JSON.stringify(jsdoc) + '\n';
+    const stat = this.getStatsForNode(node);
+    if (!jsdoc) {
+      stat.unchecked++;
+      return '';
+    }
+    stat.checked++;
+    const {
+      spaces
+    } = this;
+    let out = '';
+    let first = true;
+    const loc = this.getName(node);
+    if (this.ignoreLocations.includes(loc)) {
+      return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
+    }
+    //out += `${spaces}/*${spaces}  node.type=${node.type}\n${spaces}
+    //  ${JSON.stringify(jsdoc)}\n${parent}\n${spaces}*/\n`;
+    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;
+          // There are four kinds of patterns:
+          //   ObjectPattern:
+          //     function test({x = 123}) {return x;} test({x: 456});
+          //   ArrayPattern:
+          //     function test([x = 123]) {return x;}; test([456]);
+          //   AssignmentPattern made up of ObjectPattern:
+          //     function test({x = 123} = {}) {return x;} test();
+          //   AssignmentPattern made up of ArrayPattern:
+          //     function test([x = 123] = []) {return x;} test();
+          if (isSupportedPattern) {
+            // The name doesn't matter any longer, because any pattern inherently
+            // drops the identifier from the AST. But we can access it
+            // via arguments[paramIndex] anyway.
+            name = `arguments[${paramIndex}]`;
+          } else if (param.type === 'AssignmentPattern') {
+            const _loc = this.getName(node);
+            if (param.left.type === 'ArrayPattern' && type.type === 'array') {
+              // Add a type assertion for each element of the ArrayPattern
+              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 (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+              }
+              continue;
+            } else if (param.left.type === 'ObjectPattern' && type.type === 'object') {
+              // Add a type assertion for each property of the ObjectPattern
+              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;
+                if (type.type !== 'object' || !type.properties) {
+                  this.warn("missing subtype information in JSDoc> in type", JSON.stringify(type, null, 2), "for ObjectPattern:", this.toSource(property).trim());
+                  continue;
+                }
+                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 (!inspectType(${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;
+        }
       }
-    case FunctionType:
-      const parameters = node.parameters.map(toSourceTS);
-      return {
-        type: 'function',
-        parameters
-      };
-    case IndexedAccessType:
-      const index = toSourceTS(node.indexType);
-      const object = toSourceTS(node.objectType);
-      return {
-        type: 'indexedAccess',
-        index,
-        object
-      };
-    case RestType:
-      const annotation = toSourceTS(node.type);
-      return {
-        type: 'rest',
-        annotation
-      };
-    case JSDocNullableType:
-      const t = toSourceTS(node.type);
-      return {
-        type: 'union',
-        members: [t, 'null']
-      };
-    case MappedType:
-      {
-        const result = toSourceTS(node.type);
-        const parameter = node.typeParameter;
-        if (parameter.kind === TypeParameter) {
-          // For example: {[K in TaskType]: InstanceType etc.
-          const iterable = toSourceTS(parameter.constraint); // TaskType
-          const element = toSourceTS(parameter.name); // K
-          return {
-            type: 'mapping',
-            iterable,
-            element,
-            result
-          };
+      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');
         }
-        console.warn("MappedType: expected TypeParameter");
-        return 'transpiler-error';
+        t = '"' + this.toSource(classDecl.id) + '"';
       }
-    // todo work out more: const jsdoc = `(...a: ...number) => 123
-    // TS even thinks it's two parameters... just go for array/[]
-    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
-        };
+      const _loc3 = this.getName(node);
+      let prevCheck = '';
+      // JSDoc doesn't support multiple function signatures yet, but this is
+      // exactly what we would need to deal with ObjectPool'ing
+      if (_loc3 === 'ContactPoint#constructor' || _loc3 === 'ContactResult#constructor' || _loc3 === 'SingleContactResult#constructor') {
+        prevCheck = 'arguments.length !== 0 && ';
       }
-      return ret;
-    case TypeQuery:
-      const argument = toSourceTS(node.exprName);
-      return {
-        type: 'typeof',
-        argument
-      };
-    case TypeOperator:
-      if (node.operator === KeyOfKeyword) {
-        const _argument = toSourceTS(node.type);
-        return {
-          type: 'keyof',
-          argument: _argument
-        };
+      if (first) {
+        out += '\n';
+        first = false;
       }
-      console.warn("unimplemented TypeOperator", node);
-    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) {
-          const key = toSourceTS(typeArguments[0]);
-          const val = toSourceTS(typeArguments[1]);
-          return {
-            type: 'map',
-            key,
-            val
-          };
-        } 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 === 'Promise' && (typeArguments == null ? void 0 : typeArguments.length) === 1) {
-          const elementType = toSourceTS(typeArguments[0]);
-          return {
-            type: 'promise',
-            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) {
-          const elementType = toSourceTS(typeArguments[0]);
-          return {
-            type: 'class',
-            elementType
-          };
-        }
-        if (!typeArguments) {
-          return typeName.getText();
-        }
-        const _name = typeName.text;
-        const args = typeArguments.map(toSourceTS);
-        return {
-          type: 'reference',
-          name: _name,
-          args
-        };
+      out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
+      out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
+    }
+    return out;
+  }
+  /**
+   * @param {Node} node - The Babel AST node.
+   * @returns {string} Best possible human-readable name of given node.
+   */
+  getNameForFunctionExpression(node) {
+    const objectProperty = this.findParentOfType(node, 'ObjectProperty');
+    if (objectProperty) {
+      // See good-old-es5.mjs example for a test case
+      // TODO: Make an even better name based on Object.assign(ScopeSpace.prototype
+      // Ideally we would figure out the name: ScopeSpace#resolve
+      // Currently we only find "resolve" (still better than 'unnamed function expression'...)
+      return this.toSource(objectProperty.key);
+    }
+    const expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
+    if (expressionStatement) {
+      // There are many kinds of expressions
+      // type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ...
+      const {
+        left
+      } = expressionStatement.expression;
+      if (left) {
+        return this.toSource(left);
       }
-    case StringKeyword:
-      return node.getText();
-    case NumberKeyword:
-      return node.getText();
-    case NamedTupleMember:
-      return toSourceTS(node.type);
-    case IntersectionType:
-      {
-        const _members = node.types.map(toSourceTS);
-        return {
-          type: 'intersection',
-          members: _members
-        };
+      console.warn("Asserter#getNameForFunctionExpression> expression without left");
+    }
+    return 'unnamed function expression';
+  }
+  /**
+   * @param {Node} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  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':
+      case 'ClassPrivateMethod':
+        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);
+        }
+        return this.getNameForFunctionExpression(node);
+      case 'ArrowFunctionExpression':
+        const parent = this.findParentOfType(node, 'VariableDeclarator');
+        if (parent) {
+          return toSource(parent.id);
+        }
+        return 'getName> missing parent for ' + node.type;
+      case 'ObjectMethod':
+        return toSource(key);
+      default:
+        this.warn('getName> unhandled type', type, 'for', node);
+        return '/*MISSING*/';
+    }
+  }
+  /**
+   * @override
+   * @param {import("@babel/types").BinaryExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  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_}`;
+  }
+  /**
+   * @override
+   * @param {import("@babel/types").File} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  File(node) {
+    // @todo figure out why errors is in Babel node and not in @babel/types...
+    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);
       }
-    case TupleType:
-      const elements = node.elements.map(toSourceTS);
-      return {
-        type: 'tuple',
-        elements
-      };
-    case UnionType:
-      const members = node.types.map(toSourceTS);
-      return {
-        type: 'union',
-        members
-      };
-    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:
-      {
-        const elementType = toSourceTS(node.elementType);
-        return {
-          type: 'array',
-          elementType
-        };
+    }
+    //console.log("this.typedefs", this.typedefs);
+    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;
+  }
+  /**
+   * @override
+   * @param {import("@babel/types").VariableDeclaration} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  VariableDeclaration(node) {
+    const {
+      declarations
+    } = node;
+    let ret = super.VariableDeclaration(node);
+    for (const {
+      id
+    } of declarations) {
+      const name = this.toSource(id);
+      if (requiredTypeofs[name] === 'missing') {
+        ret += `\n${this.spaces}registerVariable('${name}', ${name});\n`;
+        requiredTypeofs[name] = 'found';
+      } else if (requiredTypeofs[name] === 'found') {
+        console.warn(`Already registered variable named ${name} for typeof validation`);
       }
-    case LiteralType:
-      return toSourceTS(node.literal);
-    case AnyKeyword:
-    case BooleanKeyword:
-    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
-    case JSDocAllType:
-    case NullKeyword:
-    case StringLiteral:
-    case ThisType:
-    case UndefinedKeyword:
-    case VoidKeyword:
-    case UnknownKeyword:
-    case NeverKeyword:
-      return node.getText();
-    case TrueKeyword:
-      return true;
-    case FalseKeyword:
-      return false;
-    case NumericLiteral:
-      return Number(node.getText());
-    case ObjectKeyword:
-      return {
-        type: 'object',
-        properties: {}
-      };
-    case ParenthesizedType:
-      // fall-through for parentheses
-      return toSourceTS(node.type);
-    case LastTypeNode:
-      return toSourceTS(node.qualifier);
-    default:
-      // const test = {};
-      // Object.entries(ts.SyntaxKind).forEach(([name, id]) => {
-      //     test[id] = (test[id] || []);
-      //     test[id].push(name);
-      // });
-      // console.log(test);
-      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;
+    }
+    return ret;
+  }
+}
+
+/**
+ * Simple facade which does all the processing. Processes the input
+ * source string, adding runtime type checks based on JSDoc comments.
+ *
+ * This function takes JavaScript source code as input, parses it to an AST, traverses the
+ * AST to find type annotations in JSDoc comments, and generates appropriate runtime type
+ * assertions. These are then inserted into the source, producing a new version of the code
+ * that includes runtime type checking based on the original JSDoc annotations.
+ *
+ * @param {string} src - The input source code containing JSDoc comments to be processed
+ * for type checks.
+ * @param {import('./Asserter.mjs').Options} [options] - Configuration options that dictate
+ * how the processing is performed.
+ * @returns {string} The transformed source code with inserted runtime type checks, or the
+ * original source code commented with an error if processing fails.
+ */
+function addTypeChecks(src, options) {
+  try {
+    const asserter = new Asserter(options);
+    const ast = parse(src, {
+      sourceType: 'module',
+      createParenthesizedExpressions: true
+    });
+    const out = asserter.getHeader() + asserter.toSource(ast);
+    return out;
+  } catch (e) {
+    console.error(e);
+    return `/*<addTypeChecks-error>*/${src}/*</addTypeChecks-error>*/`;
+  }
+}
+
+/**
+ * @param {object} ast - The Babel AST.
+ * @returns {string} String representation in JSON format for debugging/inspecting the AST.
+ */
+function ast2json(ast) {
+  return JSON.stringify(ast, function (name, val) {
+    if (name === "loc" || name === "start" || name === "end") {
+      return; // remove
+    }
+
+    return val; // keep
+  }, 2);
+}
+
+const drop = ['loc', 'start', 'end', 'leadingComments', 'trailingComments', 'innerComments', 'innerComments', 'comments'];
+/**
+ * @example
+ * setRight(ast2jsonForComparison(parseSync("/** *"))); // Close comment with / after last *
+ * @param {object} ast - The Babel AST.
+ * @returns {string} String representation in JSON format for debugging/inspecting the AST.
+ */
+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; // remove
+    }
+
+    return val; // keep
+  }, 2);
+}
+
+/**
+ * A roundtrip between code -> AST -> code to validate Stringifier.
+ * @param {string} code - The code.
+ * @returns {string | undefined} The new and once parsed and stringified code.
+ */
+function code2ast2code(code) {
+  const stringifier = new Stringifier();
+  const ast = parse(code, {
+    sourceType: 'module'
+  });
+  if (!ast) {
+    return;
   }
+  const out = stringifier.toSource(ast);
+  return out;
+}
+
+/**
+ * @param {string} left - Left source code.
+ * @param {string} right - Right source code.
+ * @returns {boolean} Whether source codes are identical on the AST level.
+ */
+function compareAST(left, right) {
+  const l = parse(left, {
+    sourceType: 'module'
+  });
+  const r = parse(right, {
+    sourceType: 'module'
+  });
+  const ljson = ast2jsonForComparison(l);
+  const rjson = ast2jsonForComparison(r);
+  const test = ljson === rjson;
+  return test;
 }
 
 /**
@@ -3638,4 +3667,4 @@ function toSourceBabelTS(node) {
   }
 }
 
-export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTypedef, parseType, parseTypeBabelTS, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };
+export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTypedef, parseType, parseTypeBabelTS, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };