@runtime-type-inspector/transpiler 5.0.1 → 5.0.3

package/index.cjs

@@ -427,6 +427,7 @@
 	    PropertySignature = _ts$SyntaxKind.PropertySignature,
 	    StringKeyword = _ts$SyntaxKind.StringKeyword,
 	    StringLiteral = _ts$SyntaxKind.StringLiteral,
+	    SymbolKeyword = _ts$SyntaxKind.SymbolKeyword,
 	    ThisType = _ts$SyntaxKind.ThisType,
 	    TupleType = _ts$SyntaxKind.TupleType,
 	    TypeLiteral = _ts$SyntaxKind.TypeLiteral,
@@ -453,6 +454,8 @@
 	    var ConstructorType = _ts$SyntaxKind.ConstructorType,
 	    NamedTupleMember = _ts$SyntaxKind.NamedTupleMember,
 	    MappedType = _ts$SyntaxKind.MappedType,
+	    MinusToken = _ts$SyntaxKind.MinusToken,
+	    PlusToken = _ts$SyntaxKind.PlusToken,
 	    TypeParameter = _ts$SyntaxKind.TypeParameter,
 	    QualifiedName = _ts$SyntaxKind.QualifiedName,
 	    TemplateLiteralType = _ts$SyntaxKind.TemplateLiteralType,
@@ -565,12 +568,26 @@
 	          // For example: {[K in TaskType]: InstanceType etc.
 	          var iterable = toSourceTS(parameter.constraint); // TaskType
 	          var element = toSourceTS(parameter.name); // K
-	          return {
+	          var out = {
 	            type: 'mapping',
 	            iterable: iterable,
 	            element: element,
 	            result: result
 	          };
+	          if (node.nameType) {
+	            // `as` key remapping, e.g. {[K in keyof T as K extends string ? K : never]: ...}
+	            out.nameType = toSourceTS(node.nameType);
+	          }
+	          // Modifiers: `-?` strips optionality, `+?`/`?` force it;
+	          // `-readonly` strips readonly, `+readonly`/`readonly` force it.
+	          // Absent modifiers preserve the source behavior (see createTypeFromMapping).
+	          if (node.questionToken) {
+	            out.question = node.questionToken.kind === MinusToken ? '-' : node.questionToken.kind === PlusToken ? '+' : '?';
+	          }
+	          if (node.readonlyToken) {
+	            out.readonly = node.readonlyToken.kind === MinusToken ? '-' : node.readonlyToken.kind === PlusToken ? '+' : 'readonly';
+	          }
+	          return out;
 	        }
 	        console.warn("MappedType: expected TypeParameter");
 	        return 'transpiler-error';
@@ -797,6 +814,15 @@
 	                optional: true
 	              };
 	            }
