@runtime-type-inspector/transpiler 3.2.5 → 3.2.7

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());
@@ -876,46 +986,42 @@
 	    // Strip the rest (either leftover of optional value or description)
 	    name = name.split(' ')[0].split('=')[0].trim();
 	    var simplifiedType = simplifyType(type, optional);
-	    var parts = name.split(".");
-	    if (parts.length === 3) {
-	      // Something like: @param {number[]} settings.render.skyboxRotation - Rotation of skybox.
-	      var parts0 = parts[0]; // settings
-	      var parts1 = parts[1]; // render
-	      var parts2 = parts[2]; // skyboxRotation
-	      var toptype = params[parts0];
-	      toptype.properties[parts1].properties = toptype.properties[parts1].properties || {};
-	      toptype.properties[parts1].properties[parts2] = simplifiedType;
-	    } else if (parts.length === 2) {
-	      // Something like: @param {number} description[].components
-	      var _parts = parts[0]; // description[]
-	      var _parts2 = parts[1]; // components
-	      if (_parts.endsWith('[]')) {
-	        _parts = _parts.slice(0, -2); // description[] -> description
-	      }
-
-	      var _toptype = params[_parts];
-	      if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) === "union") {
-	        var typeObject = _toptype.members.find(function (_) {
-	          return (_ === null || _ === void 0 ? void 0 : _.type) === 'object';
-	        });
-	        typeObject.properties[_parts2] = simplifiedType;
-	        //typeObject.properties = simplifiedType; // todo add test case
-	      } else if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) === "array") {
-	        _toptype.elementType.properties[_parts2] = simplifiedType;
-	      } else if ((_toptype === null || _toptype === void 0 ? void 0 : _toptype.type) === "object") {
-	        _toptype.properties = _toptype.properties || {};
-	        _toptype.properties[_parts2] = simplifiedType;
-	      } else {
-	        console.warn("parseJSDoc> skipping @param, unseen syntax detected, please check if your JSDoc is valid or open an issue about this", {
-	          src: src,
-	          toptype: _toptype,
-	          parts0: _parts,
-	          parts1: _parts2,
-	          simplifiedType: simplifiedType
-	        });
+	    // Turn "options.stats[].unitsName" into ['options', 'stats', 'unitsName'].
+	    var parts = name.split(/[\[\]]*\./);
+	    var properties = params;
+	    var _iterator = _createForOfIteratorHelper(parts),
+	      _step;
+	    try {
+	      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	        var part = _step.value;
+	        var toptype = properties[part];
+	        if (!toptype) {
+	          // No toptype means we resolved as far as possible, now we can add `simplifiedType`.
+	          console.assert(part === parts.at(-1), 'Current part and last part should be the same.');
+	          properties[part] = simplifiedType;
+	        } else if (toptype.type === "union") {
+	          var typeObject = toptype.members.find(function (_) {
+	            return (_ === null || _ === void 0 ? void 0 : _.type) === 'object';
+	          });
+	          properties = typeObject.properties;
+	        } else if (toptype.type === "array") {
+	          properties = toptype.elementType.properties;
+	        } else if (toptype.type === "object") {
+	          toptype.properties = toptype.properties || Object.create(null);
+	          properties = toptype.properties;
+	        } else {
+	          console.warn("parseJSDoc> Skipping @param, unseen syntax detected. Please check if your JSDoc is valid or open an issue about this!", {
+	            src: src,
+	            toptype: toptype,
+	            parts: parts,
+	            simplifiedType: simplifiedType
+	          });
+	        }
 	      }
-	    } else {
-	      params[name] = simplifiedType;
+	    } catch (err) {
+	      _iterator.e(err);
+	    } finally {
+	      _iterator.f();
 	    }
 	  });
 	  if (Object.keys(params).length === 0) {
@@ -942,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.
 	 *
@@ -2946,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.
@@ -3230,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;
 	      }
@@ -3259,26 +3394,56 @@
 	      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);
-	          }
-	          if (lastComment.value.includes('@ignoreRTI')) {
-	            return;
-	          }
-	          return parseJSDoc(lastComment.value, this.expandType);
+	          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' && 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(comment, this.expandType);
+	        if (!setterType) {
+	          return;
 	        }
+	        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.
@@ -3299,8 +3464,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);
 	    }
 	  }, {
@@ -3417,6 +3581,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 = '';
@@ -3425,17 +3598,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];
@@ -3471,7 +3648,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) {
@@ -3502,7 +3683,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) {
@@ -3540,11 +3725,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;
 	      }
@@ -4122,6 +4311,7 @@
 	exports.nodeIsFunction = nodeIsFunction;
 	exports.parseJSDoc = parseJSDoc;
 	exports.parseJSDocSetter = parseJSDocSetter;
+	exports.parseJSDocTemplates = parseJSDocTemplates;
 	exports.parseJSDocTypedef = parseJSDocTypedef;
 	exports.parseType = parseType;
 	exports.parseTypeBabelTS = parseTypeBabelTS;