@runtime-type-inspector/transpiler 3.2.6 → 3.3.0

package/index.cjs

@@ -282,24 +282,19 @@
 	 * 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
+	 * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The structured type
 	 * representation obtained from parsing and converting the provided type string.
 	 */
 	function expandType(type) {
 	  var ast = parseType(type);
+	  if (!ast) {
+	    return 'never';
+	  }
 	  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.
+	 * @returns {ts.TypeNode|undefined} - The node containing all the information about the input type string.
 	 */
 	function parseType(str) {
 	  // TS doesn't like ... notation in this context
@@ -310,7 +305,12 @@
 	  // type tmp = (...string) => 123; to have a function context
 	  str = "type tmp = ".concat(str, ";");
 	  var ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true /*setParentNodes*/);
-	  return ast.statements[0].type;
+	  var firstStatement = ast.statements[0];
+	  if (!ts.isTypeAliasDeclaration(firstStatement)) {
+	    console.warn('parseType> Expected type alias declaration, got', firstStatement, 'instead.');
+	    return;
+	  }
+	  return firstStatement.type;
 	}
 	/** @type {Record<string, 'missing'|'found'>} */
 	var requiredTypeofs = {};
@@ -320,7 +320,7 @@
 	 * 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.
+	 * @param {ts.TypeNode|ts.Identifier} 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.
 	 */
@@ -336,7 +336,7 @@
 	    Identifier = _ts$SyntaxKind.Identifier,
 	    IntersectionType = _ts$SyntaxKind.IntersectionType,
 	    JSDocAllType = _ts$SyntaxKind.JSDocAllType,
-	    LastTypeNode = _ts$SyntaxKind.LastTypeNode,
+	    ImportType = _ts$SyntaxKind.ImportType,
 	    LiteralType = _ts$SyntaxKind.LiteralType,
 	    NullKeyword = _ts$SyntaxKind.NullKeyword,
 	    NumberKeyword = _ts$SyntaxKind.NumberKeyword,
@@ -363,6 +363,7 @@
 	    BigIntLiteral = _ts$SyntaxKind.BigIntLiteral,
 	    ConditionalType = _ts$SyntaxKind.ConditionalType,
 	    IndexedAccessType = _ts$SyntaxKind.IndexedAccessType,
+	    IndexSignature = _ts$SyntaxKind.IndexSignature,
 	    RestType = _ts$SyntaxKind.RestType,
 	    TypeQuery = _ts$SyntaxKind.TypeQuery,
 	    TypeOperator = _ts$SyntaxKind.TypeOperator,
@@ -378,12 +379,18 @@
 	        type: 'bigint'
 	      };
 	    case BigIntLiteral:
+	      if (!ts.isBigIntLiteral(node)) {
+	        throw Error("Impossible");
+	      }
 	      var literal = node.text.slice(0, -1); // Remove the "n"
 	      return {
 	        type: 'bigint',
 	        literal: literal
 	      };
 	    case ConditionalType:
+	      if (!ts.isConditionalTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      // Keys on node:
 	      // ['pos', 'end', 'flags', 'modifierFlagsCache', 'transformFlags', 'parent', 'kind', 'checkType',
 	      // 'extendsType', 'trueType', 'falseType', 'locals', 'nextContainer']
@@ -400,6 +407,9 @@
 	      };
 	    case ConstructorType:
 	      {
+	        if (!ts.isConstructorTypeNode(node)) {
+	          throw Error("Impossible");
+	        }
 	        var _parameters = node.parameters.map(toSourceTS);
 	        var _ret = toSourceTS(node.type);
 	        return {
@@ -409,12 +419,18 @@
 	        };
 	      }
 	    case FunctionType:
+	      if (!ts.isFunctionTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var parameters = node.parameters.map(toSourceTS);
 	      return {
 	        type: 'function',
 	        parameters: parameters
 	      };
 	    case IndexedAccessType:
+	      if (!ts.isIndexedAccessTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var index = toSourceTS(node.indexType);
 	      var object = toSourceTS(node.objectType);
 	      return {
@@ -423,12 +439,18 @@
 	        object: object
 	      };
 	    case RestType:
+	      if (!ts.isRestTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var annotation = toSourceTS(node.type);
 	      return {
 	        type: 'rest',
 	        annotation: annotation
 	      };
 	    case JSDocNullableType:
+	      if (!ts.isJSDocNullableType(node)) {
+	        throw Error("Impossible");
+	      }
 	      var t = toSourceTS(node.type);
 	      return {
 	        type: 'union',
@@ -436,6 +458,9 @@
 	      };
 	    case MappedType:
 	      {
+	        if (!ts.isMappedTypeNode(node)) {
+	          throw Error("Impossible");
+	        }
 	        var result = toSourceTS(node.type);
 	        var parameter = node.typeParameter;
 	        if (parameter.kind === TypeParameter) {
@@ -455,6 +480,9 @@
 	    // todo work out more: const jsdoc = `(...a: ...number) => 123
 	    // TS even thinks it's two parameters... just go for array/[]
 	    case Parameter:
+	      if (!ts.isParameter(node)) {
+	        throw Error("Impossible");
+	      }
 	      var type = node.type ? toSourceTS(node.type) : 'any';
 	      var name = toSourceTS(node.name);
 	      var ret = {
@@ -469,6 +497,9 @@
 	      }
 	      return ret;
 	    case TypeQuery:
+	      if (!ts.isTypeQueryNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var argument = toSourceTS(node.exprName);
 	      // Notify Asserter class that we have to register variables with this name
 	      if (!requiredTypeofs[argument]) {
@@ -479,6 +510,9 @@
 	        argument: argument
 	      };
 	    case TypeOperator:
+	      if (!ts.isTypeOperatorNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      if (node.operator === KeyOfKeyword) {
 	        var _argument = toSourceTS(node.type);
 	        return {
@@ -489,6 +523,9 @@
 	      console.warn("unimplemented TypeOperator", node);
 	    case TypeReference:
 	      {
+	        if (!ts.isTypeReferenceNode(node)) {
+	          throw Error("Impossible");
+	        }
 	        if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 2) {
 	          return {
 	            type: 'record',
@@ -544,14 +581,16 @@
 	          args: args
 	        };
 	      }
-	    case StringKeyword:
-	      return node.getText();
-	    case NumberKeyword:
-	      return node.getText();
 	    case NamedTupleMember:
+	      if (!ts.isNamedTupleMember(node)) {
+	        throw Error("Impossible");
+	      }
 	      return toSourceTS(node.type);
 	    case IntersectionType:
 	      {
+	        if (!ts.isIntersectionTypeNode(node)) {
+	          throw Error("Impossible");
+	        }
 	        var _members = node.types.map(toSourceTS);
 	        return {
 	          type: 'intersection',
@@ -559,35 +598,87 @@
 	        };
 	      }
 	    case TupleType:
+	      if (!ts.isTupleTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var elements = node.elements.map(toSourceTS);
 	      return {
 	        type: 'tuple',
 	        elements: elements
 	      };
 	    case UnionType:
+	      if (!ts.isUnionTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      var members = node.types.map(toSourceTS);
 	      return {
 	        type: 'union',
 	        members: members
 	      };
 	    case TypeLiteral:
-	      var properties = {};
-	      node.members.forEach(function (member) {
-	        var name = toSourceTS(member.name);
-	        var type = toSourceTS(member.type);
-	        properties[name] = type;
-	      });
-	      return {
-	        type: 'object',
-	        properties: properties
-	      };
+	      {
+	        if (!ts.isTypeLiteralNode(node)) {
+	          throw Error("Impossible");
+	        }
+	        var properties = {};
+	        /** @type {object[]} */
+	        var indexSignatures;
+	        node.members.forEach(function (member) {
+	          if (member.kind === IndexSignature) {
+	            var _indexSignatures;
+	            indexSignatures = (_indexSignatures = indexSignatures) !== null && _indexSignatures !== void 0 ? _indexSignatures : [];
+	            indexSignatures.push(toSourceTS(member));
+	          } else if (member.kind === PropertySignature) {
+	            if (!ts.isPropertySignature(member)) {
+	              throw Error("Impossible");
+	            }
+	            var _name2 = toSourceTS(member.name);
+	            var _type = toSourceTS(member.type);
+	            properties[_name2] = _type;
+	          } else {
+	            console.warn('TypeLiteral: unhandled member', member);
+	          }
+	        });
+	        var _ret2 = {
+	          type: 'object'
+	        };
+	        if (Object.keys(properties).length) {
+	          _ret2.properties = properties;
+	        }
+	        if (indexSignatures) {
+	          _ret2.indexSignatures = indexSignatures;
+	        }
+	        return _ret2;
+	      }
 	    case PropertySignature:
+	      if (!ts.isPropertySignature(node)) {
+	        throw Error("Impossible");
+	      }
 	      console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
 	      return "".concat(toSourceTS(node.name), ": ").concat(toSourceTS(node.type));
+	    case IndexSignature:
+	      if (!ts.isIndexSignatureDeclaration(node)) {
+	        throw Error("Impossible");
+	      }
+	      // Only possible modifier I know of, but we don't need it:
+	      //   {readonly [n: number]: string, length: number}
+	      var indexType = toSourceTS(node.type);
+	      var indexParameters = node.parameters.map(toSourceTS);
+	      return {
+	        type: 'indexSignature',
+	        indexType: indexType,
+	        indexParameters: indexParameters
+	      };
 	    case Identifier:
+	      if (!ts.isIdentifier(node)) {
+	        throw Error("Impossible");
+	      }
 	      return node.text;
 	    case ArrayType:
 	      {
+	        if (!ts.isArrayTypeNode(node)) {
+	          throw Error("Impossible");
+	        }
 	        var _elementType4 = toSourceTS(node.elementType);
 	        return {
 	          type: 'array',
@@ -595,18 +686,23 @@
 	        };
 	      }
 	    case LiteralType:
+	      if (!ts.isLiteralTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      return toSourceTS(node.literal);
 	    case AnyKeyword:
 	    case BooleanKeyword:
-	    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
-	    case JSDocAllType:
+	    case StringKeyword:
+	    case NeverKeyword:
 	    case NullKeyword:
-	    case StringLiteral:
-	    case ThisType:
+	    case NumberKeyword:
 	    case UndefinedKeyword:
-	    case VoidKeyword:
 	    case UnknownKeyword:
-	    case NeverKeyword:
+	    case VoidKeyword:
+	    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
+	    case JSDocAllType:
+	    case ThisType:
+	    case StringLiteral:
 	      return node.getText();
 	    case TrueKeyword:
 	      return true;
@@ -620,9 +716,16 @@
 	        properties: {}
 	      };
 	    case ParenthesizedType:
+	      if (!ts.isParenthesizedTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
 	      // fall-through for parentheses
 	      return toSourceTS(node.type);
-	    case LastTypeNode:
+	    case ImportType:
+	      if (!ts.isImportTypeNode(node)) {
+	        throw Error("Impossible");
+	      }
+	      /** @todo Handle case without any qualifier like `import('test')` */
 	      return toSourceTS(node.qualifier);
 	    default:
 	      // const test = {};
@@ -844,19 +947,26 @@
 	  return type;
 	}
 
+	/**
+	 * @typedef {ReturnType<typeof parseJSDoc>} ParseJSDocReturnType
+	 */
+	/**
+	 * @typedef {typeof expandTypeDepFree} ExpandType
+	 * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+	 */
 	/**
 	 * 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.
+	 * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+	 * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
 	 */
 	function parseJSDoc(src) {
 	  var expandType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : expandTypeDepFree;
 	  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
 	  var regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
 	  var matches = _toConsumableArray(src.matchAll(regex));
-	  /** @type {Record<string, any>} */
+	  /** @type {Record<string, ExpandTypeReturnType>} */
 	  var params = Object.create(null);
 	  matches.forEach(function (_) {
 	    var type = expandType(_[1].trim());
@@ -884,7 +994,6 @@
 	    try {
 	      for (_iterator.s(); !(_step = _iterator.n()).done;) {
 	        var part = _step.value;
-	        /** @type {object} */
 	        var toptype = properties[part];
 	        if (!toptype) {
 	          // No toptype means we resolved as far as possible, now we can add `simplifiedType`.
@@ -939,6 +1048,35 @@
 	  }
 	}
 
+	/**
+	 * @typedef {typeof expandTypeDepFree} ExpandType
+	 * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+	 */
+	/**
+	 * Parses JSDoc comments to extract parameter type information.
+	 *
+	 * @param {string} src - The JSDoc comment string to parse.
+	 * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+	 * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping template names to their parsed types,
+	 * or `undefined` if no template tags were found.
+	 */
+	function parseJSDocTemplates(src) {
+	  var expandType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : expandTypeDepFree;
+	  var regexTemplateTyped = /@template \{(.*?)\} ([a-zA-Z0-9_$=]+)/g;
+	  var matches = _toConsumableArray(src.matchAll(regexTemplateTyped));
+	  if (!matches.length) {
+	    return;
+	  }
+	  /** @type {Record<string, ExpandTypeReturnType>} */
+	  var templates = Object.create(null);
+	  matches.forEach(function (_) {
+	    var type = expandType(_[1].trim());
+	    var name = _[2].trim();
+	    templates[name] = type;
+	  });
+	  return templates;
+	}
+
 	/**
 	 * Extracts the parameter name and its optionality from a JSDoc parameter string.
 	 *
@@ -2943,14 +3081,14 @@
 	}();
 
 	/** @typedef {import('@babel/types').Node              } Node               */
-	/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
-	/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
-	/** @typedef {import('./stat.js').Stat                } Stat               */
+	/** @typedef {import('@babel/types').ClassMethod       } ClassMethod        */
+	/** @typedef {import('@babel/types').ClassPrivateMethod} ClassPrivateMethod */
+	/** @typedef {import('./stat.js').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 {import('./parseJSDoc.js').ExpandType} [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.
@@ -3227,11 +3365,11 @@
 	    }
 	    /**
 	     * @param {Node} node - The Babel AST node.
-	     * @returns {undefined | {}} The return value of `parseJSDoc`.
+	     * @returns {string|undefined} The JSDoc comment of `node`.
 	     */
 	  }, {
-	    key: "getJSDoc",
-	    value: function getJSDoc(node) {
+	    key: "getLeadingComment",
+	    value: function getLeadingComment(node) {
 	      if (node.type === 'BlockStatement') {
 	        node = this.parent;
 	      }
@@ -3256,26 +3394,61 @@
 	      if (leadingComments && leadingComments.length) {
 	        var lastComment = leadingComments[leadingComments.length - 1];
 	        if (lastComment.type === "CommentBlock") {
-	          if (lastComment.value.includes('@event')) {
-	            return;
-	          }
-	          if (node.type === 'ClassMethod' && node.kind === 'set') {
-	            var paramName = this.getNameOfParam(node.params[0]);
-	            if (node.params.length !== 1) {
-	              this.warn("getJSDoc> setters require exactly one argument");
-	            }
-	            var setterType = parseJSDocSetter(lastComment.value, this.expandType);
-	            if (!setterType) {
-	              return;
-	            }
-	            return _defineProperty({}, paramName, setterType);
+	          return lastComment.value;
+	        }
+	      }
+	    }
+	    /**
+	     * @param {Node} node - The Babel AST node.
+	     * @todo ESLint problem:
+	     * returns {import('./parseJSDoc.js').ParseJSDocReturnType} The return value of `parseJSDoc`
+	     * returns {Record<string, import('./parseJSDoc.js').ExpandTypeReturnType> | undefined} The
+	     * return value of `parseJSDoc`.
+	     * @returns {Record<string, any>|undefined} asd
+	     */
+	  }, {
+	    key: "getJSDoc",
+	    value: function getJSDoc(node) {
+	      var comment = this.getLeadingComment(node);
+	      if (!comment) {
+	        return;
+	      }
+	      if (comment.includes('@event')) {
+	        return;
+	      }
+	      if (comment.includes('@ignoreRTI')) {
+	        return;
+	      }
+	      // Need to do same resolving as in: this.getLeadingComment(node)
+	      if (node.type === 'BlockStatement') {
+	        node = this.parent;
+	      }
+	      if (node.type === 'ClassMethod') {
+	        if (node.kind === 'get') {
+	          // JSDoc on a getter is just some documentation.
+	          return;
+	        } else if (node.kind === 'set') {
+	          if (node.params.length !== 1) {
+	            this.warn("getJSDoc> setters require exactly one argument");
 	          }
-	          if (lastComment.value.includes('@ignoreRTI')) {
+	          var setterType = parseJSDocSetter(comment, this.expandType);
+	          if (!setterType) {
 	            return;
 	          }
-	          return parseJSDoc(lastComment.value, this.expandType);
+	          var paramName = this.getNameOfParam(node.params[0]);
+	          var _params = _defineProperty({}, paramName, setterType);
+	          return {
+	            templates: undefined,
+	            params: _params
+	          };
 	        }
 	      }
+	      var templates = parseJSDocTemplates(comment);
+	      var params = parseJSDoc(comment, this.expandType);
+	      return {
+	        templates: templates,
+	        params: params
+	      };
 	    }
 	    /**
 	     * Retrieves the name of a parameter from a Babel AST node.
@@ -3296,8 +3469,7 @@
 	          return param.left.name;
 	        }
 	      }
-	      debugger;
-	      this.warn("unable to extra name from param in specified way - may contain too much information");
+	      this.warn("Unable to retrieve name from param in specified way - may contain too much information.");
 	      return this.toSource(param);
 	    }
 	  }, {
@@ -3414,6 +3586,15 @@
 	        stat.unchecked++;
 	        return '';
 	      }
+	      var templates = jsdoc.templates,
+	        params = jsdoc.params;
+	      if (!params) {
+	        console.warn("This should never happen, please check your input code.", this.getLeadingComment(node), {
+	          jsdoc: jsdoc
+	        });
+	        stat.unchecked++;
+	        return '';
+	      }
 	      stat.checked++;
 	      var spaces = this.spaces;
 	      var out = '';
@@ -3422,17 +3603,21 @@
 	      if (this.ignoreLocations.includes(loc)) {
 	        return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
 	      }
+	      if (templates) {
+	        var tmp = JSON.stringify(templates, null, 2).replaceAll('\n', '\n' + spaces);
+	        out += "\n".concat(spaces, "const rtiTemplates = ").concat(tmp, ";");
+	      }
 	      //out += `${spaces}/*${spaces}  node.type=${node.type}\n${spaces}
 	      //  ${JSON.stringify(jsdoc)}\n${parent}\n${spaces}*/\n`;
 	      var _loop = function _loop(name) {
-	          var type = jsdoc[name];
+	          var type = params[name];
 	          var hasParam = _this2.nodeHasParamName(node, name);
 	          if (!hasParam) {
 	            var testNode = node;
 	            if (node.type === 'BlockStatement') {
 	              testNode = _this2.parent;
 	            }
-	            var paramIndex = Object.keys(jsdoc).findIndex(function (_) {
+	            var paramIndex = Object.keys(params).findIndex(function (_) {
 	              return _ === name;
 	            });
 	            var param = testNode.params[paramIndex];
@@ -3468,7 +3653,11 @@
 	                        continue;
 	                      }
 	                      var _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
-	                      out += "".concat(spaces, "if (!inspectType(").concat(element.name, ", ").concat(_t, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      if (templates) {
+	                        out += "".concat(spaces, "if (!inspectTypeWithTemplates(").concat(element.name, ", ").concat(_t, ", '").concat(_loc, "', '").concat(name, "', rtiTemplates)) {\n");
+	                      } else {
+	                        out += "".concat(spaces, "if (!inspectType(").concat(element.name, ", ").concat(_t, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      }
 	                      out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
 	                    }
 	                  } catch (err) {
@@ -3499,7 +3688,11 @@
 	                        continue;
 	                      }
 	                      var _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
-	                      out += "".concat(spaces, "if (!inspectType(").concat(keyName, ", ").concat(_t2, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      if (templates) {
+	                        out += "".concat(spaces, "if (!inspectTypeWithTemplates(").concat(keyName, ", ").concat(_t2, ", '").concat(_loc, "', '").concat(name, "', rtiTemplates)) {\n");
+	                      } else {
+	                        out += "".concat(spaces, "if (!inspectType(").concat(keyName, ", ").concat(_t2, ", '").concat(_loc, "', '").concat(name, "')) {\n");
+	                      }
 	                      out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
 	                    }
 	                  } catch (err) {
@@ -3537,11 +3730,15 @@
 	            out += '\n';
 	            first = false;
 	          }
-	          out += "".concat(spaces, "if (").concat(prevCheck, "!inspectType(").concat(name, ", ").concat(t, ", '").concat(loc, "', '").concat(name, "')) {\n");
+	          if (templates) {
+	            out += "".concat(spaces, "if (").concat(prevCheck, "!inspectTypeWithTemplates(").concat(name, ", ").concat(t, ", '").concat(loc, "', '").concat(name, "', rtiTemplates)) {\n");
+	          } else {
+	            out += "".concat(spaces, "if (").concat(prevCheck, "!inspectType(").concat(name, ", ").concat(t, ", '").concat(loc, "', '").concat(name, "')) {\n");
+	          }
 	          out += "".concat(spaces, "  youCanAddABreakpointHere();\n").concat(spaces, "}\n");
 	        },
 	        _ret;
-	      for (var name in jsdoc) {
+	      for (var name in params) {
 	        _ret = _loop(name);
 	        if (_ret === 0) continue;
 	      }
@@ -4119,6 +4316,7 @@
 	exports.nodeIsFunction = nodeIsFunction;
 	exports.parseJSDoc = parseJSDoc;
 	exports.parseJSDocSetter = parseJSDocSetter;
+	exports.parseJSDocTemplates = parseJSDocTemplates;
 	exports.parseJSDocTypedef = parseJSDocTypedef;
 	exports.parseType = parseType;
 	exports.parseTypeBabelTS = parseTypeBabelTS;

package/index.mjs

@@ -25,24 +25,19 @@ import ts from 'typescript';
  * 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
+ * @returns {string | number | boolean | {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);
+  if (!ast) {
+    return 'never';
+  }
   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.
+ * @returns {ts.TypeNode|undefined} - The node containing all the information about the input type string.
  */
 function parseType(str) {
   // TS doesn't like ... notation in this context
@@ -53,7 +48,12 @@ function parseType(str) {
   // 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;
+  const firstStatement = ast.statements[0];
+  if (!ts.isTypeAliasDeclaration(firstStatement)) {
+    console.warn('parseType> Expected type alias declaration, got', firstStatement, 'instead.');
+    return;
+  }
+  return firstStatement.type;
 }
 /** @type {Record<string, 'missing'|'found'>} */
 const requiredTypeofs = {};
@@ -63,7 +63,7 @@ const requiredTypeofs = {};
  * 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.
+ * @param {ts.TypeNode|ts.Identifier} 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.
  */
@@ -75,52 +75,90 @@ function toSourceTS(node) {
   const kind_ = ts.SyntaxKind[node.kind];
   const {
     AnyKeyword,
+    // parseType('any'                            ).kind                 === ts.SyntaxKind.AnyKeyword && toSourceTS(parseType('any')) === 'any'
     ArrayType,
+    // parseType('number[]'                       ).kind                 === ts.SyntaxKind.ArrayType // todo toSourceTS(parseType('number[]')) === {type: 'array etc.
     BooleanKeyword,
+    // parseType("boolean"                        ).kind                 === ts.SyntaxKind.BooleanKeyword
     FunctionType,
+    // parseType("() => void"                     ).kind                 === ts.SyntaxKind.FunctionType
     Identifier,
+    // parseType("{a: 1, b: 2}"                   ).members[0].name.kind === ts.SyntaxKind.Identifier
     IntersectionType,
+    // parseType("1 & 2"                          ).kind                 === ts.SyntaxKind.IntersectionType
     JSDocAllType,
-    LastTypeNode,
+    // parseType("*"                              ).kind                 === ts.SyntaxKind.JSDocAllType
+    ImportType,
+    // parseType('import("test").Test'            ).kind                 === ts.SyntaxKind.ImportType
     LiteralType,
+    // parseType("123"                            ).kind                 === ts.SyntaxKind.LiteralType
     NullKeyword,
+    // parseType("null"                           ).literal.kind         === ts.SyntaxKind.NullKeyword
     NumberKeyword,
+    // parseType("number"                         ).kind                 === ts.SyntaxKind.NumberKeyword
     NumericLiteral,
+    // parseType("123"                            ).literal.kind         === ts.SyntaxKind.NumericLiteral
     ObjectKeyword,
+    // parseType("object"                         ).kind                 === ts.SyntaxKind.ObjectKeyword
     Parameter,
+    // parseType("(a) => void"                    ).parameters[0].kind   === ts.SyntaxKind.Parameter
     ParenthesizedType,
+    // parseType("(SomeType)"                     ).kind                 === ts.SyntaxKind.ParenthesizedType
     PropertySignature,
+    // parseType("{a: 1, b: 2}"                   ).members[0].kind      === ts.SyntaxKind.PropertySignature
     StringKeyword,
+    // parseType("string"                         ).kind                 === ts.SyntaxKind.StringKeyword
     StringLiteral,
+    // parseType("'test'"                         ).literal.kind         === ts.SyntaxKind.StringLiteral
     ThisType,
+    // parseType("this"                           ).kind                 === ts.SyntaxKind.ThisType
     TupleType,
+    // parseType("[1, 2, 3]"                      ).kind                 === ts.SyntaxKind.TupleType
     TypeLiteral,
+    // parseType("{a: 1, b: 2}"                   ).kind                 === ts.SyntaxKind.TypeLiteral
     TypeReference,
+    // parseType("SomeOtherType"                  ).kind                 === ts.SyntaxKind.TypeReference
     UndefinedKeyword,
+    // parseType("undefined"                      ).kind                 === ts.SyntaxKind.UndefinedKeyword
     UnionType,
+    // parseType("1|2"                            ).kind                 === ts.SyntaxKind.UnionType
     JSDocNullableType,
+    // parseType("?lol?"                          ).kind                 === ts.SyntaxKind.JSDocNullableType
     TrueKeyword,
+    // parseType("true"                           ).literal.kind         === ts.SyntaxKind.TrueKeyword
     FalseKeyword,
+    // parseType("false"                          ).literal.kind         === ts.SyntaxKind.FalseKeyword
     VoidKeyword,
+    // parseType("void"                           ).kind                 === ts.SyntaxKind.VoidKeyword
     UnknownKeyword,
+    // parseType("unknown"                        ).kind                 === ts.SyntaxKind.UnknownKeyword
     NeverKeyword,
+    // parseType("never"                          ).kind                 === ts.SyntaxKind.NeverKeyword
     BigIntKeyword,
+    // parseType("bigint"                         ).kind                 === ts.SyntaxKind.BigIntKeyword
     BigIntLiteral,
+    // parseType("123n"                           ).literal.kind         === ts.SyntaxKind.BigIntLiteral
     ConditionalType,
+    // parseType("1 extends number ? true : false").kind                 === ts.SyntaxKind.ConditionalType
     IndexedAccessType,
+    // parseType('Test[123]'                      ).kind                 === ts.SyntaxKind.IndexedAccessType
+    IndexSignature,
+    // parseType('{[n: number]: string}'          ).members[0].kind      === ts.SyntaxKind.IndexSignature
     RestType,
+    // parseType("[...number]"                    ).elements[0].kind     === ts.SyntaxKind.RestType
     TypeQuery,
-    // parseType('typeof Number')
+    // parseType('typeof Number'                  ).kind                 === ts.SyntaxKind.TypeQuery
     TypeOperator,
-    // parseType('keyof typeof obj')
+    // parseType('keyof typeof obj'               ).kind                 === ts.SyntaxKind.TypeOperator
     KeyOfKeyword,
-    // "operator" key in TypeOperator node
+    // parseType('keyof typeof obj'               ).operator             === ts.SyntaxKind.KeyOfKeyword
     ConstructorType,
-    // parseType('new (...args: any[]) => any');
+    // parseType('new (...args: any[]) => any'    ).kind                 === ts.SyntaxKind.ConstructorType
     NamedTupleMember,
+    // parseType('[a: 1]'                         ).elements[0].kind     === ts.SyntaxKind.NamedTupleMember
     MappedType,
-    // parseType('{[K in TaskType]: InstanceType<typeof SUPPORTED_TASKS[K]["pipeline"]>}')
-    TypeParameter // Basically K and TaskType of MappedType
+    // parseType('{[K in TaskType]: 123}'         ).kind                 === ts.SyntaxKind.MappedType
+    TypeParameter // parseType('{[K in TaskType]: 123}'         ).typeParameter.kind   ===  ts.SyntaxKind.TypeParameter
   } = ts.SyntaxKind;
   // console.log({typeArguments, typeName, kind_, node});
   switch (node.kind) {
@@ -129,12 +167,18 @@ function toSourceTS(node) {
         type: 'bigint'
       };
     case BigIntLiteral:
+      if (!ts.isBigIntLiteral(node)) {
+        throw Error("Impossible");
+      }
       const literal = node.text.slice(0, -1); // Remove the "n"
       return {
         type: 'bigint',
         literal
       };
     case ConditionalType:
+      if (!ts.isConditionalTypeNode(node)) {
+        throw Error("Impossible");
+      }
       // Keys on node:
       // ['pos', 'end', 'flags', 'modifierFlagsCache', 'transformFlags', 'parent', 'kind', 'checkType',
       // 'extendsType', 'trueType', 'falseType', 'locals', 'nextContainer']
@@ -151,6 +195,9 @@ function toSourceTS(node) {
       };
     case ConstructorType:
       {
+        if (!ts.isConstructorTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const _parameters = node.parameters.map(toSourceTS);
         const _ret = toSourceTS(node.type);
         return {
@@ -160,12 +207,18 @@ function toSourceTS(node) {
         };
       }
     case FunctionType:
+      if (!ts.isFunctionTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const parameters = node.parameters.map(toSourceTS);
       return {
         type: 'function',
         parameters
       };
     case IndexedAccessType:
+      if (!ts.isIndexedAccessTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const index = toSourceTS(node.indexType);
       const object = toSourceTS(node.objectType);
       return {
@@ -174,12 +227,18 @@ function toSourceTS(node) {
         object
       };
     case RestType:
+      if (!ts.isRestTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const annotation = toSourceTS(node.type);
       return {
         type: 'rest',
         annotation
       };
     case JSDocNullableType:
+      if (!ts.isJSDocNullableType(node)) {
+        throw Error("Impossible");
+      }
       const t = toSourceTS(node.type);
       return {
         type: 'union',
@@ -187,6 +246,9 @@ function toSourceTS(node) {
       };
     case MappedType:
       {
+        if (!ts.isMappedTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const result = toSourceTS(node.type);
         const parameter = node.typeParameter;
         if (parameter.kind === TypeParameter) {
@@ -206,6 +268,9 @@ function toSourceTS(node) {
     // todo work out more: const jsdoc = `(...a: ...number) => 123
     // TS even thinks it's two parameters... just go for array/[]
     case Parameter:
+      if (!ts.isParameter(node)) {
+        throw Error("Impossible");
+      }
       const type = node.type ? toSourceTS(node.type) : 'any';
       const name = toSourceTS(node.name);
       const ret = {
@@ -220,6 +285,9 @@ function toSourceTS(node) {
       }
       return ret;
     case TypeQuery:
+      if (!ts.isTypeQueryNode(node)) {
+        throw Error("Impossible");
+      }
       const argument = toSourceTS(node.exprName);
       // Notify Asserter class that we have to register variables with this name
       if (!requiredTypeofs[argument]) {
@@ -230,6 +298,9 @@ function toSourceTS(node) {
         argument
       };
     case TypeOperator:
+      if (!ts.isTypeOperatorNode(node)) {
+        throw Error("Impossible");
+      }
       if (node.operator === KeyOfKeyword) {
         const _argument = toSourceTS(node.type);
         return {
@@ -240,6 +311,9 @@ function toSourceTS(node) {
       console.warn("unimplemented TypeOperator", node);
     case TypeReference:
       {
+        if (!ts.isTypeReferenceNode(node)) {
+          throw Error("Impossible");
+        }
         if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments == null ? void 0 : typeArguments.length) === 2) {
           return {
             type: 'record',
@@ -295,14 +369,16 @@ function toSourceTS(node) {
           args
         };
       }
-    case StringKeyword:
-      return node.getText();
-    case NumberKeyword:
-      return node.getText();
     case NamedTupleMember:
+      if (!ts.isNamedTupleMember(node)) {
+        throw Error("Impossible");
+      }
       return toSourceTS(node.type);
     case IntersectionType:
       {
+        if (!ts.isIntersectionTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const _members = node.types.map(toSourceTS);
         return {
           type: 'intersection',
@@ -310,35 +386,87 @@ function toSourceTS(node) {
         };
       }
     case TupleType:
+      if (!ts.isTupleTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const elements = node.elements.map(toSourceTS);
       return {
         type: 'tuple',
         elements
       };
     case UnionType:
+      if (!ts.isUnionTypeNode(node)) {
+        throw Error("Impossible");
+      }
       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
-      };
+      {
+        if (!ts.isTypeLiteralNode(node)) {
+          throw Error("Impossible");
+        }
+        const properties = {};
+        /** @type {object[]} */
+        let indexSignatures;
+        node.members.forEach(member => {
+          if (member.kind === IndexSignature) {
+            var _indexSignatures;
+            indexSignatures = (_indexSignatures = indexSignatures) != null ? _indexSignatures : [];
+            indexSignatures.push(toSourceTS(member));
+          } else if (member.kind === PropertySignature) {
+            if (!ts.isPropertySignature(member)) {
+              throw Error("Impossible");
+            }
+            const name = toSourceTS(member.name);
+            const type = toSourceTS(member.type);
+            properties[name] = type;
+          } else {
+            console.warn('TypeLiteral: unhandled member', member);
+          }
+        });
+        const _ret2 = {
+          type: 'object'
+        };
+        if (Object.keys(properties).length) {
+          _ret2.properties = properties;
+        }
+        if (indexSignatures) {
+          _ret2.indexSignatures = indexSignatures;
+        }
+        return _ret2;
+      }
     case PropertySignature:
+      if (!ts.isPropertySignature(node)) {
+        throw Error("Impossible");
+      }
       console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
       return `${toSourceTS(node.name)}: ${toSourceTS(node.type)}`;
+    case IndexSignature:
+      if (!ts.isIndexSignatureDeclaration(node)) {
+        throw Error("Impossible");
+      }
+      // Only possible modifier I know of, but we don't need it:
+      //   {readonly [n: number]: string, length: number}
+      const indexType = toSourceTS(node.type);
+      const indexParameters = node.parameters.map(toSourceTS);
+      return {
+        type: 'indexSignature',
+        indexType,
+        indexParameters
+      };
     case Identifier:
+      if (!ts.isIdentifier(node)) {
+        throw Error("Impossible");
+      }
       return node.text;
     case ArrayType:
       {
+        if (!ts.isArrayTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const elementType = toSourceTS(node.elementType);
         return {
           type: 'array',
@@ -346,18 +474,23 @@ function toSourceTS(node) {
         };
       }
     case LiteralType:
+      if (!ts.isLiteralTypeNode(node)) {
+        throw Error("Impossible");
+      }
       return toSourceTS(node.literal);
     case AnyKeyword:
     case BooleanKeyword:
-    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
-    case JSDocAllType:
+    case StringKeyword:
+    case NeverKeyword:
     case NullKeyword:
-    case StringLiteral:
-    case ThisType:
+    case NumberKeyword:
     case UndefinedKeyword:
-    case VoidKeyword:
     case UnknownKeyword:
-    case NeverKeyword:
+    case VoidKeyword:
+    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
+    case JSDocAllType:
+    case ThisType:
+    case StringLiteral:
       return node.getText();
     case TrueKeyword:
       return true;
@@ -371,9 +504,16 @@ function toSourceTS(node) {
         properties: {}
       };
     case ParenthesizedType:
+      if (!ts.isParenthesizedTypeNode(node)) {
+        throw Error("Impossible");
+      }
       // fall-through for parentheses
       return toSourceTS(node.type);
-    case LastTypeNode:
+    case ImportType:
+      if (!ts.isImportTypeNode(node)) {
+        throw Error("Impossible");
+      }
+      /** @todo Handle case without any qualifier like `import('test')` */
       return toSourceTS(node.qualifier);
     default:
       // const test = {};
@@ -588,18 +728,25 @@ function simplifyType(type, optional) {
   return type;
 }
 
+/**
+ * @typedef {ReturnType<typeof parseJSDoc>} ParseJSDocReturnType
+ */
+/**
+ * @typedef {typeof expandTypeDepFree} ExpandType
+ * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ */
 /**
  * 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.
+ * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, ExpandTypeReturnType> | 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>} */
+  /** @type {Record<string, ExpandTypeReturnType>} */
   const params = Object.create(null);
   matches.forEach(_ => {
     const type = expandType(_[1].trim());
@@ -623,7 +770,6 @@ function parseJSDoc(src, expandType = expandTypeDepFree) {
     const parts = name.split(/[\[\]]*\./);
     let properties = params;
     for (const part of parts) {
-      /** @type {object} */
       const toptype = properties[part];
       if (!toptype) {
         // No toptype means we resolved as far as possible, now we can add `simplifiedType`.
@@ -670,6 +816,34 @@ function parseJSDocSetter(src, expandType = expandTypeDepFree) {
   }
 }
 
+/**
+ * @typedef {typeof expandTypeDepFree} ExpandType
+ * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ */
+/**
+ * Parses JSDoc comments to extract parameter type information.
+ *
+ * @param {string} src - The JSDoc comment string to parse.
+ * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping template names to their parsed types,
+ * or `undefined` if no template tags were found.
+ */
+function parseJSDocTemplates(src, expandType = expandTypeDepFree) {
+  const regexTemplateTyped = /@template \{(.*?)\} ([a-zA-Z0-9_$=]+)/g;
+  const matches = [...src.matchAll(regexTemplateTyped)];
+  if (!matches.length) {
+    return;
+  }
+  /** @type {Record<string, ExpandTypeReturnType>} */
+  const templates = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    const name = _[2].trim();
+    templates[name] = type;
+  });
+  return templates;
+}
+
 /**
  * Extracts the parameter name and its optionality from a JSDoc parameter string.
  *
@@ -2619,14 +2793,14 @@ class Stringifier {
 }
 
 /** @typedef {import('@babel/types').Node              } Node               */
-/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
-/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
-/** @typedef {import('./stat.js').Stat                } Stat               */
+/** @typedef {import('@babel/types').ClassMethod       } ClassMethod        */
+/** @typedef {import('@babel/types').ClassPrivateMethod} ClassPrivateMethod */
+/** @typedef {import('./stat.js').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 {import('./parseJSDoc.js').ExpandType} [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.
@@ -2879,9 +3053,9 @@ class Asserter extends Stringifier {
   }
   /**
    * @param {Node} node - The Babel AST node.
-   * @returns {undefined | {}} The return value of `parseJSDoc`.
+   * @returns {string|undefined} The JSDoc comment of `node`.
    */
-  getJSDoc(node) {
+  getLeadingComment(node) {
     if (node.type === 'BlockStatement') {
       node = this.parent;
     }
@@ -2907,28 +3081,61 @@ class Asserter extends Stringifier {
     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");
-          }
-          const setterType = parseJSDocSetter(lastComment.value, this.expandType);
-          if (!setterType) {
-            return;
-          }
-          return {
-            [paramName]: setterType
-          };
+        return lastComment.value;
+      }
+    }
+  }
+  /**
+   * @param {Node} node - The Babel AST node.
+   * @todo ESLint problem:
+   * returns {import('./parseJSDoc.js').ParseJSDocReturnType} The return value of `parseJSDoc`
+   * returns {Record<string, import('./parseJSDoc.js').ExpandTypeReturnType> | undefined} The
+   * return value of `parseJSDoc`.
+   * @returns {Record<string, any>|undefined} asd
+   */
+  getJSDoc(node) {
+    const comment = this.getLeadingComment(node);
+    if (!comment) {
+      return;
+    }
+    if (comment.includes('@event')) {
+      return;
+    }
+    if (comment.includes('@ignoreRTI')) {
+      return;
+    }
+    // Need to do same resolving as in: this.getLeadingComment(node)
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
+    }
+    if (node.type === 'ClassMethod') {
+      if (node.kind === 'get') {
+        // JSDoc on a getter is just some documentation.
+        return;
+      } else if (node.kind === 'set') {
+        if (node.params.length !== 1) {
+          this.warn("getJSDoc> setters require exactly one argument");
         }
-        if (lastComment.value.includes('@ignoreRTI')) {
+        const setterType = parseJSDocSetter(comment, this.expandType);
+        if (!setterType) {
           return;
         }
-        return parseJSDoc(lastComment.value, this.expandType);
+        const paramName = this.getNameOfParam(node.params[0]);
+        const _params = {
+          [paramName]: setterType
+        };
+        return {
+          templates: undefined,
+          params: _params
+        };
       }
     }
+    const templates = parseJSDocTemplates(comment);
+    const params = parseJSDoc(comment, this.expandType);
+    return {
+      templates,
+      params
+    };
   }
   /**
    * Retrieves the name of a parameter from a Babel AST node.
@@ -2947,8 +3154,7 @@ class Asserter extends Stringifier {
         return param.left.name;
       }
     }
-    debugger;
-    this.warn("unable to extra name from param in specified way - may contain too much information");
+    this.warn("Unable to retrieve name from param in specified way - may contain too much information.");
     return this.toSource(param);
   }
   statsReset() {
@@ -3067,6 +3273,17 @@ class Asserter extends Stringifier {
       stat.unchecked++;
       return '';
     }
+    const {
+      templates,
+      params
+    } = jsdoc;
+    if (!params) {
+      console.warn("This should never happen, please check your input code.", this.getLeadingComment(node), {
+        jsdoc
+      });
+      stat.unchecked++;
+      return '';
+    }
     stat.checked++;
     const {
       spaces
@@ -3077,17 +3294,21 @@ class Asserter extends Stringifier {
     if (this.ignoreLocations.includes(loc)) {
       return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
     }
+    if (templates) {
+      const tmp = JSON.stringify(templates, null, 2).replaceAll('\n', '\n' + spaces);
+      out += `\n${spaces}const rtiTemplates = ${tmp};`;
+    }
     //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];
+    for (let name in params) {
+      const type = params[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 paramIndex = Object.keys(params).findIndex(_ => _ === name);
         const param = testNode.params[paramIndex];
         if (param) {
           const isObjectPattern = param.type === 'ObjectPattern';
@@ -3117,7 +3338,11 @@ class Asserter extends Stringifier {
                   continue;
                 }
                 const _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
-                out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                if (templates) {
+                  out += `${spaces}if (!inspectTypeWithTemplates(${element.name}, ${_t}, '${_loc}', '${name}', rtiTemplates)) {\n`;
+                } else {
+                  out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                }
                 out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
               }
               continue;
@@ -3139,7 +3364,11 @@ class Asserter extends Stringifier {
                   continue;
                 }
                 const _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
-                out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc}', '${name}')) {\n`;
+                if (templates) {
+                  out += `${spaces}if (!inspectTypeWithTemplates(${keyName}, ${_t2}, '${_loc}', '${name}', rtiTemplates)) {\n`;
+                } else {
+                  out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc}', '${name}')) {\n`;
+                }
                 out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
               }
               continue;
@@ -3172,7 +3401,11 @@ class Asserter extends Stringifier {
         out += '\n';
         first = false;
       }
-      out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
+      if (templates) {
+        out += `${spaces}if (${prevCheck}!inspectTypeWithTemplates(${name}, ${t}, '${_loc3}', '${name}', rtiTemplates)) {\n`;
+      } else {
+        out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
+      }
       out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
     }
     return out;
@@ -3698,4 +3931,4 @@ function toSourceBabelTS(node) {
   }
 }
 
-export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTypedef, parseType, parseTypeBabelTS, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };
+export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTemplates, parseJSDocTypedef, parseType, parseTypeBabelTS, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };

package/package.json

@@ -1,7 +1,7 @@
 {
   "bin": "bin.js",
   "name": "@runtime-type-inspector/transpiler",
-  "version": "3.2.6",
+  "version": "3.3.0",
   "description": "Validating JSDoc types at runtime for high-quality types - Trust is good, control is better.",
   "main": "index.cjs",
   "module": "index.mjs",
@@ -19,7 +19,7 @@
   "homepage": "https://github.com/kungfooman/RuntimeTypeInspector.js#readme",
   "dependencies": {
     "@babel/parser": "^7.23.0",
-    "@runtime-type-inspector/runtime": "^3.2.6",
+    "@runtime-type-inspector/runtime": "^3.3.0",
     "typescript": "^5.1.6"
   },
   "files": [