+	            if (Array.isArray(member.modifiers) && member.modifiers.some(function (modifier) {
+	              return modifier.kind === ReadonlyKeyword;
+	            })) {
+	              // Tracked for IfEquals-style comparisons; ignored by validation.
+	              if (_type && _typeof(_type) === 'object') _type.readonly = true;else _type = {
+	                type: _type,
+	                readonly: true
+	              };
+	            }
 	            properties[_name2] = _type;
 	          } else {
 	            console.warn('TypeLiteral: unhandled member', member);
@@ -856,6 +882,7 @@
 	    case AnyKeyword:
 	    case BooleanKeyword:
 	    case StringKeyword:
+	    case SymbolKeyword:
 	    case NeverKeyword:
 	    case NullKeyword:
 	    case NumberKeyword:
@@ -936,6 +963,7 @@
 	 */
 	/**
 	 * Splits a string by a delimiter, ignoring delimiters nested inside <>, {}, [], ().
+	 * Quote-aware: delimiters inside '...', "..." or `...` never split.
 	 * @param {string} str - The string to split.
 	 * @param {string} delimiter - Single character delimiter.
 	 * @returns {string[]} Top-level split parts.
@@ -946,28 +974,148 @@
 	  var depthCurly = 0;
 	  var depthSquare = 0;
 	  var depthParen = 0;
+	  var inSingle = false;
+	  var inDouble = false;
+	  var inBacktick = false;
 	  var current = '';
-	  var _iterator = _createForOfIteratorHelper(str),
-	    _step;
-	  try {
-	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-	      var c = _step.value;
+	  for (var i = 0; i < str.length; i++) {
+	    var c = str[i];
+	    var prev = i > 0 ? str[i - 1] : '';
+	    if (c === "'" && !inDouble && !inBacktick && prev !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && !inBacktick && prev !== '\\') inDouble = !inDouble;else if (c === '`' && !inSingle && !inDouble && prev !== '\\') inBacktick = !inBacktick;
+	    var inQuote = inSingle || inDouble || inBacktick;
+	    if (!inQuote) {
 	      if (c === '<') depthAngle++;else if (c === '>') depthAngle--;else if (c === '{') depthCurly++;else if (c === '}') depthCurly--;else if (c === '[') depthSquare++;else if (c === ']') depthSquare--;else if (c === '(') depthParen++;else if (c === ')') depthParen--;
-	      if (c === delimiter && depthAngle === 0 && depthCurly === 0 && depthSquare === 0 && depthParen === 0) {
-	        parts.push(current);
-	        current = '';
-	      } else {
-	        current += c;
-	      }
 	    }
-	  } catch (err) {
-	    _iterator.e(err);
-	  } finally {
-	    _iterator.f();
+	    if (c === delimiter && !inQuote && depthAngle === 0 && depthCurly === 0 && depthSquare === 0 && depthParen === 0) {
+	      parts.push(current);
+	      current = '';
+	    } else {
+	      current += c;
+	    }
 	  }
 	  parts.push(current);
 	  return parts;
 	}
+	/**
+	 * Depth state at a given index, quote-aware.
+	 * @param {string} str - The string to scan.
+	 * @param {number} upto - Exclusive end index.
+	 * @returns {{angle: number, curly: number, square: number, paren: number, quote: boolean}} Depths.
+	 */
+	function depthsAt(str, upto) {
+	  var angle = 0;
+	  var curly = 0;
+	  var square = 0;
+	  var paren = 0;
+	  var inSingle = false;
+	  var inDouble = false;
+	  var inBacktick = false;
+	  for (var i = 0; i < upto; i++) {
+	    var c = str[i];
+	    var prev = i > 0 ? str[i - 1] : '';
+	    if (c === "'" && !inDouble && !inBacktick && prev !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && !inBacktick && prev !== '\\') inDouble = !inDouble;else if (c === '`' && !inSingle && !inDouble && prev !== '\\') inBacktick = !inBacktick;
+	    var inQuote = inSingle || inDouble || inBacktick;
+	    if (inQuote) continue;
+	    if (c === '<') angle++;else if (c === '>') angle--;else if (c === '{') curly++;else if (c === '}') curly--;else if (c === '[') square++;else if (c === ']') square--;else if (c === '(') paren++;else if (c === ')') paren--;
+	  }
+	  return {
+	    angle: angle,
+	    curly: curly,
+	    square: square,
+	    paren: paren,
+	    quote: inSingle || inDouble || inBacktick
+	  };
+	}
+	/**
+	 * Finds a keyword (e.g. `in`, `as`, `extends`) at top level, outside brackets/quotes.
+	 * @param {string} str - The string to search.
+	 * @param {string} keyword - Keyword without surrounding spaces.
+	 * @returns {number} Start index or -1.
+	 */
+	function findTopLevelKeyword(str, keyword) {
+	  var isWord = function isWord(c) {
+	    return /[A-Za-z0-9_$]/.test(c);
+	  };
+	  for (var i = 0; i <= str.length - keyword.length; i++) {
+	    if (str.slice(i, i + keyword.length) !== keyword) continue;
+	    var before = i > 0 ? str[i - 1] : ' ';
+	    var after = i + keyword.length < str.length ? str[i + keyword.length] : ' ';
+	    if (isWord(before) || isWord(after)) continue;
+	    var d = depthsAt(str, i);
+	    if (d.angle === 0 && d.curly === 0 && d.square === 0 && d.paren === 0 && !d.quote) {
+	      // Ensure remainder after keyword is also top-level (keyword itself not quoted).
+	      var d2 = depthsAt(str, i + keyword.length);
+	      if (!d2.quote) return i;
+	    }
+	  }
+	  return -1;
+	}
+	/**
+	 * Finds a single-char delimiter at top level, outside brackets/quotes.
+	 * @param {string} str - The string to search.
+	 * @param {string} delimiter - Single character.
+	 * @param {number} from - Start index.
+	 * @returns {number} Index or -1.
+	 */
+	function findTopLevelChar(str, delimiter) {
+	  var from = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+	  var angle = 0;
+	  var curly = 0;
+	  var square = 0;
+	  var paren = 0;
+	  var inSingle = false;
+	  var inDouble = false;
+	  var inBacktick = false;
+	  for (var i = 0; i < str.length; i++) {
+	    var c = str[i];
+	    // Check at depths *before* the current char, so `[` itself is findable.
+	    var inQuoteBefore = inSingle || inDouble || inBacktick;
+	    if (i >= from && c === delimiter && !inQuoteBefore && angle === 0 && curly === 0 && square === 0 && paren === 0) {
+	      return i;
+	    }
+	    var prev = i > 0 ? str[i - 1] : '';
+	    if (c === "'" && !inDouble && !inBacktick && prev !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && !inBacktick && prev !== '\\') inDouble = !inDouble;else if (c === '`' && !inSingle && !inDouble && prev !== '\\') inBacktick = !inBacktick;
+	    var inQuote = inSingle || inDouble || inBacktick;
+	    if (!inQuote) {
+	      if (c === '<') angle++;else if (c === '>') angle--;else if (c === '{') curly++;else if (c === '}') curly--;else if (c === '[') square++;else if (c === ']') square--;else if (c === '(') paren++;else if (c === ')') paren--;
+	    }
+	  }
+	  return -1;
+	}
+	/**
+	 * Strips balanced outer parens, e.g. `(( T ))` -> `T`.
+	 * @param {string} type - Trimmed type string.
+	 * @returns {string} Unwrapped type.
+	 */
+	function stripOuterParens(type) {
+	  var changed = true;
+	  while (changed) {
+	    changed = false;
+	    if (type.length >= 2 && type[0] === '(' && type[type.length - 1] === ')') {
+	      var depth = 0;
+	      var balanced = true;
+	      var inSingle = false;
+	      var inDouble = false;
+	      for (var i = 0; i < type.length; i++) {
+	        var c = type[i];
+	        if (c === "'" && !inDouble && type[i - 1] !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && type[i - 1] !== '\\') inDouble = !inDouble;else if (!inSingle && !inDouble) {
+	          if (c === '(') depth++;else if (c === ')') {
+	            depth--;
+	            if (depth === 0 && i !== type.length - 1) {
+	              balanced = false;
+	              break;
+	            }
+	          }
+	        }
+	      }
+	      if (balanced && depth === 0) {
+	        type = type.slice(1, -1).trim();
+	        changed = true;
+	      }
+	    }
+	  }
+	  return type;
+	}
 	/**
 	 * Parses `Name<A, B>` into name + raw arg strings, respecting nested brackets.
 	 * Returns undefined when input isn't a generic reference.
@@ -1012,6 +1160,190 @@
 	    args: args
 	  };
 	}
+	/**
+	 * Parses `{[K in Iterable as NameType]?: Result}` mapped syntax.
+	 * Returns undefined when input isn't a mapped type.
+	 * @param {string} type - Trimmed type string starting with `{`.
+	 * @returns {object|undefined} Mapping struct with raw strings, or undefined.
+	 */
+	function parseMappedRaw(type) {
+	  if (type[0] !== '{' || type[type.length - 1] !== '}') {
+	    return;
+	  }
+	  var inner = type.slice(1, -1).trim();
+	  var readonly;
+	  if (inner.startsWith('-readonly') && (inner[9] === ' ' || inner[9] === '[')) {
+	    readonly = '-';
+	    inner = inner.slice(9).trim();
+	  } else if (inner.startsWith('+readonly') && (inner[9] === ' ' || inner[9] === '[')) {
+	    readonly = '+';
+	    inner = inner.slice(9).trim();
+	  } else if (inner.startsWith('readonly') && (inner[8] === ' ' || inner[8] === '[')) {
+	    readonly = 'readonly';
+	    inner = inner.slice(8).trim();
+	  }
+	  if (inner[0] !== '[') {
+	    return;
+	  }
+	  // Find matching `]` for the opening `[`, quote-aware.
+	  var square = 0;
+	  var inSingle = false;
+	  var inDouble = false;
+	  var inBacktick = false;
+	  var close = -1;
+	  for (var i = 0; i < inner.length; i++) {
+	    var c = inner[i];
+	    var prev = i > 0 ? inner[i - 1] : '';
+	    if (c === "'" && !inDouble && !inBacktick && prev !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && !inBacktick && prev !== '\\') inDouble = !inDouble;else if (c === '`' && !inSingle && !inDouble && prev !== '\\') inBacktick = !inBacktick;else if (!inSingle && !inDouble && !inBacktick) {
+	      if (c === '[') square++;else if (c === ']') {
+	        square--;
+	        if (square === 0) {
+	          close = i;
+	          break;
+	        }
+	      }
+	    }
+	  }
+	  if (close === -1) {
+	    return;
+	  }
+	  var bracket = inner.slice(1, close);
+	  var rest = inner.slice(close + 1).trim();
+	  var question;
+	  if (rest.startsWith('-?')) {
+	    question = '-';
+	    rest = rest.slice(2).trim();
+	  } else if (rest.startsWith('+?')) {
+	    question = '+';
+	    rest = rest.slice(2).trim();
+	  } else if (rest.startsWith('?')) {
+	    question = '?';
+	    rest = rest.slice(1).trim();
+	  }
+	  if (!rest.startsWith(':')) {
+	    return;
+	  }
+	  var resultRaw = rest.slice(1).trim();
+	  if (!resultRaw) {
+	    return;
+	  }
+	  var inIdx = findTopLevelKeyword(bracket, 'in');
+	  if (inIdx === -1) {
+	    return;
+	  }
+	  var element = bracket.slice(0, inIdx).trim();
+	  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(element)) {
+	    return;
+	  }
+	  var afterIn = bracket.slice(inIdx + 2).trim();
+	  if (!afterIn) {
+	    return;
+	  }
+	  var asIdx = findTopLevelKeyword(afterIn, 'as');
+	  var iterableRaw = afterIn;
+	  var nameRaw;
+	  if (asIdx !== -1) {
+	    iterableRaw = afterIn.slice(0, asIdx).trim();
+	    nameRaw = afterIn.slice(asIdx + 2).trim();
+	    if (!iterableRaw || !nameRaw) {
+	      return;
+	    }
+	  }
+	  return {
+	    element: element,
+	    iterableRaw: iterableRaw,
+	    nameRaw: nameRaw,
+	    resultRaw: resultRaw,
+	    question: question,
+	    readonly: readonly
+	  };
+	}
+	/**
+	 * Splits `Check extends Extends ? True : False` at top level.
+	 * Returns undefined when input isn't a conditional type.
+	 * @param {string} type - Trimmed type string.
+	 * @returns {{check: string, extends_: string, true_: string, false_: string}|undefined} Raw parts.
+	 */
+	function parseConditionRaw(type) {
+	  var qIdx = findTopLevelChar(type, '?');
+	  if (qIdx === -1) {
+	    return;
+	  }
+	  var beforeQ = type.slice(0, qIdx);
+	  var afterQ = type.slice(qIdx + 1);
+	  var extIdx = findTopLevelKeyword(beforeQ, 'extends');
+	  if (extIdx === -1) {
+	    return;
+	  }
+	  var colonIdx = findTopLevelChar(afterQ, ':');
+	  if (colonIdx === -1) {
+	    return;
+	  }
+	  var check = beforeQ.slice(0, extIdx).trim();
+	  var extends_ = beforeQ.slice(extIdx + 7).trim();
+	  var true_ = afterQ.slice(0, colonIdx).trim();
+	  var false_ = afterQ.slice(colonIdx + 1).trim();
+	  if (!check || !extends_ || !true_ || !false_) {
+	    return;
+	  }
+	  // Guard against `?.` optional chaining and `??` nullish coalescing.
+	  if (type[qIdx + 1] === '.' || type[qIdx + 1] === '?') {
+	    return;
+	  }
+	  return {
+	    check: check,
+	    extends_: extends_,
+	    true_: true_,
+	    false_: false_
+	  };
+	}
+	/**
+	 * Splits `Object[Index]` at top level. Excludes tuples (`[...]`) and
+	 * empty-index arrays (`T[]`, handled earlier).
+	 * @param {string} type - Trimmed type string.
+	 * @returns {{objectRaw: string, indexRaw: string}|undefined} Raw parts.
+	 */
+	function parseIndexedAccessRaw(type) {
+	  if (!type.endsWith(']') || type.endsWith('[]')) {
+	    return;
+	  }
+	  if (type[0] === '[') {
+	    return;
+	  }
+	  var openIdx = findTopLevelChar(type, '[');
+	  if (openIdx === -1) {
+	    return;
+	  }
+	  // Ensure the `[` at openIdx closes at the very end.
+	  var square = 0;
+	  var inSingle = false;
+	  var inDouble = false;
+	  var inBacktick = false;
+	  for (var i = openIdx; i < type.length; i++) {
+	    var c = type[i];
+	    var prev = i > 0 ? type[i - 1] : '';
+	    if (c === "'" && !inDouble && !inBacktick && prev !== '\\') inSingle = !inSingle;else if (c === '"' && !inSingle && !inBacktick && prev !== '\\') inDouble = !inDouble;else if (c === '`' && !inSingle && !inDouble && prev !== '\\') inBacktick = !inBacktick;else if (!inSingle && !inDouble && !inBacktick) {
+	      if (c === '[') square++;else if (c === ']') {
+	        square--;
+	        if (square === 0 && i !== type.length - 1) {
+	          return;
+	        }
+	      }
+	    }
+	  }
+	  if (square !== 0) {
+	    return;
+	  }
+	  var objectRaw = type.slice(0, openIdx).trim();
+	  var indexRaw = type.slice(openIdx + 1, -1).trim();
+	  if (!objectRaw || !indexRaw) {
+	    return;
+	  }
+	  return {
+	    objectRaw: objectRaw,
+	    indexRaw: indexRaw
+	  };
+	}
 	/**
 	 * 'DepFree' refers to the fact that this function has no dependencies,
 	 * while `expandType` depends on TypeScript itself for maximum compatibility.
@@ -1027,6 +1359,33 @@
 	 */
 	function expandTypeDepFree(type) {
 	  type = type.trim();
+	  // '(123)' -> '123': strip balanced outer parens first so `(cond)?`
+	  // nullable and `(A|B)` unions see through them.
+	  var stripped = stripOuterParens(type);
+	  if (stripped !== type) {
+	    return expandTypeDepFree(stripped);
+	  }
+	  // `readonly T` erased at runtime, same shape as the inner type.
+	  if (type.startsWith('readonly ') && type.length > 9) {
+	    return expandTypeDepFree(type.slice(9).trim());
+	  }
+	  if (type === 'unique symbol') {
+	    return 'any';
+	  }
+	  // Conditionals before nullable: `A extends B ? C : D?` must keep the
+	  // nullable on the false branch, not lift it over the whole condition.
+	  // (`(cond)?` has no top-level `?` due to parens, so it falls through
+	  // to nullable below.)
+	  var earlyCond = parseConditionRaw(type);
+	  if (earlyCond) {
+	    return {
+	      type: 'condition',
+	      checkType: expandTypeDepFree(earlyCond.check),
+	      extendsType: expandTypeDepFree(earlyCond.extends_),
+	      trueType: expandTypeDepFree(earlyCond.true_),
+	      falseType: expandTypeDepFree(earlyCond.false_)
+	    };
+	  }
 	  // JSDocNullableType (`T?` / `?T`): union with null, matching expandType().
 	  if (type.endsWith('?') && type.length > 1) {
 	    return {
@@ -1040,20 +1399,9 @@
 	      members: [expandTypeDepFree(type.slice(1).trim()), 'null']
 	    };
 	  }
-	  // `readonly T` erased at runtime, same shape as the inner type.
-	  if (type.startsWith('readonly ') && type.length > 9) {
-	    return expandTypeDepFree(type.slice(9).trim());
-	  }
-	  if (type === 'unique symbol') {
-	    return 'any';
-	  }
-	  // '(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] === '.') {
-	    var elementType = type.slice(3);
+	    var elementType = expandTypeDepFree(type.slice(3).trim());
 	    return {
 	      type: 'array',
 	      elementType: elementType
@@ -1081,17 +1429,18 @@
 	  // (3) Object<...> or Record<...>
 	  if ((type.startsWith("Object<") || type.startsWith("Record<")) && type.endsWith('>')) {
 	    var recordSlice = type.slice(7, -1);
-	    var firstComma = recordSlice.indexOf(',');
-	    if (firstComma === -1) {
+	    var commaIdx = findTopLevelChar(recordSlice, ',');
+	    if (commaIdx === -1) {
 	      console.warn("expandTypeDepFree> invalid Object/Record");
+	    } else {
+	      var key = recordSlice.slice(0, commaIdx).trim();
+	      var val = recordSlice.slice(commaIdx + 1).trim();
+	      return {
+	        type: "record",
+	        key: expandTypeDepFree(key),
+	        val: expandTypeDepFree(val)
+	      };
 	    }
-	    var key = recordSlice.slice(0, firstComma).trim();
-	    var val = recordSlice.slice(firstComma + 1).trim();
-	    return {
-	      type: "record",
-	      key: expandTypeDepFree(key),
-	      val: expandTypeDepFree(val)
-	    };
 	  }
 	  // (3b) Map<...> / Set<...' for dep-free parity with expandType()
 	  if (type.startsWith("Map<") && type.endsWith('>')) {
@@ -1124,40 +1473,109 @@
 	      args: args.map(expandTypeDepFree)
 	    };
 	  }
-	  // (4) {...}
+	  // (4) Mapped types `{[K in X as Y]?: Z}` before the object-literal fallback.
 	  if (type[0] === '{' && type[type.length - 1] === '}') {
-	    var propertiesArray = type.slice(1, -1).split(','); // ['entity: Entity', ' app: AppBase']
+	    var mapped = parseMappedRaw(type);
+	    if (mapped) {
+	      var out = {
+	        type: 'mapping',
+	        iterable: expandTypeDepFree(mapped.iterableRaw),
+	        element: mapped.element,
+	        result: expandTypeDepFree(mapped.resultRaw)
+	      };
+	      if (mapped.nameRaw !== undefined) {
+	        out.nameType = expandTypeDepFree(mapped.nameRaw);
+	      }
+	      if (mapped.question !== undefined) {
+	        out.question = mapped.question;
+	      }
+	      if (mapped.readonly !== undefined) {
+	        out.readonly = mapped.readonly;
+	      }
+	      return out;
+	    }
+	    var propertiesArray = splitTopLevel(type.slice(1, -1), ','); // ['entity: Entity', ' app: AppBase']
 	    var properties = {};
-	    propertiesArray.forEach(function (_) {
-	      var _$split$map = _.split(":").map(function (_) {
-	          return _.trim();
-	        }),
-	        _$split$map2 = _slicedToArray(_$split$map, 2),
-	        propName = _$split$map2[0],
-	        propType = _$split$map2[1];
-	      if (!propName || !propType) {
-	        console.warn('expandTypeDepFree> unexpected type format, fix');
-	        return false;
+	    var _iterator = _createForOfIteratorHelper(propertiesArray),
+	      _step;
+	    try {
+	      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	        var entry = _step.value;
+	        var colonIdx = findTopLevelChar(entry, ':');
+	        if (colonIdx === -1) {
+	          // Empty `{}` yields one empty entry: the empty object type.
+	          if (entry.trim() === '') {
+	            continue;
+	          }
+	          console.warn('expandTypeDepFree> unexpected type format, fix');
+	          continue;
+	        }
+	        var propName = entry.slice(0, colonIdx).trim();
+	        var propTypeRaw = entry.slice(colonIdx + 1).trim();
+	        if (!propName || !propTypeRaw) {
+	          console.warn('expandTypeDepFree> unexpected type format, fix');
+	          continue;
+	        }
+	        properties[propName] = expandTypeDepFree(propTypeRaw);
 	      }
-	      properties[propName] = propType;
-	    });
+	      // Bare `{}` carries no `properties` key, matching the TS/Babel parsers
+	      // (and distinguishing it from the `object` keyword, which does).
+	    } catch (err) {
+	      _iterator.e(err);
+	    } finally {
+	      _iterator.f();
+	    }
+	    if (!Object.keys(properties).length) {
+	      return {
+	        type: 'object'
+	      };
+	    }
 	    return {
 	      type: 'object',
 	      properties: properties
 	    };
 	  }
-	  // (5) expand unions
-	  var members = type.split("|");
-	  if (members.length >= 2) {
-	    members.forEach(function (_, i) {
-	      return members[i] = _.trim();
-	    });
+	  // (5) Unions and intersections via top-level splits (`&` binds tighter, so `|` first).
+	  // Note: conditionals already handled up front (before nullable) so `D?`
+	  // false branches keep their nullability; this slot is intentionally union-only.
+	  var unionParts = splitTopLevel(type, "|");
+	  if (unionParts.length >= 2) {
 	    return {
 	      type: 'union',
-	      members: members.map(expandTypeDepFree)
+	      members: unionParts.map(function (_) {
+	        return expandTypeDepFree(_.trim());
+	      })
+	    };
+	  }
+	  var interParts = splitTopLevel(type, "&");
+	  if (interParts.length >= 2) {
+	    return {
+	      type: 'intersection',
+	      members: interParts.map(function (_) {
+	        return expandTypeDepFree(_.trim());
+	      })
+	    };
+	  }
+	  // (7) `keyof T` before typeof so `keyof typeof X` nests correctly.
+	  if (type.startsWith('keyof ') || type.startsWith('keyof(')) {
+	    var after = type.startsWith('keyof(') ? type.slice(5).trim() : type.slice(6).trim();
+	    if (after) {
+	      return {
+	        type: 'keyof',
+	        argument: expandTypeDepFree(after)
+	      };
+	    }
+	  }
+	  // (8) Indexed access `T[K]` (arrays `T[]` handled below, tuples above start with `[`).
+	  var indexed = parseIndexedAccessRaw(type);
+	  if (indexed) {
+	    return {
+	      type: 'indexedAccess',
+	      index: expandTypeDepFree(indexed.indexRaw),
+	      object: expandTypeDepFree(indexed.objectRaw)
 	    };
 	  }
-	  // (6) expand [] Arrays
+	  // (9) expand [] Arrays
 	  // Test arrays: new pc.Mat3().set([1, 2, 3, "asd"])
 	  if (type.endsWith("[]")) {
 	    var _typeSlice2 = type.slice(0, -2);
@@ -1166,17 +1584,26 @@
 	      elementType: expandTypeDepFree(_typeSlice2)
 	    };
 	  }
-	  // (7) expand tuples
+	  // (10) expand tuples
 	  if (type[0] === '[' && type[type.length - 1] === ']') {
-	    var elements = type.slice(1, -1).split(','); // ['null', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture']
+	    var _inner2 = type.slice(1, -1);
+	    if (_inner2.trim() === '') {
+	      return {
+	        type: 'tuple',
+	        elements: []
+	      };
+	    }
+	    var elements = splitTopLevel(_inner2, ','); // ['null', ' Texture', ...]
 	    return {
 	      type: 'tuple',
-	      elements: elements.map(expandTypeDepFree)
+	      elements: elements.map(function (_) {
+	        return expandTypeDepFree(_.trim());
+	      })
 	    };
 	  }
-	  // (8) expand typeof expressions
+	  // (11) expand typeof expressions
 	  if (type.startsWith('typeof ')) {
-	    var argument = expandTypeDepFree(type.substring(7));
+	    var argument = expandTypeDepFree(type.substring(7).trim());
 	    return {
 	      type: 'typeof',
 	      argument: argument
@@ -1202,79 +1629,6 @@
 	  return type;
 	}
 
-	/**
-	 * Infers a parameter type from its default value AST node.
-	 * Returns widened types like TypeScript does (`= 0` means `number`, not
-	 * literal `0`; `= null` widens to `any`).
-	 * Returns `undefined` when nothing useful can be inferred — the caller then
-	 * emits no check, exactly like an undocumented parameter today.
-	 * Shapes match what `expandType` produces so they can be embedded as-is.
-	 * @param {import('@babel/types').Node} node - The default value AST node.
-	 * @returns {string | object | undefined} Inferred type or `undefined` to skip.
-	 */
-	function inferTypeFromDefault$1(node) {
-	  if (!node) {
-	    return;
-	  }
-	  switch (node.type) {
-	    case 'NumericLiteral':
-	      return 'number';
-	    case 'StringLiteral':
-	      return 'string';
-	    case 'BooleanLiteral':
-	      return 'boolean';
-	    case 'BigIntLiteral':
-	      return {
-	        type: 'bigint'
-	      };
-	    case 'RegExpLiteral':
-	      return 'RegExp';
-	    case 'TemplateLiteral':
-	      return 'string';
-	    case 'ArrayExpression':
-	      return {
-	        type: 'array',
-	        elementType: 'any'
-	      };
-	    case 'ObjectExpression':
-	      return {
-	        type: 'object',
-	        properties: {}
-	      };
-	    case 'ArrowFunctionExpression':
-	    case 'FunctionExpression':
-	      return 'Function';
-	    case 'NewExpression':
-	      {
-	        var callee = node.callee;
-	        if (callee.type === 'Identifier') {
-	          return callee.name;
-	        }
-	        break;
-	      }
-	    case 'UnaryExpression':
-	      {
-	        var operator = node.operator,
-	          argument = node.argument;
-	        if (operator === '!') {
-	          return 'boolean';
-	        }
-	        if (operator === 'void' || operator === 'typeof') {
-	          return operator === 'void' ? 'undefined' : 'string';
-	        }
-	        if ((operator === '-' || operator === '+') && argument.type === 'NumericLiteral') {
-	          return 'number';
-	        }
-	        if ((operator === '-' || operator === '+') && argument.type === 'BigIntLiteral') {
-	          return {
-	            type: 'bigint'
-	          };
-	        }
-	        break;
-	      }
-	  }
-	}
-
 	/**
 	 * Extracts the parameter name and its optionality from a JSDoc parameter string.
 	 *
@@ -1339,73 +1693,863 @@
 	 *
 	 * It iterates through the lines of a `CommentBlock` from the Babel AST, looking for `@typedef` and `@property`
 	 * annotations. When it finds a typedef, it stores it in the `typedefs` record. When it finds a property,
-	 * it adds it to the last found typedef if it is an object type.
+	 * it adds it to the last found typedef if it is an object type. `@template` names preceding a
+	 * typedef are recorded in `typedefTemplates` so generic references can instantiate.
 	 * @param {Record<string, object>} typedefs - An object to store typedefs, mapping type names to their expanded definitions.
+	 * @param {Record<string, string[]>} typedefTemplates - An object to store template parameter names per generic typedef.
 	 * @param {Console["warn"]} warn - A warn function used for emitting warnings about non-extensible types.
 	 * @param {import("@babel/types").Comment} comment - A comment extracted from Babel's AST, expected to be a CommentBlock containing type definitions.
 	 * @param {Function} expandType - A function that takes a type expression as a string and returns a structured representation of the type.
 	 */
-	function parseJSDocTypedef(typedefs, warn, comment, expandType) {
-	  var type = comment.type,
-	    value = comment.value;
-	  if (type !== 'CommentBlock') {
+	function parseJSDocTypedef(typedefs, typedefTemplates, warn, comment, expandType) {
+	  var type = comment.type,
+	    value = comment.value;
+	  if (type !== 'CommentBlock') {
+	    return;
+	  }
+	  var lines = value.split('\n');
+	  var lastTypedef;
+	  var pendingTemplates = [];
+	  /**
+	   * @param {string} line - The trimmed JSDoc line.
+	   * @returns {boolean} True when the line held a template tag.
+	   */
+	  function harvestTemplate(line) {
+	    var match = line.match(/@template \{(.*?)\} ([a-zA-Z0-9_$]+)/);
+	    if (match) {
+	      pendingTemplates.push(match[2]);
+	      return true;
+	    }
+	    match = line.match(/@template (?:\{.*?\} )?\[([a-zA-Z0-9_$]+)=/);
+	    if (match) {
+	      pendingTemplates.push(match[1]);
+	      return true;
+	    }
+	    match = line.match(/@template ([a-zA-Z0-9_$]+)(?![a-zA-Z0-9_$])/);
+	    if (match) {
+	      pendingTemplates.push(match[1]);
+	      return true;
+	    }
+	    return false;
+	  }
+	  var _iterator = _createForOfIteratorHelper(lines),
+	    _step;
+	  try {
+	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	      var line = _step.value;
+	      line = line.trim();
+	      if (line[0] === '*') {
+	        line = line.slice(1).trim();
+	      }
+	      if (line.startsWith('@template')) {
+	        harvestTemplate(line);
+	      } else if (line.startsWith('@typedef')) {
+	        var _extractCurlyContent = extractCurlyContent(line),
+	          def = _extractCurlyContent.content,
+	          nextIndex = _extractCurlyContent.nextIndex;
+	        var name = line.substring(nextIndex).trim();
+	        // Drop description
+	        name = name.split(' ')[0];
+	        lastTypedef = expandType(def);
+	        // Ignore @typedef's that only refer to themselves in another file (see typedef-overwrite test)
+	        if (lastTypedef !== name) {
+	          typedefs[name] = lastTypedef;
+	          if (pendingTemplates.length) {
+	            typedefTemplates[name] = _toConsumableArray(pendingTemplates);
+	          }
+	        }
+	        pendingTemplates = [];
+	      } else if (line.startsWith('@property')) {
+	        var _lastTypedef;
+	        // class @property
+	        if (!lastTypedef) {
+	          continue;
+	        }
+	        var _extractCurlyContent2 = extractCurlyContent(line),
+	          content = _extractCurlyContent2.content,
+	          _nextIndex = _extractCurlyContent2.nextIndex;
+	        var rest = line.substring(_nextIndex);
+	        var propType = expandType(content);
+	        var _extractNameAndOption = extractNameAndOptionality(rest),
+	          _extractNameAndOption2 = _slicedToArray(_extractNameAndOption, 2),
+	          _name = _extractNameAndOption2[0],
+	          optional = _extractNameAndOption2[1];
+	        // console.log({name, optional, propType});
+	        var finalType = annotateOptional(propType, optional);
+	        if (((_lastTypedef = lastTypedef) === null || _lastTypedef === void 0 ? void 0 : _lastTypedef.type) === 'object') {
+	          lastTypedef.properties[_name] = finalType;
+	        } else {
+	          warn("not an extensible type", lastTypedef);
+	        }
+	      } else if (line.startsWith('@callback')) {
+	        var _name2 = line.substring(9).trim();
+	        typedefs[_name2] = 'Function';
+	      }
+	    }
+	  } catch (err) {
+	    _iterator.e(err);
+	  } finally {
+	    _iterator.f();
+	  }
+	}
+
+	/**
+	 * @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 {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, ExpandTypeReturnType>} */
+	  var params = Object.create(null);
+	  matches.forEach(function (_) {
+	    var type = expandType(_[1].trim());
+	    var name = _[2].trim();
+	    var optional = false;
+	    // Examples:
+	    //   name: [kwargs={}] The configuration parameters.
+	    //   name: [d = 1.0] Sample spacing
+	    if (name[0] === '[') {
+	      // Counting opening/closing brackets for perfect match
+	      var openCloseCount = 1;
+	      var i = 1;
+	      for (; i < name.length; i++) {
+	        var c = name[i];
+	        if (c === '[') {
+	          openCloseCount++;
+	        } else if (c === ']') {
+	          openCloseCount--;
+	        }
+	        if (openCloseCount === 0) {
+	          break;
+	        }
+	      }
+	      // Afterwards name will be: d = 1.0
+	      name = name.substring(1, i);
+	      // mark it for the type:
+	      optional = true;
+	    }
+	    // Strip the rest (either leftover of optional value or description)
+	    name = name.split(' ')[0].split('=')[0].trim();
+	    var annotatedType = annotateOptional(type, optional);
+	    // 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 `annotatedType`.
+	          console.assert(part === parts.at(-1), 'Current part and last part should be the same.');
+	          properties[part] = annotatedType;
+	        } 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,
+	            annotatedType: annotatedType
+	          });
+	        }
+	      }
+	    } catch (err) {
+	      _iterator.e(err);
+	    } finally {
+	      _iterator.f();
+	    }
+	  });
+	  if (Object.keys(params).length === 0) {
+	    return;
+	  }
+	  return params;
+	}
+
+	/**
+	 * Infers a parameter type from its default value AST node.
+	 * Returns widened types like TypeScript does (`= 0` means `number`, not
+	 * literal `0`; `= null` widens to `any`).
+	 * Returns `undefined` when nothing useful can be inferred — the caller then
+	 * emits no check, exactly like an undocumented parameter today.
+	 * Shapes match what `expandType` produces so they can be embedded as-is.
+	 * @param {import('@babel/types').Node} node - The default value AST node.
+	 * @returns {string | object | undefined} Inferred type or `undefined` to skip.
+	 */
+	function inferTypeFromDefault$1(node) {
+	  if (!node) {
+	    return;
+	  }
+	  switch (node.type) {
+	    case 'NumericLiteral':
+	      return 'number';
+	    case 'StringLiteral':
+	      return 'string';
+	    case 'BooleanLiteral':
+	      return 'boolean';
+	    case 'BigIntLiteral':
+	      return {
+	        type: 'bigint'
+	      };
+	    case 'RegExpLiteral':
+	      return 'RegExp';
+	    case 'TemplateLiteral':
+	      return 'string';
+	    case 'ArrayExpression':
+	      return {
+	        type: 'array',
+	        elementType: 'any'
+	      };
+	    case 'ObjectExpression':
+	      return {
+	        type: 'object',
+	        properties: {}
+	      };
+	    case 'ArrowFunctionExpression':
+	    case 'FunctionExpression':
+	      return 'Function';
+	    case 'NewExpression':
+	      {
+	        var callee = node.callee;
+	        if (callee.type === 'Identifier') {
+	          return callee.name;
+	        }
+	        break;
+	      }
+	    case 'UnaryExpression':
+	      {
+	        var operator = node.operator,
+	          argument = node.argument;
+	        if (operator === '!') {
+	          return 'boolean';
+	        }
+	        if (operator === 'void' || operator === 'typeof') {
+	          return operator === 'void' ? 'undefined' : 'string';
+	        }
+	        if ((operator === '-' || operator === '+') && argument.type === 'NumericLiteral') {
+	          return 'number';
+	        }
+	        if ((operator === '-' || operator === '+') && argument.type === 'BigIntLiteral') {
+	          return {
+	            type: 'bigint'
+	          };
+	        }
+	        break;
+	      }
+	  }
+	}
+
+	// Declaration-site ranks: the field always beats constructor assignments,
+	// like TSC where the declared type wins over assigned values.
+	var FIELD_JSDOC = 3;
+	var CTOR_JSDOC = 2;
+	var FIELD_INFER = 1;
+	var CTOR_INFER = 0;
+	/**
+	 * Reads the last block comment attached to a node.
+	 * @param {*} node - Babel AST node.
+	 * @returns {string|undefined} Comment text or undefined.
+	 */
+	function lastBlockComment(node) {
+	  var list = node === null || node === void 0 ? void 0 : node.leadingComments;
+	  if (!list) {
+	    return;
+	  }
+	  for (var i = list.length - 1; i >= 0; i--) {
+	    if (list[i].type === 'CommentBlock') {
+	      return list[i].value;
+	    }
+	  }
+	}
+	/**
+	 * Extracts a `{...}`-typed JSDoc tag (`@type`, `@returns`) from a comment.
+	 * @param {string|undefined} comment - Comment text.
+	 * @param {string} tag - Tag name including `@`.
+	 * @param {Function} expandType - String type to structured type.
+	 * @returns {{type: *, raw: string}|undefined} Expanded type plus raw text.
+	 */
+	function tagType(comment, tag, expandType) {
+	  if (!comment) {
+	    return;
+	  }
+	  var idx = comment.search(new RegExp("".concat(tag, "(?=[\\s{])")));
+	  if (idx === -1) {
+	    return;
+	  }
+	  var slice = comment.slice(idx);
+	  if (!slice.includes('{')) {
+	    return;
+	  }
+	  try {
+	    var _extractCurlyContent = extractCurlyContent(slice),
+	      content = _extractCurlyContent.content;
+	    if (!content || !content.trim()) {
+	      return;
+	    }
+	    return {
+	      type: expandType(content.trim()),
+	      raw: content.trim()
+	    };
+	  } catch (_unused) {
+	    // Unparseable annotation: fail open, harvest continues.
+	  }
+	}
+	/**
+	 * Reads a static property name: identifiers and string literals, including
+	 * computed `['name']` forms. Anything dynamic yields undefined.
+	 * @param {*} key - Babel key node.
+	 * @param {boolean} computed - Whether the key position is computed.
+	 * @returns {string|undefined} Property name or undefined.
+	 */
+	function keyName(key, computed) {
+	  if (!key) {
+	    return;
+	  }
+	  if (key.type === 'Identifier' && !computed) {
+	    return key.name;
+	  }
+	  if (key.type === 'StringLiteral') {
+	    return key.value;
+	  }
+	}
+	/**
+	 * Unwraps parenthesized and TS `as`/`satisfies` nodes.
+	 * @param {*} node - Babel AST node.
+	 * @returns {*} Unwrapped node.
+	 */
+	function unwrap(node) {
+	  while (node && (node.type === 'ParenthesizedExpression' || node.type === 'TSAsExpression' || node.type === 'TSSatisfiesExpression')) {
+	    node = node.expression;
+	  }
+	  return node;
+	}
+	/**
+	 * Merges a harvested entry: higher rank wins the type, flags accumulate
+	 * (`optional` reflects runtime reality, `@readonly` anywhere counts).
+	 * Two disagreeing humans (JSDoc vs JSDoc) warn, like a TSC error.
+	 * @param {Record<string, object>} fields - Collected entries by name.
+	 * @param {string} name - Property name.
+	 * @param {object} entry - Entry with type, rank, raw, readonly, optional.
+	 * @param {Function} warn - Transpile-time warning function.
+	 * @param {string} className - Class name for messages.
+	 */
+	function record(fields, name, entry, warn, className) {
+	  var existing = fields[name];
+	  if (!existing) {
+	    fields[name] = entry;
+	    return;
+	  }
+	  if (entry.jsdoc && existing.jsdoc && entry.raw !== existing.raw) {
+	    warn("harvestClassShape: ".concat(className, ".").concat(name, " has conflicting JSDoc types (").concat(existing.raw, " vs ").concat(entry.raw, ")"));
+	  }
+	  var winner = entry.rank >= existing.rank ? entry : existing;
+	  winner.readonly = existing.readonly || entry.readonly;
+	  winner.optional = existing.optional || entry.optional;
+	  fields[name] = winner;
+	}
+	/**
+	 * Turns a collected entry into a type struct, applying flags.
+	 * @param {object} entry - Collected entry.
+	 * @returns {*} Type struct or name.
+	 */
+	function entryToType(entry) {
+	  var _entry$type;
+	  var t = (_entry$type = entry.type) !== null && _entry$type !== void 0 ? _entry$type : 'any';
+	  if (!entry.readonly && !entry.optional) {
+	    return t;
+	  }
+	  if (t && _typeof(t) === 'object') {
+	    return _objectSpread2(_objectSpread2(_objectSpread2({}, t), entry.readonly ? {
+	      readonly: true
+	    } : {}), entry.optional ? {
+	      optional: true
+	    } : {});
+	  }
+	  var out = {
+	    type: t
+	  };
+	  if (entry.readonly) {
+	    out.readonly = true;
+	  }
+	  if (entry.optional) {
+	    out.optional = true;
+	  }
+	  return out;
+	}
+	/**
+	 * Records `this.x = ...` (or `+=`, `++`) assignments.
+	 * @param {*} left - Assignment target.
+	 * @param {*} right - Assigned value or undefined for op-assign/update.
+	 * @param {string|undefined} comment - Leading comment text.
+	 * @param {boolean} conditional - True inside conditionals (counts as optional).
+	 * @param {object} ctx - Harvest context with fields, expandType, warn, className.
+	 */
+	function recordThisAssign(left, right, comment, conditional, ctx) {
+	  var _declared$type;
+	  var fields = ctx.fields,
+	    expandType = ctx.expandType,
+	    warn = ctx.warn,
+	    className = ctx.className;
+	  left = unwrap(left);
+	  if (!left || left.type !== 'MemberExpression' || left.computed) {
+	    return;
+	  }
+	  if (!left.object || left.object.type !== 'ThisExpression') {
+	    return;
+	  }
+	  var name = keyName(left.property, false);
+	  if (name === undefined) {
+	    return;
+	  }
+	  var declared = tagType(comment, '@type', expandType);
+	  if (right === undefined) {
+	    // Op-assign/update (`+=`, `++`): exists, type unknown.
+	    record(fields, name, {
+	      type: 'any',
+	      rank: CTOR_INFER,
+	      jsdoc: false,
+	      optional: conditional
+	    }, warn, className);
+	    return;
+	  }
+	  var inferred = inferTypeFromDefault$1(unwrap(right));
+	  var type = (_declared$type = declared === null || declared === void 0 ? void 0 : declared.type) !== null && _declared$type !== void 0 ? _declared$type : inferred;
+	  if (type === undefined) {
+	    return;
+	  }
+	  record(fields, name, {
+	    type: type,
+	    rank: declared ? CTOR_JSDOC : CTOR_INFER,
+	    jsdoc: declared !== undefined,
+	    raw: declared === null || declared === void 0 ? void 0 : declared.raw,
+	    optional: conditional
+	  }, warn, className);
+	}
+	/**
+	 * Handles `Object.assign(this, {...})` with inline object literals.
+	 * @param {*} node - CallExpression node.
+	 * @param {boolean} conditional - True inside conditionals.
+	 * @param {object} ctx - Harvest context.
+	 * @returns {boolean} True when the call was `Object.assign` on `this`.
+	 */
+	function recordObjectAssign(node, conditional, ctx) {
+	  var _callee$object, _callee$property;
+	  var fields = ctx.fields,
+	    expandType = ctx.expandType,
+	    warn = ctx.warn,
+	    className = ctx.className;
+	  var callee = node.callee,
+	    args = node.arguments;
+	  if (!callee || callee.type !== 'MemberExpression' || callee.computed) {
+	    return false;
+	  }
+	  if (((_callee$object = callee.object) === null || _callee$object === void 0 ? void 0 : _callee$object.type) !== 'Identifier' || callee.object.name !== 'Object') {
+	    return false;
+	  }
+	  if (((_callee$property = callee.property) === null || _callee$property === void 0 ? void 0 : _callee$property.type) !== 'Identifier' || callee.property.name !== 'assign') {
+	    return false;
+	  }
+	  if (!args.length || args[0].type !== 'ThisExpression') {
+	    return false;
+	  }
+	  var _iterator = _createForOfIteratorHelper(args.slice(1)),
+	    _step;
+	  try {
+	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	      var arg = _step.value;
+	      if (!arg || arg.type !== 'ObjectExpression') {
+	        continue;
+	      }
+	      var _iterator2 = _createForOfIteratorHelper(arg.properties),
+	        _step2;
+	      try {
+	        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	          var _declared$type2;
+	          var prop = _step2.value;
+	          if (!prop || prop.type !== 'ObjectProperty') {
+	            continue;
+	          }
+	          var name = keyName(prop.key, prop.computed);
+	          if (name === undefined) {
+	            continue;
+	          }
+	          var comment = lastBlockComment(prop);
+	          var declared = tagType(comment, '@type', expandType);
+	          var type = (_declared$type2 = declared === null || declared === void 0 ? void 0 : declared.type) !== null && _declared$type2 !== void 0 ? _declared$type2 : inferTypeFromDefault$1(unwrap(prop.value));
+	          if (type === undefined) {
+	            continue;
+	          }
+	          record(fields, name, {
+	            type: type,
+	            rank: declared ? CTOR_JSDOC : CTOR_INFER,
+	            jsdoc: declared !== undefined,
+	            raw: declared === null || declared === void 0 ? void 0 : declared.raw,
+	            optional: conditional
+	          }, warn, className);
+	        }
+	      } catch (err) {
+	        _iterator2.e(err);
+	      } finally {
+	        _iterator2.f();
+	      }
+	    }
+	  } catch (err) {
+	    _iterator.e(err);
+	  } finally {
+	    _iterator.f();
+	  }
+	  return true;
+	}
+	/**
+	 * Walks an expression for `this.x` writes. Stops at function boundaries:
+	 * deferred writes (callbacks) are out of scope.
+	 * @param {*} expr - Babel expression node.
+	 * @param {boolean} conditional - True inside conditionals.
+	 * @param {object} ctx - Harvest context.
+	 * @param {*} stmt - Enclosing statement carrying leading comments.
+	 */
+	function walkExpression(expr, conditional, ctx, stmt) {
+	  if (!expr) {
+	    return;
+	  }
+	  switch (expr.type) {
+	    case 'AssignmentExpression':
+	      {
+	        var comment = lastBlockComment(stmt);
+	        if (expr.operator === '=') {
+	          recordThisAssign(expr.left, expr.right, comment, conditional, ctx);
+	          walkExpression(expr.right, conditional, ctx, stmt);
+	        } else {
+	          recordThisAssign(expr.left, undefined, comment, conditional, ctx);
+	        }
+	        break;
+	      }
+	    case 'UpdateExpression':
+	      recordThisAssign(expr.argument, undefined, lastBlockComment(stmt), conditional, ctx);
+	      break;
+	    case 'SequenceExpression':
+	      var _iterator3 = _createForOfIteratorHelper(expr.expressions),
+	        _step3;
+	      try {
+	        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+	          var each = _step3.value;
+	          walkExpression(each, conditional, ctx, stmt);
+	        }
+	      } catch (err) {
+	        _iterator3.e(err);
+	      } finally {
+	        _iterator3.f();
+	      }
+	      break;
+	    case 'LogicalExpression':
+	      walkExpression(expr.right, true, ctx, stmt);
+	      break;
+	    case 'ConditionalExpression':
+	      walkExpression(expr.consequent, true, ctx, stmt);
+	      walkExpression(expr.alternate, true, ctx, stmt);
+	      break;
+	    case 'CallExpression':
+	      recordObjectAssign(expr, conditional, ctx);
+	      break;
+	  }
+	}
+	/**
+	 * Walks a statement for `this.x` writes. Conditional wrappers mark entries
+	 * optional; nested functions are boundaries.
+	 * @param {*} st - Babel statement node.
+	 * @param {boolean} conditional - True inside conditionals.
+	 * @param {object} ctx - Harvest context.
+	 */
+	function walkStatement(st, conditional, ctx) {
+	  if (!st) {
+	    return;
+	  }
+	  switch (st.type) {
+	    case 'BlockStatement':
+	      var _iterator4 = _createForOfIteratorHelper(st.body),
+	        _step4;
+	      try {
+	        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+	          var each = _step4.value;
+	          walkStatement(each, conditional, ctx);
+	        }
+	      } catch (err) {
+	        _iterator4.e(err);
+	      } finally {
+	        _iterator4.f();
+	      }
+	      break;
+	    case 'ExpressionStatement':
+	      walkExpression(st.expression, conditional, ctx, st);
+	      break;
+	    case 'ReturnStatement':
+	      walkExpression(st.argument, conditional, ctx, st);
+	      break;
+	    case 'IfStatement':
+	      walkStatement(st.consequent, true, ctx);
+	      walkStatement(st.alternate, true, ctx);
+	      break;
+	    case 'WhileStatement':
+	    case 'ForStatement':
+	    case 'ForInStatement':
+	    case 'ForOfStatement':
+	      walkStatement(st.body, true, ctx);
+	      break;
+	    case 'DoWhileStatement':
+	      walkStatement(st.body, conditional, ctx);
+	      break;
+	    case 'SwitchStatement':
+	      var _iterator5 = _createForOfIteratorHelper(st.cases),
+	        _step5;
+	      try {
+	        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+	          var _each = _step5.value;
+	          var _iterator6 = _createForOfIteratorHelper(_each.consequent),
+	            _step6;
+	          try {
+	            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+	              var consequent = _step6.value;
+	              walkStatement(consequent, true, ctx);
+	            }
+	          } catch (err) {
+	            _iterator6.e(err);
+	          } finally {
+	            _iterator6.f();
+	          }
+	        }
+	      } catch (err) {
+	        _iterator5.e(err);
+	      } finally {
+	        _iterator5.f();
+	      }
+	      break;
+	    case 'TryStatement':
+	      walkStatement(st.block, conditional, ctx);
+	      if (st.handler) {
+	        walkStatement(st.handler.body, true, ctx);
+	      }
+	      if (st.finalizer) {
+	        walkStatement(st.finalizer, conditional, ctx);
+	      }
+	      break;
+	    case 'LabeledStatement':
+	      walkStatement(st.body, conditional, ctx);
+	      break;
+	  }
+	}
+	/**
+	 * Reads the single parameter name of a setter.
+	 * @param {*} param - Babel parameter node.
+	 * @returns {string|undefined} Name or undefined.
+	 */
+	function setterParamName(param) {
+	  if (!param) {
+	    return;
+	  }
+	  if (param.type === 'Identifier') {
+	    return param.name;
+	  }
+	  if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') {
+	    return param.left.name;
+	  }
+	}
+	/**
+	 * Reads a setter's value type: its `@param` JSDoc first, `@type` fallback.
+	 * @param {*} set - Babel ClassMethod (kind set) node.
+	 * @param {Function} expandType - String type to structured type.
+	 * @returns {{type: *, raw: string|undefined, jsdoc: boolean}} Type plus metadata.
+	 */
+	function setterType(set, expandType) {
+	  var setComment = lastBlockComment(set);
+	  var paramName = setterParamName(set.params[0]);
+	  var params = parseJSDoc(setComment !== null && setComment !== void 0 ? setComment : '', expandType);
+	  if (paramName && params && params[paramName] !== undefined) {
+	    return {
+	      type: params[paramName],
+	      raw: undefined,
+	      jsdoc: true
+	    };
+	  }
+	  var tagged = tagType(setComment, '@type', expandType);
+	  if (tagged) {
+	    return {
+	      type: tagged.type,
+	      raw: tagged.raw,
+	      jsdoc: true
+	    };
+	  }
+	  return {
+	    type: 'any',
+	    raw: undefined,
+	    jsdoc: false
+	  };
+	}
+	/**
+	 * Harvests the instance shape of a class: field declarations (JSDoc wins,
+	 * else inferred), constructor `this.x` writes (field site wins conflicts),
+	 * methods as `Function`, getter/setter pairs as writable and getter-only as
+	 * readonly. Statics, privates and dynamic keys are skipped.
+	 * @param {*} node - Babel ClassDeclaration node.
+	 * @param {object} opts - Options with expandType and warn.
+	 * @param {Function} opts.expandType - String type to structured type.
+	 * @param {Function} opts.warn - Transpile-time warning function.
+	 * @returns {{name: string, shape: object}|undefined} Class name plus object shape.
+	 */
+	function harvestClassShape(node, _ref) {
+	  var expandType = _ref.expandType,
+	    warn = _ref.warn;
+	  var id = node === null || node === void 0 ? void 0 : node.id;
+	  if (!id || id.type !== 'Identifier' || !id.name) {
 	    return;
 	  }
-	  var lines = value.split('\n');
-	  var lastTypedef;
-	  var _iterator = _createForOfIteratorHelper(lines),
-	    _step;
+	  var className = id.name;
+	  var ctx = {
+	    fields: {},
+	    gets: {},
+	    sets: {},
+	    expandType: expandType,
+	    warn: warn,
+	    className: className
+	  };
+	  var ctor = null;
+	  var _iterator7 = _createForOfIteratorHelper(node.body.body),
+	    _step7;
 	  try {
-	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-	      var line = _step.value;
-	      line = line.trim();
-	      if (line[0] === '*') {
-	        line = line.slice(1).trim();
+	    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+	      var el = _step7.value;
+	      if (el.type === 'ClassPrivateProperty' || el.type === 'ClassPrivateMethod') {
+	        continue;
 	      }
-	      if (line.startsWith('@typedef')) {
-	        var _extractCurlyContent = extractCurlyContent(line),
-	          def = _extractCurlyContent.content,
-	          nextIndex = _extractCurlyContent.nextIndex;
-	        var name = line.substring(nextIndex).trim();
-	        // Drop description
-	        name = name.split(' ')[0];
-	        lastTypedef = expandType(def);
-	        // Ignore @typedef's that only refer to themselves in another file (see typedef-overwrite test)
-	        if (lastTypedef !== name) {
-	          typedefs[name] = lastTypedef;
+	      var _name3 = keyName(el.key, el.computed);
+	      if (_name3 === undefined) {
+	        continue;
+	      }
+	      if (el.type === 'ClassProperty' || el.type === 'PropertyDefinition') {
+	        var _declared$type3;
+	        if (el.static || el.declare) {
+	          continue;
 	        }
-	      } else if (line.startsWith('@property')) {
-	        var _lastTypedef;
-	        // class @property
-	        if (!lastTypedef) {
+	        var comment = lastBlockComment(el);
+	        var declared = tagType(comment, '@type', expandType);
+	        var inferred = el.value ? inferTypeFromDefault$1(unwrap(el.value)) : undefined;
+	        var _type = (_declared$type3 = declared === null || declared === void 0 ? void 0 : declared.type) !== null && _declared$type3 !== void 0 ? _declared$type3 : inferred;
+	        if (_type === undefined) {
 	          continue;
 	        }
-	        var _extractCurlyContent2 = extractCurlyContent(line),
-	          content = _extractCurlyContent2.content,
-	          _nextIndex = _extractCurlyContent2.nextIndex;
-	        var rest = line.substring(_nextIndex);
-	        var propType = expandType(content);
-	        var _extractNameAndOption = extractNameAndOptionality(rest),
-	          _extractNameAndOption2 = _slicedToArray(_extractNameAndOption, 2),
-	          _name = _extractNameAndOption2[0],
-	          optional = _extractNameAndOption2[1];
-	        // console.log({name, optional, propType});
-	        var finalType = annotateOptional(propType, optional);
-	        if (((_lastTypedef = lastTypedef) === null || _lastTypedef === void 0 ? void 0 : _lastTypedef.type) === 'object') {
-	          lastTypedef.properties[_name] = finalType;
-	        } else {
-	          warn("not an extensible type", lastTypedef);
+	        record(ctx.fields, _name3, {
+	          type: _type,
+	          rank: declared ? FIELD_JSDOC : FIELD_INFER,
+	          jsdoc: declared !== undefined,
+	          raw: declared === null || declared === void 0 ? void 0 : declared.raw,
+	          readonly: el.readonly === true || (comment ? /@readonly(?![\w])/.test(comment) : false),
+	          optional: el.optional === true
+	        }, warn, className);
+	      } else if (el.type === 'ClassMethod' || el.type === 'ClassPrivateMethod') {
+	        if (el.static) {
+	          continue;
+	        }
+	        if (el.kind === 'constructor') {
+	          ctor = el;
+	        } else if (el.kind === 'method') {
+	          var _ctx$fields$_name;
+	          ctx.fields[_name3] = (_ctx$fields$_name = ctx.fields[_name3]) !== null && _ctx$fields$_name !== void 0 ? _ctx$fields$_name : {
+	            type: 'Function',
+	            rank: FIELD_INFER,
+	            jsdoc: false
+	          };
+	        } else if (el.kind === 'get') {
+	          ctx.gets[_name3] = el;
+	        } else if (el.kind === 'set') {
+	          ctx.sets[_name3] = el;
 	        }
-	      } else if (line.startsWith('@callback')) {
-	        var _name2 = line.substring(9).trim();
-	        typedefs[_name2] = 'Function';
 	      }
 	    }
 	  } catch (err) {
-	    _iterator.e(err);
+	    _iterator7.e(err);
 	  } finally {
-	    _iterator.f();
+	    _iterator7.f();
+	  }
+	  for (var _i = 0, _Object$keys = Object.keys(ctx.gets); _i < _Object$keys.length; _i++) {
+	    var _tagType, _ref2, _getType$type, _getType$raw;
+	    var name = _Object$keys[_i];
+	    var get = ctx.gets[name];
+	    var set = ctx.sets[name];
+	    var getComment = lastBlockComment(get);
+	    var getType = (_tagType = tagType(getComment, '@type', expandType)) !== null && _tagType !== void 0 ? _tagType : tagType(getComment, '@returns', expandType);
+	    var setInfo = set ? setterType(set, expandType) : undefined;
+	    var type = (_ref2 = (_getType$type = getType === null || getType === void 0 ? void 0 : getType.type) !== null && _getType$type !== void 0 ? _getType$type : setInfo === null || setInfo === void 0 ? void 0 : setInfo.type) !== null && _ref2 !== void 0 ? _ref2 : 'any';
+	    record(ctx.fields, name, {
+	      type: type,
+	      rank: getType || setInfo !== null && setInfo !== void 0 && setInfo.jsdoc ? FIELD_JSDOC : FIELD_INFER,
+	      jsdoc: Boolean(getType || (setInfo === null || setInfo === void 0 ? void 0 : setInfo.jsdoc)),
+	      raw: (_getType$raw = getType === null || getType === void 0 ? void 0 : getType.raw) !== null && _getType$raw !== void 0 ? _getType$raw : setInfo === null || setInfo === void 0 ? void 0 : setInfo.raw,
+	      readonly: !set
+	    }, warn, className);
+	  }
+	  for (var _i2 = 0, _Object$keys2 = Object.keys(ctx.sets); _i2 < _Object$keys2.length; _i2++) {
+	    var _name = _Object$keys2[_i2];
+	    if (ctx.gets[_name]) {
+	      continue;
+	    }
+	    var _setInfo = setterType(ctx.sets[_name], expandType);
+	    record(ctx.fields, _name, {
+	      type: _setInfo.type,
+	      rank: _setInfo.jsdoc ? FIELD_JSDOC : FIELD_INFER,
+	      jsdoc: _setInfo.jsdoc,
+	      raw: _setInfo.raw
+	    }, warn, className);
 	  }
+	  if (ctor && ctor.body) {
+	    var _iterator8 = _createForOfIteratorHelper(ctor.body.body),
+	      _step8;
+	    try {
+	      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+	        var st = _step8.value;
+	        walkStatement(st, false, ctx);
+	      }
+	    } catch (err) {
+	      _iterator8.e(err);
+	    } finally {
+	      _iterator8.f();
+	    }
+	  }
+	  var properties = {};
+	  for (var _i3 = 0, _Object$keys3 = Object.keys(ctx.fields); _i3 < _Object$keys3.length; _i3++) {
+	    var _name2 = _Object$keys3[_i3];
+	    properties[_name2] = entryToType(ctx.fields[_name2]);
+	  }
+	  if (!Object.keys(properties).length) {
+	    return;
+	  }
+	  return {
+	    name: className,
+	    shape: {
+	      type: 'object',
+	      properties: properties
+	    }
+	  };
 	}
 
 	/**
@@ -1454,101 +2598,6 @@
 	  return false;
 	}
 
-	/**
-	 * @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 {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, ExpandTypeReturnType>} */
-	  var params = Object.create(null);
-	  matches.forEach(function (_) {
-	    var type = expandType(_[1].trim());
-	    var name = _[2].trim();
-	    var optional = false;
-	    // Examples:
-	    //   name: [kwargs={}] The configuration parameters.
-	    //   name: [d = 1.0] Sample spacing
-	    if (name[0] === '[') {
-	      // Counting opening/closing brackets for perfect match
-	      var openCloseCount = 1;
-	      var i = 1;
-	      for (; i < name.length; i++) {
-	        var c = name[i];
-	        if (c === '[') {
-	          openCloseCount++;
-	        } else if (c === ']') {
-	          openCloseCount--;
-	        }
-	        if (openCloseCount === 0) {
-	          break;
-	        }
-	      }
-	      // Afterwards name will be: d = 1.0
-	      name = name.substring(1, i);
-	      // mark it for the type:
-	      optional = true;
-	    }
-	    // Strip the rest (either leftover of optional value or description)
-	    name = name.split(' ')[0].split('=')[0].trim();
-	    var annotatedType = annotateOptional(type, optional);
-	    // 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 `annotatedType`.
-	          console.assert(part === parts.at(-1), 'Current part and last part should be the same.');
-	          properties[part] = annotatedType;
-	        } 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,
-	            annotatedType: annotatedType
-	          });
-	        }
-	      }
-	    } catch (err) {
-	      _iterator.e(err);
-	    } finally {
-	      _iterator.f();
-	    }
-	  });
-	  if (Object.keys(params).length === 0) {
-	    return;
-	  }
-	  return params;
-	}
-
 	/**
 	 * @param {string} src - JSDoc comment of the setter.
 	 * @param {Function} expandType - The expandType function.
@@ -1583,9 +2632,6 @@
 	  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 (_) {
@@ -1593,6 +2639,40 @@
 	    var name = _[2].trim();
 	    templates[name] = type;
 	  });
+	  // `@template [A=X]` defaults: constraint X under name A.
+	  var regexTemplateDefault = /@template \[([a-zA-Z0-9_$]+)=([^\]]+)\]/g;
+	  var _iterator = _createForOfIteratorHelper(src.matchAll(regexTemplateDefault)),
+	    _step;
+	  try {
+	    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	      var match = _step.value;
+	      templates[match[1]] = expandType(match[2].trim());
+	    }
+	    // Bare `@template T`: unconstrained, stands in as any.
+	  } catch (err) {
+	    _iterator.e(err);
+	  } finally {
+	    _iterator.f();
+	  }
+	  var regexTemplateBare = /@template ([a-zA-Z0-9_$]+)(?![a-zA-Z0-9_$])/g;
+	  var _iterator2 = _createForOfIteratorHelper(src.matchAll(regexTemplateBare)),
+	    _step2;
+	  try {
+	    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	      var _match = _step2.value;
+	      var name = _match[1];
+	      if (!(name in templates)) {
+	        templates[name] = 'any';
+	      }
+	    }
+	  } catch (err) {
+	    _iterator2.e(err);
+	  } finally {
+	    _iterator2.f();
+	  }
+	  if (!Object.keys(templates).length) {
+	    return;
+	  }
 	  return templates;
 	}
 
@@ -1618,8 +2698,12 @@
 	 */
 	/**
 	 * Recursively clones and simplifies a type for emission into source code.
-	 * Strips empty `properties` and collapses empty `object` types to the bare
-	 * string `'object'`.  Numbers/booleans (literal types) pass through.
+	 * Empty `properties` are preserved (not deleted) and empty `object` types
+	 * are kept structured: `{type: 'object'}` without a `properties` key is the
+	 * `{}` literal (accepts every non-nullish value like TS), while
+	 * `{type: 'object', properties: {}}` is the `object` keyword (rejects
+	 * primitives). Collapsing either form would erase that distinction.
+	 * Numbers/booleans (literal types) pass through.
 	 * Non-destructive — the original type tree is never mutated.
 	 * @param {string | DocType | number | boolean} type - The type.
 	 * @returns {string | DocType | number | boolean} The simplified type.
@@ -1631,9 +2715,6 @@
 	  var out = _objectSpread2({}, type);
 	  if (out.properties) {
 	    out.properties = mapValues(out.properties, simplifyType);
-	    if (out.type === 'object' && !Object.keys(out.properties).length) {
-	      delete out.properties;
-	    }
 	  }
 	  if (out.indexSignatures && Array.isArray(out.indexSignatures)) {
 	    out.indexSignatures = out.indexSignatures.map(simplifyType);
@@ -1660,9 +2741,6 @@
 	  if (out.type === 'typeof' && out.argument) {
 	    out.argument = simplifyType(out.argument);
 	  }
-	  if (out.type === 'object' && !out.properties && !out.indexSignatures && !out.optional) {
-	    return 'object';
-	  }
 	  return out;
 	}
 
@@ -3934,6 +5012,8 @@
 	    });
 	    /** @type {Record<string, object>} */
 	    _defineProperty(_assertThisInitialized(_this), "typedefs", {});
+	    /** @type {Record<string, string[]>} */
+	    _defineProperty(_assertThisInitialized(_this), "typedefTemplates", {});
 	    /** @type {string[]} */
 	    _defineProperty(_assertThisInitialized(_this), "addLaterImportNamespaceSpecifier", []);
 	    _this.forceCurly = forceCurly;
@@ -3996,6 +5076,21 @@
 	      var id_ = this.toSource(id);
 	      var out = _get(_getPrototypeOf(Asserter.prototype), "ClassDeclaration", this).call(this, node);
 	      out += "".concat(this.spaces, "registerClass(").concat(id_, ");");
+	      var harvested = harvestClassShape(node, {
+	        expandType: this.expandType,
+	        warn: this.warn.bind(this)
+	      });
+	      if (harvested) {
+	        // Hand-written typedefs win: emitting a second registerTypedef for the
+	        // same name would be last-wins deterministic but noisy, so the harvest
+	        // step skips names already present in this.typedefs (populated in File).
+	        if (this.typedefs[harvested.name]) {
+	          this.warn("harvestClassShape: skipping harvested shape for '".concat(harvested.name, "', hand-written typedef wins"));
+	        } else {
+	          var json = simplifyTypeToSource(harvested.shape);
+	          out += "\n".concat(this.spaces, "registerTypedef('").concat(harvested.name, "', ").concat(json, ");");
+	        }
+	      }
 	      return out;
 	    }
 	    /**
@@ -4910,7 +6005,7 @@
 	          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
 	            var comment = _step5.value;
 	            var warn = this.warn.bind(this);
-	            parseJSDocTypedef(this.typedefs, warn, comment, this.expandType);
+	            parseJSDocTypedef(this.typedefs, this.typedefTemplates, warn, comment, this.expandType);
 	          }
 	        } catch (err) {
 	          _iterator5.e(err);
@@ -4923,7 +6018,8 @@
 	      for (var name in this.typedefs) {
 	        var typedef = this.typedefs[name];
 	        var json = simplifyTypeToSource(typedef);
-	        out += "registerTypedef('".concat(name, "', ").concat(json, ");\n");
+	        var params = this.typedefTemplates[name];
+	        out += params !== null && params !== void 0 && params.length ? "registerTypedef('".concat(name, "', ").concat(json, ", ").concat(JSON.stringify(params), ");\n") : "registerTypedef('".concat(name, "', ").concat(json, ");\n");
 	      }
 	      var code = this.toSource(program) + '\n';
 	      out += code;
@@ -5214,7 +6310,13 @@
 	      {
 	        var name = toSourceBabelTS(node.typeName);
 	        if (!node.typeParameters) {
-	          // console.log(`node.typeName.name=${node.typeName.name} name=${name}`, node);
+	          // Bare `Object` is the empty object type, matching expandType().
+	          if (name === 'Object') {
+	            return {
+	              type: 'object',
+	              properties: {}
+	            };
+	          }
 	          // Bare reference: Identifier gives name, TSQualifiedName gives dotted path.
 	          return name;
 	        }
@@ -5275,6 +6377,8 @@
 	      }
 	    case 'TSStringKeyword':
 	      return 'string';
+	    case 'TSSymbolKeyword':
+	      return 'symbol';
 	    case 'TSNumberKeyword':
 	      return 'number';
 	    case 'TSIntersectionType':
@@ -5356,6 +6460,8 @@
 	    case 'ParenthesizedType':
 	      // fall-through for parentheses
 	      return toSourceBabelTS(node.type);
+	    case 'TSParenthesizedType':
+	      return toSourceBabelTS(node.typeAnnotation);
 	    case 'LastTypeNode':
 	      return toSourceBabelTS(node.qualifier);
 	    case 'TSTypeQuery':
@@ -5364,11 +6470,129 @@
 	        type: 'typeof',
 	        argument: argument
 	      };
+	    case 'TSConditionalType':
+	      {
+	        var checkType = toSourceBabelTS(node.checkType);
+	        var extendsType = toSourceBabelTS(node.extendsType);
+	        var trueType = toSourceBabelTS(node.trueType);
+	        var falseType = toSourceBabelTS(node.falseType);
+	        return {
+	          type: 'condition',
+	          checkType: checkType,
+	          extendsType: extendsType,
+	          trueType: trueType,
+	          falseType: falseType
+	        };
+	      }
+	    case 'TSIndexedAccessType':
+	      {
+	        var index = toSourceBabelTS(node.indexType);
+	        var object = toSourceBabelTS(node.objectType);
+	        return {
+	          type: 'indexedAccess',
+	          index: index,
+	          object: object
+	        };
+	      }
+	    case 'TSMappedType':
+	      {
+	        var param = node.typeParameter;
+	        var nameNode = param === null || param === void 0 ? void 0 : param.name;
+	        var element = typeof nameNode === 'string' ? nameNode : toSourceBabelTS(nameNode);
+	        var iterable = toSourceBabelTS(param === null || param === void 0 ? void 0 : param.constraint);
+	        var result = toSourceBabelTS(node.typeAnnotation);
+	        var out = {
+	          type: 'mapping',
+	          iterable: iterable,
+	          element: element,
+	          result: result
+	        };
+	        if (node.nameType) {
+	          out.nameType = toSourceBabelTS(node.nameType);
+	        }
+	        if (node.optional !== undefined && node.optional !== false && node.optional !== null) {
+	          out.question = node.optional === '-' ? '-' : node.optional === '+' ? '+' : '?';
+	        }
+	        if (node.readonly !== undefined && node.readonly !== false && node.readonly !== null) {
+	          out.readonly = node.readonly === '-' ? '-' : node.readonly === '+' ? '+' : 'readonly';
+	        }
+	        return out;
+	      }
+	    case 'TSTypeAnnotation':
+	      return toSourceBabelTS(node.typeAnnotation);
+	    case 'TSTypeLiteral':
+	      {
+	        var _node$members;
+	        var _properties = {};
+	        var indexSignatures;
+	        var _iterator = _createForOfIteratorHelper((_node$members = node.members) !== null && _node$members !== void 0 ? _node$members : []),
+	          _step;
+	        try {
+	          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	            var member = _step.value;
+	            if (member.type === 'TSIndexSignature') {
+	              var _indexSignatures;
+	              indexSignatures = (_indexSignatures = indexSignatures) !== null && _indexSignatures !== void 0 ? _indexSignatures : [];
+	              indexSignatures.push(toSourceBabelTS(member));
+	            } else if (member.type === 'TSPropertySignature') {
+	              var _name = toSourceBabelTS(member.key);
+	              var type = toSourceBabelTS(member.typeAnnotation);
+	              if (member.optional) {
+	                if (type && _typeof(type) === 'object') type.optional = true;else type = {
+	                  type: type,
+	                  optional: true
+	                };
+	              }
+	              if (member.readonly) {
+	                if (type && _typeof(type) === 'object') type.readonly = true;else type = {
+	                  type: type,
+	                  readonly: true
+	                };
+	              }
+	              _properties[_name] = type;
+	            } else {
+	              console.warn('TSTypeLiteral: unhandled member', member.type);
+	            }
+	          }
+	        } catch (err) {
+	          _iterator.e(err);
+	        } finally {
+	          _iterator.f();
+	        }
+	        var ret = {
+	          type: 'object'
+	        };
+	        if (Object.keys(_properties).length) {
+	          ret.properties = _properties;
+	        }
+	        if (indexSignatures) {
+	          ret.indexSignatures = indexSignatures;
+	        }
+	        return ret;
+	      }
+	    case 'TSIndexSignature':
+	      {
+	        var _node$parameters;
+	        var indexType = toSourceBabelTS(node.typeAnnotation);
+	        var indexParameters = ((_node$parameters = node.parameters) !== null && _node$parameters !== void 0 ? _node$parameters : []).map(toSourceBabelTS);
+	        return {
+	          type: 'indexSignature',
+	          indexType: indexType,
+	          indexParameters: indexParameters
+	        };
+	      }
 	    case 'TSTypeOperator':
 	      if (node.operator === 'readonly') {
 	        // readonly erased at runtime, same shape as the inner type.
 	        return toSourceBabelTS(node.typeAnnotation);
 	      }
+	      if (node.operator === 'keyof') {
+	        var keyofArg = toSourceBabelTS(node.typeAnnotation);
+	        return {
+	          type: 'keyof',
+	          argument: keyofArg
+	        };
+	      }
 	      console.warn('unimplemented TSTypeOperator', node.operator);
 	      return 'any';
 	    case 'TSQualifiedName':
@@ -5501,6 +6725,8 @@
 	    _defineProperty(this, "parents", []);
 	    /** @type {Record<string, object>} */
 	    _defineProperty(this, "typedefs", {});
+	    /** @type {Record<string, string[]>} */
+	    _defineProperty(this, "typedefTemplates", {});
 	    /** @type {import('./parseJSDoc.js').ExpandType} */
 	    this.expandType = options.expandType || expandTypeDepFree;
 	  }
@@ -5521,7 +6747,7 @@
 	            for (_iterator.s(); !(_step = _iterator.n()).done;) {
 	              var comment = _step.value;
 	              var warn = console.warn.bind(console);
-	              parseJSDocTypedef(this.typedefs, warn, comment, this.expandType);
+	              parseJSDocTypedef(this.typedefs, this.typedefTemplates, warn, comment, this.expandType);
 	            }
 	          } catch (err) {
 	            _iterator.e(err);