@angular/compiler-cli 16.2.0-next.4 → 16.2.0

package/bundles/{chunk-WF3L5COT.js → chunk-OCDXYAWW.js}

@@ -12,10 +12,636 @@ import {
   resolve,
   stripExtension,
   toRelativeImport
-} from "./chunk-TBUSSXUA.js";
+} from "./chunk-K2U2VZ7S.js";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+import ts4 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
 import ts from "typescript";
+function isDecoratorIdentifier(exp) {
+  return ts.isIdentifier(exp) || ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression) && ts.isIdentifier(exp.name);
+}
+var ClassMemberKind;
+(function(ClassMemberKind2) {
+  ClassMemberKind2[ClassMemberKind2["Constructor"] = 0] = "Constructor";
+  ClassMemberKind2[ClassMemberKind2["Getter"] = 1] = "Getter";
+  ClassMemberKind2[ClassMemberKind2["Setter"] = 2] = "Setter";
+  ClassMemberKind2[ClassMemberKind2["Property"] = 3] = "Property";
+  ClassMemberKind2[ClassMemberKind2["Method"] = 4] = "Method";
+})(ClassMemberKind || (ClassMemberKind = {}));
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
+import ts2 from "typescript";
+function typeToValue(typeNode, checker) {
+  if (typeNode === null) {
+    return missingType();
+  }
+  if (!ts2.isTypeReferenceNode(typeNode)) {
+    return unsupportedType(typeNode);
+  }
+  const symbols = resolveTypeSymbols(typeNode, checker);
+  if (symbols === null) {
+    return unknownReference(typeNode);
+  }
+  const { local, decl } = symbols;
+  if (decl.valueDeclaration === void 0 || decl.flags & ts2.SymbolFlags.ConstEnum) {
+    let typeOnlyDecl = null;
+    if (decl.declarations !== void 0 && decl.declarations.length > 0) {
+      typeOnlyDecl = decl.declarations[0];
+    }
+    return noValueDeclaration(typeNode, typeOnlyDecl);
+  }
+  const firstDecl = local.declarations && local.declarations[0];
+  if (firstDecl !== void 0) {
+    if (ts2.isImportClause(firstDecl) && firstDecl.name !== void 0) {
+      if (firstDecl.isTypeOnly) {
+        return typeOnlyImport(typeNode, firstDecl);
+      }
+      return {
+        kind: 0,
+        expression: firstDecl.name,
+        defaultImportStatement: firstDecl.parent
+      };
+    } else if (ts2.isImportSpecifier(firstDecl)) {
+      if (firstDecl.isTypeOnly) {
+        return typeOnlyImport(typeNode, firstDecl);
+      }
+      if (firstDecl.parent.parent.isTypeOnly) {
+        return typeOnlyImport(typeNode, firstDecl.parent.parent);
+      }
+      const importedName = (firstDecl.propertyName || firstDecl.name).text;
+      const [_localName, ...nestedPath] = symbols.symbolNames;
+      const moduleName = extractModuleName(firstDecl.parent.parent.parent);
+      return {
+        kind: 1,
+        valueDeclaration: decl.valueDeclaration,
+        moduleName,
+        importedName,
+        nestedPath
+      };
+    } else if (ts2.isNamespaceImport(firstDecl)) {
+      if (firstDecl.parent.isTypeOnly) {
+        return typeOnlyImport(typeNode, firstDecl.parent);
+      }
+      if (symbols.symbolNames.length === 1) {
+        return namespaceImport(typeNode, firstDecl.parent);
+      }
+      const [_ns, importedName, ...nestedPath] = symbols.symbolNames;
+      const moduleName = extractModuleName(firstDecl.parent.parent);
+      return {
+        kind: 1,
+        valueDeclaration: decl.valueDeclaration,
+        moduleName,
+        importedName,
+        nestedPath
+      };
+    }
+  }
+  const expression = typeNodeToValueExpr(typeNode);
+  if (expression !== null) {
+    return {
+      kind: 0,
+      expression,
+      defaultImportStatement: null
+    };
+  } else {
+    return unsupportedType(typeNode);
+  }
+}
+function unsupportedType(typeNode) {
+  return {
+    kind: 2,
+    reason: { kind: 5, typeNode }
+  };
+}
+function noValueDeclaration(typeNode, decl) {
+  return {
+    kind: 2,
+    reason: { kind: 1, typeNode, decl }
+  };
+}
+function typeOnlyImport(typeNode, node) {
+  return {
+    kind: 2,
+    reason: { kind: 2, typeNode, node }
+  };
+}
+function unknownReference(typeNode) {
+  return {
+    kind: 2,
+    reason: { kind: 3, typeNode }
+  };
+}
+function namespaceImport(typeNode, importClause) {
+  return {
+    kind: 2,
+    reason: { kind: 4, typeNode, importClause }
+  };
+}
+function missingType() {
+  return {
+    kind: 2,
+    reason: { kind: 0 }
+  };
+}
+function typeNodeToValueExpr(node) {
+  if (ts2.isTypeReferenceNode(node)) {
+    return entityNameToValue(node.typeName);
+  } else {
+    return null;
+  }
+}
+function resolveTypeSymbols(typeRef, checker) {
+  const typeName = typeRef.typeName;
+  const typeRefSymbol = checker.getSymbolAtLocation(typeName);
+  if (typeRefSymbol === void 0) {
+    return null;
+  }
+  let local = typeRefSymbol;
+  let leftMost = typeName;
+  const symbolNames = [];
+  while (ts2.isQualifiedName(leftMost)) {
+    symbolNames.unshift(leftMost.right.text);
+    leftMost = leftMost.left;
+  }
+  symbolNames.unshift(leftMost.text);
+  if (leftMost !== typeName) {
+    const localTmp = checker.getSymbolAtLocation(leftMost);
+    if (localTmp !== void 0) {
+      local = localTmp;
+    }
+  }
+  let decl = typeRefSymbol;
+  if (typeRefSymbol.flags & ts2.SymbolFlags.Alias) {
+    decl = checker.getAliasedSymbol(typeRefSymbol);
+  }
+  return { local, decl, symbolNames };
+}
+function entityNameToValue(node) {
+  if (ts2.isQualifiedName(node)) {
+    const left = entityNameToValue(node.left);
+    return left !== null ? ts2.factory.createPropertyAccessExpression(left, node.right) : null;
+  } else if (ts2.isIdentifier(node)) {
+    const clone = ts2.setOriginalNode(ts2.factory.createIdentifier(node.text), node);
+    clone.parent = node.parent;
+    return clone;
+  } else {
+    return null;
+  }
+}
+function extractModuleName(node) {
+  if (!ts2.isStringLiteral(node.moduleSpecifier)) {
+    throw new Error("not a module specifier");
+  }
+  return node.moduleSpecifier.text;
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/util.mjs
+import ts3 from "typescript";
+function isNamedClassDeclaration(node) {
+  return ts3.isClassDeclaration(node) && isIdentifier(node.name);
+}
+function isIdentifier(node) {
+  return node !== void 0 && ts3.isIdentifier(node);
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+var TypeScriptReflectionHost = class {
+  constructor(checker) {
+    this.checker = checker;
+  }
+  getDecoratorsOfDeclaration(declaration) {
+    const decorators = ts4.canHaveDecorators(declaration) ? ts4.getDecorators(declaration) : void 0;
+    return decorators !== void 0 && decorators.length ? decorators.map((decorator) => this._reflectDecorator(decorator)).filter((dec) => dec !== null) : null;
+  }
+  getMembersOfClass(clazz) {
+    const tsClazz = castDeclarationToClassOrDie(clazz);
+    return tsClazz.members.map((member) => this._reflectMember(member)).filter((member) => member !== null);
+  }
+  getConstructorParameters(clazz) {
+    const tsClazz = castDeclarationToClassOrDie(clazz);
+    const isDeclaration2 = tsClazz.getSourceFile().isDeclarationFile;
+    const ctor = tsClazz.members.find((member) => ts4.isConstructorDeclaration(member) && (isDeclaration2 || member.body !== void 0));
+    if (ctor === void 0) {
+      return null;
+    }
+    return ctor.parameters.map((node) => {
+      const name = parameterName(node.name);
+      const decorators = this.getDecoratorsOfDeclaration(node);
+      let originalTypeNode = node.type || null;
+      let typeNode = originalTypeNode;
+      if (typeNode && ts4.isUnionTypeNode(typeNode)) {
+        let childTypeNodes = typeNode.types.filter((childTypeNode) => !(ts4.isLiteralTypeNode(childTypeNode) && childTypeNode.literal.kind === ts4.SyntaxKind.NullKeyword));
+        if (childTypeNodes.length === 1) {
+          typeNode = childTypeNodes[0];
+        }
+      }
+      const typeValueReference = typeToValue(typeNode, this.checker);
+      return {
+        name,
+        nameNode: node.name,
+        typeValueReference,
+        typeNode: originalTypeNode,
+        decorators
+      };
+    });
+  }
+  getImportOfIdentifier(id) {
+    const directImport = this.getDirectImportOfIdentifier(id);
+    if (directImport !== null) {
+      return directImport;
+    } else if (ts4.isQualifiedName(id.parent) && id.parent.right === id) {
+      return this.getImportOfNamespacedIdentifier(id, getQualifiedNameRoot(id.parent));
+    } else if (ts4.isPropertyAccessExpression(id.parent) && id.parent.name === id) {
+      return this.getImportOfNamespacedIdentifier(id, getFarLeftIdentifier(id.parent));
+    } else {
+      return null;
+    }
+  }
+  getExportsOfModule(node) {
+    if (!ts4.isSourceFile(node)) {
+      throw new Error(`getExportsOfModule() called on non-SourceFile in TS code`);
+    }
+    const symbol = this.checker.getSymbolAtLocation(node);
+    if (symbol === void 0) {
+      return null;
+    }
+    const map = /* @__PURE__ */ new Map();
+    this.checker.getExportsOfModule(symbol).forEach((exportSymbol) => {
+      const decl = this.getDeclarationOfSymbol(exportSymbol, null);
+      if (decl !== null) {
+        map.set(exportSymbol.name, decl);
+      }
+    });
+    return map;
+  }
+  isClass(node) {
+    return isNamedClassDeclaration(node);
+  }
+  hasBaseClass(clazz) {
+    return this.getBaseClassExpression(clazz) !== null;
+  }
+  getBaseClassExpression(clazz) {
+    if (!(ts4.isClassDeclaration(clazz) || ts4.isClassExpression(clazz)) || clazz.heritageClauses === void 0) {
+      return null;
+    }
+    const extendsClause = clazz.heritageClauses.find((clause) => clause.token === ts4.SyntaxKind.ExtendsKeyword);
+    if (extendsClause === void 0) {
+      return null;
+    }
+    const extendsType = extendsClause.types[0];
+    if (extendsType === void 0) {
+      return null;
+    }
+    return extendsType.expression;
+  }
+  getDeclarationOfIdentifier(id) {
+    let symbol = this.checker.getSymbolAtLocation(id);
+    if (symbol === void 0) {
+      return null;
+    }
+    return this.getDeclarationOfSymbol(symbol, id);
+  }
+  getDefinitionOfFunction(node) {
+    if (!ts4.isFunctionDeclaration(node) && !ts4.isMethodDeclaration(node) && !ts4.isFunctionExpression(node) && !ts4.isArrowFunction(node)) {
+      return null;
+    }
+    let body = null;
+    if (node.body !== void 0) {
+      body = ts4.isBlock(node.body) ? Array.from(node.body.statements) : [ts4.factory.createReturnStatement(node.body)];
+    }
+    const type = this.checker.getTypeAtLocation(node);
+    const signatures = this.checker.getSignaturesOfType(type, ts4.SignatureKind.Call);
+    return {
+      node,
+      body,
+      signatureCount: signatures.length,
+      typeParameters: node.typeParameters === void 0 ? null : Array.from(node.typeParameters),
+      parameters: node.parameters.map((param) => {
+        const name = parameterName(param.name);
+        const initializer = param.initializer || null;
+        return { name, node: param, initializer, type: param.type || null };
+      })
+    };
+  }
+  getGenericArityOfClass(clazz) {
+    if (!ts4.isClassDeclaration(clazz)) {
+      return null;
+    }
+    return clazz.typeParameters !== void 0 ? clazz.typeParameters.length : 0;
+  }
+  getVariableValue(declaration) {
+    return declaration.initializer || null;
+  }
+  isStaticallyExported(decl) {
+    let topLevel = decl;
+    if (ts4.isVariableDeclaration(decl) && ts4.isVariableDeclarationList(decl.parent)) {
+      topLevel = decl.parent.parent;
+    }
+    const modifiers = ts4.canHaveModifiers(topLevel) ? ts4.getModifiers(topLevel) : void 0;
+    if (modifiers !== void 0 && modifiers.some((modifier) => modifier.kind === ts4.SyntaxKind.ExportKeyword)) {
+      return true;
+    }
+    if (topLevel.parent === void 0 || !ts4.isSourceFile(topLevel.parent)) {
+      return false;
+    }
+    const localExports = this.getLocalExportedDeclarationsOfSourceFile(decl.getSourceFile());
+    return localExports.has(decl);
+  }
+  getDirectImportOfIdentifier(id) {
+    const symbol = this.checker.getSymbolAtLocation(id);
+    if (symbol === void 0 || symbol.declarations === void 0 || symbol.declarations.length !== 1) {
+      return null;
+    }
+    const decl = symbol.declarations[0];
+    const importDecl = getContainingImportDeclaration(decl);
+    if (importDecl === null) {
+      return null;
+    }
+    if (!ts4.isStringLiteral(importDecl.moduleSpecifier)) {
+      return null;
+    }
+    return {
+      from: importDecl.moduleSpecifier.text,
+      name: getExportedName(decl, id),
+      node: importDecl
+    };
+  }
+  getImportOfNamespacedIdentifier(id, namespaceIdentifier) {
+    if (namespaceIdentifier === null) {
+      return null;
+    }
+    const namespaceSymbol = this.checker.getSymbolAtLocation(namespaceIdentifier);
+    if (!namespaceSymbol || namespaceSymbol.declarations === void 0) {
+      return null;
+    }
+    const declaration = namespaceSymbol.declarations.length === 1 ? namespaceSymbol.declarations[0] : null;
+    if (!declaration) {
+      return null;
+    }
+    const namespaceDeclaration = ts4.isNamespaceImport(declaration) ? declaration : null;
+    if (!namespaceDeclaration) {
+      return null;
+    }
+    const importDeclaration = namespaceDeclaration.parent.parent;
+    if (!ts4.isStringLiteral(importDeclaration.moduleSpecifier)) {
+      return null;
+    }
+    return {
+      from: importDeclaration.moduleSpecifier.text,
+      name: id.text,
+      node: namespaceDeclaration.parent.parent
+    };
+  }
+  getDeclarationOfSymbol(symbol, originalId) {
+    let valueDeclaration = void 0;
+    if (symbol.valueDeclaration !== void 0) {
+      valueDeclaration = symbol.valueDeclaration;
+    } else if (symbol.declarations !== void 0 && symbol.declarations.length > 0) {
+      valueDeclaration = symbol.declarations[0];
+    }
+    if (valueDeclaration !== void 0 && ts4.isShorthandPropertyAssignment(valueDeclaration)) {
+      const shorthandSymbol = this.checker.getShorthandAssignmentValueSymbol(valueDeclaration);
+      if (shorthandSymbol === void 0) {
+        return null;
+      }
+      return this.getDeclarationOfSymbol(shorthandSymbol, originalId);
+    } else if (valueDeclaration !== void 0 && ts4.isExportSpecifier(valueDeclaration)) {
+      const targetSymbol = this.checker.getExportSpecifierLocalTargetSymbol(valueDeclaration);
+      if (targetSymbol === void 0) {
+        return null;
+      }
+      return this.getDeclarationOfSymbol(targetSymbol, originalId);
+    }
+    const importInfo = originalId && this.getImportOfIdentifier(originalId);
+    const viaModule = importInfo !== null && importInfo.from !== null && !importInfo.from.startsWith(".") ? importInfo.from : null;
+    while (symbol.flags & ts4.SymbolFlags.Alias) {
+      symbol = this.checker.getAliasedSymbol(symbol);
+    }
+    if (symbol.valueDeclaration !== void 0) {
+      return {
+        node: symbol.valueDeclaration,
+        viaModule
+      };
+    } else if (symbol.declarations !== void 0 && symbol.declarations.length > 0) {
+      return {
+        node: symbol.declarations[0],
+        viaModule
+      };
+    } else {
+      return null;
+    }
+  }
+  _reflectDecorator(node) {
+    let decoratorExpr = node.expression;
+    let args = null;
+    if (ts4.isCallExpression(decoratorExpr)) {
+      args = Array.from(decoratorExpr.arguments);
+      decoratorExpr = decoratorExpr.expression;
+    }
+    if (!isDecoratorIdentifier(decoratorExpr)) {
+      return null;
+    }
+    const decoratorIdentifier = ts4.isIdentifier(decoratorExpr) ? decoratorExpr : decoratorExpr.name;
+    const importDecl = this.getImportOfIdentifier(decoratorIdentifier);
+    return {
+      name: decoratorIdentifier.text,
+      identifier: decoratorExpr,
+      import: importDecl,
+      node,
+      args
+    };
+  }
+  _reflectMember(node) {
+    let kind = null;
+    let value = null;
+    let name = null;
+    let nameNode = null;
+    if (ts4.isPropertyDeclaration(node)) {
+      kind = ClassMemberKind.Property;
+      value = node.initializer || null;
+    } else if (ts4.isGetAccessorDeclaration(node)) {
+      kind = ClassMemberKind.Getter;
+    } else if (ts4.isSetAccessorDeclaration(node)) {
+      kind = ClassMemberKind.Setter;
+    } else if (ts4.isMethodDeclaration(node)) {
+      kind = ClassMemberKind.Method;
+    } else if (ts4.isConstructorDeclaration(node)) {
+      kind = ClassMemberKind.Constructor;
+    } else {
+      return null;
+    }
+    if (ts4.isConstructorDeclaration(node)) {
+      name = "constructor";
+    } else if (ts4.isIdentifier(node.name)) {
+      name = node.name.text;
+      nameNode = node.name;
+    } else if (ts4.isStringLiteral(node.name)) {
+      name = node.name.text;
+      nameNode = node.name;
+    } else {
+      return null;
+    }
+    const decorators = this.getDecoratorsOfDeclaration(node);
+    const modifiers = ts4.getModifiers(node);
+    const isStatic = modifiers !== void 0 && modifiers.some((mod) => mod.kind === ts4.SyntaxKind.StaticKeyword);
+    return {
+      node,
+      implementation: node,
+      kind,
+      type: node.type || null,
+      name,
+      nameNode,
+      decorators,
+      value,
+      isStatic
+    };
+  }
+  getLocalExportedDeclarationsOfSourceFile(file) {
+    const cacheSf = file;
+    if (cacheSf[LocalExportedDeclarations] !== void 0) {
+      return cacheSf[LocalExportedDeclarations];
+    }
+    const exportSet = /* @__PURE__ */ new Set();
+    cacheSf[LocalExportedDeclarations] = exportSet;
+    const sfSymbol = this.checker.getSymbolAtLocation(cacheSf);
+    if (sfSymbol === void 0 || sfSymbol.exports === void 0) {
+      return exportSet;
+    }
+    const iter = sfSymbol.exports.values();
+    let item = iter.next();
+    while (item.done !== true) {
+      let exportedSymbol = item.value;
+      if (exportedSymbol.flags & ts4.SymbolFlags.Alias) {
+        exportedSymbol = this.checker.getAliasedSymbol(exportedSymbol);
+      }
+      if (exportedSymbol.valueDeclaration !== void 0 && exportedSymbol.valueDeclaration.getSourceFile() === file) {
+        exportSet.add(exportedSymbol.valueDeclaration);
+      }
+      item = iter.next();
+    }
+    return exportSet;
+  }
+};
+function reflectTypeEntityToDeclaration(type, checker) {
+  let realSymbol = checker.getSymbolAtLocation(type);
+  if (realSymbol === void 0) {
+    throw new Error(`Cannot resolve type entity ${type.getText()} to symbol`);
+  }
+  while (realSymbol.flags & ts4.SymbolFlags.Alias) {
+    realSymbol = checker.getAliasedSymbol(realSymbol);
+  }
+  let node = null;
+  if (realSymbol.valueDeclaration !== void 0) {
+    node = realSymbol.valueDeclaration;
+  } else if (realSymbol.declarations !== void 0 && realSymbol.declarations.length === 1) {
+    node = realSymbol.declarations[0];
+  } else {
+    throw new Error(`Cannot resolve type entity symbol to declaration`);
+  }
+  if (ts4.isQualifiedName(type)) {
+    if (!ts4.isIdentifier(type.left)) {
+      throw new Error(`Cannot handle qualified name with non-identifier lhs`);
+    }
+    const symbol = checker.getSymbolAtLocation(type.left);
+    if (symbol === void 0 || symbol.declarations === void 0 || symbol.declarations.length !== 1) {
+      throw new Error(`Cannot resolve qualified type entity lhs to symbol`);
+    }
+    const decl = symbol.declarations[0];
+    if (ts4.isNamespaceImport(decl)) {
+      const clause = decl.parent;
+      const importDecl = clause.parent;
+      if (!ts4.isStringLiteral(importDecl.moduleSpecifier)) {
+        throw new Error(`Module specifier is not a string`);
+      }
+      return { node, from: importDecl.moduleSpecifier.text };
+    } else if (ts4.isModuleDeclaration(decl)) {
+      return { node, from: null };
+    } else {
+      throw new Error(`Unknown import type?`);
+    }
+  } else {
+    return { node, from: null };
+  }
+}
+function filterToMembersWithDecorator(members, name, module) {
+  return members.filter((member) => !member.isStatic).map((member) => {
+    if (member.decorators === null) {
+      return null;
+    }
+    const decorators = member.decorators.filter((dec) => {
+      if (dec.import !== null) {
+        return dec.import.name === name && (module === void 0 || dec.import.from === module);
+      } else {
+        return dec.name === name && module === void 0;
+      }
+    });
+    if (decorators.length === 0) {
+      return null;
+    }
+    return { member, decorators };
+  }).filter((value) => value !== null);
+}
+function reflectObjectLiteral(node) {
+  const map = /* @__PURE__ */ new Map();
+  node.properties.forEach((prop) => {
+    if (ts4.isPropertyAssignment(prop)) {
+      const name = propertyNameToString(prop.name);
+      if (name === null) {
+        return;
+      }
+      map.set(name, prop.initializer);
+    } else if (ts4.isShorthandPropertyAssignment(prop)) {
+      map.set(prop.name.text, prop.name);
+    } else {
+      return;
+    }
+  });
+  return map;
+}
+function castDeclarationToClassOrDie(declaration) {
+  if (!ts4.isClassDeclaration(declaration)) {
+    throw new Error(`Reflecting on a ${ts4.SyntaxKind[declaration.kind]} instead of a ClassDeclaration.`);
+  }
+  return declaration;
+}
+function parameterName(name) {
+  if (ts4.isIdentifier(name)) {
+    return name.text;
+  } else {
+    return null;
+  }
+}
+function propertyNameToString(node) {
+  if (ts4.isIdentifier(node) || ts4.isStringLiteral(node) || ts4.isNumericLiteral(node)) {
+    return node.text;
+  } else {
+    return null;
+  }
+}
+function getQualifiedNameRoot(qualifiedName) {
+  while (ts4.isQualifiedName(qualifiedName.left)) {
+    qualifiedName = qualifiedName.left;
+  }
+  return ts4.isIdentifier(qualifiedName.left) ? qualifiedName.left : null;
+}
+function getFarLeftIdentifier(propertyAccess) {
+  while (ts4.isPropertyAccessExpression(propertyAccess.expression)) {
+    propertyAccess = propertyAccess.expression;
+  }
+  return ts4.isIdentifier(propertyAccess.expression) ? propertyAccess.expression : null;
+}
+function getContainingImportDeclaration(node) {
+  return ts4.isImportSpecifier(node) ? node.parent.parent.parent : ts4.isNamespaceImport(node) ? node.parent.parent : null;
+}
+function getExportedName(decl, originalId) {
+  return ts4.isImportSpecifier(decl) ? (decl.propertyName !== void 0 ? decl.propertyName : decl.name).text : originalId.text;
+}
+var LocalExportedDeclarations = Symbol("LocalExportedDeclarations");
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
+import ts5 from "typescript";
 var TS = /\.tsx?$/i;
 var D_TS = /\.d\.ts$/i;
 function isSymbolWithValueDeclaration(symbol) {
@@ -30,31 +656,31 @@ function isNonDeclarationTsPath(filePath) {
 function isFromDtsFile(node) {
   let sf = node.getSourceFile();
   if (sf === void 0) {
-    sf = ts.getOriginalNode(node).getSourceFile();
+    sf = ts5.getOriginalNode(node).getSourceFile();
   }
   return sf !== void 0 && sf.isDeclarationFile;
 }
 function nodeNameForError(node) {
-  if (node.name !== void 0 && ts.isIdentifier(node.name)) {
+  if (node.name !== void 0 && ts5.isIdentifier(node.name)) {
     return node.name.text;
   } else {
-    const kind = ts.SyntaxKind[node.kind];
-    const { line, character } = ts.getLineAndCharacterOfPosition(node.getSourceFile(), node.getStart());
+    const kind = ts5.SyntaxKind[node.kind];
+    const { line, character } = ts5.getLineAndCharacterOfPosition(node.getSourceFile(), node.getStart());
     return `${kind}@${line}:${character}`;
   }
 }
 function getSourceFile(node) {
   const directSf = node.getSourceFile();
-  return directSf !== void 0 ? directSf : ts.getOriginalNode(node).getSourceFile();
+  return directSf !== void 0 ? directSf : ts5.getOriginalNode(node).getSourceFile();
 }
 function getSourceFileOrNull(program, fileName) {
   return program.getSourceFile(fileName) || null;
 }
 function getTokenAtPosition(sf, pos) {
-  return ts.getTokenAtPosition(sf, pos);
+  return ts5.getTokenAtPosition(sf, pos);
 }
 function identifierOfNode(decl) {
-  if (decl.name !== void 0 && ts.isIdentifier(decl.name)) {
+  if (decl.name !== void 0 && ts5.isIdentifier(decl.name)) {
     return decl.name;
   } else {
     return null;
@@ -64,14 +690,14 @@ function isDeclaration(node) {
   return isValueDeclaration(node) || isTypeDeclaration(node);
 }
 function isValueDeclaration(node) {
-  return ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isVariableDeclaration(node);
+  return ts5.isClassDeclaration(node) || ts5.isFunctionDeclaration(node) || ts5.isVariableDeclaration(node);
 }
 function isTypeDeclaration(node) {
-  return ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node);
+  return ts5.isEnumDeclaration(node) || ts5.isTypeAliasDeclaration(node) || ts5.isInterfaceDeclaration(node);
 }
 function isNamedDeclaration(node) {
   const namedNode = node;
-  return namedNode.name !== void 0 && ts.isIdentifier(namedNode.name);
+  return namedNode.name !== void 0 && ts5.isIdentifier(namedNode.name);
 }
 function getRootDirs(host, options) {
   const rootDirs = [];
@@ -88,8 +714,8 @@ function getRootDirs(host, options) {
 }
 function nodeDebugInfo(node) {
   const sf = getSourceFile(node);
-  const { line, character } = ts.getLineAndCharacterOfPosition(sf, node.pos);
-  return `[${sf.fileName}: ${ts.SyntaxKind[node.kind]} @ ${line}:${character}]`;
+  const { line, character } = ts5.getLineAndCharacterOfPosition(sf, node.pos);
+  return `[${sf.fileName}: ${ts5.SyntaxKind[node.kind]} @ ${line}:${character}]`;
 }
 function resolveModuleName(moduleName, containingFile, compilerOptions, compilerHost, moduleResolutionCache) {
   if (compilerHost.resolveModuleNames) {
@@ -101,11 +727,11 @@ function resolveModuleName(moduleName, containingFile, compilerOptions, compiler
       compilerOptions
     )[0];
   } else {
-    return ts.resolveModuleName(moduleName, containingFile, compilerOptions, compilerHost, moduleResolutionCache !== null ? moduleResolutionCache : void 0).resolvedModule;
+    return ts5.resolveModuleName(moduleName, containingFile, compilerOptions, compilerHost, moduleResolutionCache !== null ? moduleResolutionCache : void 0).resolvedModule;
   }
 }
 function isAssignment(node) {
-  return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+  return ts5.isBinaryExpression(node) && node.operatorToken.kind === ts5.SyntaxKind.EqualsToken;
 }
 function toUnredirectedSourceFile(sf) {
   const redirectInfo = sf.redirectInfo;
@@ -115,7 +741,7 @@ function toUnredirectedSourceFile(sf) {
   return redirectInfo.unredirected;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
 var Reference = class {
   constructor(node, bestGuessOwningModule = null) {
     this.node = node;
@@ -178,14 +804,14 @@ var Reference = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
 import { ExternalExpr as ExternalExpr2 } from "@angular/compiler";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
 import { ExternalExpr, ExternalReference, WrappedNodeExpr } from "@angular/compiler";
-import ts3 from "typescript";
+import ts7 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.mjs
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["DECORATOR_ARG_NOT_LITERAL"] = 1001] = "DECORATOR_ARG_NOT_LITERAL";
@@ -259,7 +885,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["SUGGEST_SUBOPTIMAL_TYPE_INFERENCE"] = 10002] = "SUGGEST_SUBOPTIMAL_TYPE_INFERENCE";
 })(ErrorCode || (ErrorCode = {}));
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
 var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
   ErrorCode.DECORATOR_ARG_NOT_LITERAL,
   ErrorCode.IMPORT_CYCLE_DETECTED,
@@ -271,10 +897,10 @@ var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
   ErrorCode.WARN_NGMODULE_ID_UNNECESSARY
 ]);
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
-import ts2 from "typescript";
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
+import ts6 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
 var ERROR_CODE_MATCHER = /(\u001b\[\d+m ?)TS-99(\d+: ?\u001b\[\d+m)/g;
 function replaceTsWithNgInErrors(errors) {
   return errors.replace(ERROR_CODE_MATCHER, "$1NG$2");
@@ -283,7 +909,7 @@ function ngErrorCode(code) {
   return parseInt("-99" + code);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
 var FatalDiagnosticError = class {
   constructor(code, node, message, relatedInformation) {
     this.code = code;
@@ -297,11 +923,11 @@ var FatalDiagnosticError = class {
   }
 };
 function makeDiagnostic(code, node, messageText, relatedInformation) {
-  node = ts2.getOriginalNode(node);
+  node = ts6.getOriginalNode(node);
   return {
-    category: ts2.DiagnosticCategory.Error,
+    category: ts6.DiagnosticCategory.Error,
     code: ngErrorCode(code),
-    file: ts2.getOriginalNode(node).getSourceFile(),
+    file: ts6.getOriginalNode(node).getSourceFile(),
     start: node.getStart(void 0, false),
     length: node.getWidth(),
     messageText,
@@ -310,16 +936,16 @@ function makeDiagnostic(code, node, messageText, relatedInformation) {
 }
 function makeDiagnosticChain(messageText, next) {
   return {
-    category: ts2.DiagnosticCategory.Message,
+    category: ts6.DiagnosticCategory.Message,
     code: 0,
     messageText,
     next
   };
 }
 function makeRelatedInformation(node, messageText) {
-  node = ts2.getOriginalNode(node);
+  node = ts6.getOriginalNode(node);
   return {
-    category: ts2.DiagnosticCategory.Message,
+    category: ts6.DiagnosticCategory.Message,
     code: 0,
     file: node.getSourceFile(),
     start: node.getStart(),
@@ -339,10 +965,10 @@ function addDiagnosticChain(messageText, add) {
   return messageText;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
 var ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
 var ExtendedTemplateDiagnosticName;
 (function(ExtendedTemplateDiagnosticName2) {
   ExtendedTemplateDiagnosticName2["INVALID_BANANA_IN_BOX"] = "invalidBananaInBox";
@@ -355,7 +981,7 @@ var ExtendedTemplateDiagnosticName;
   ExtendedTemplateDiagnosticName2["SKIP_HYDRATION_NOT_STATIC"] = "skipHydrationNotStatic";
 })(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
 function findExportedNameOfNode(target, file, reflector) {
   const exports = reflector.getExportsOfModule(file);
   if (exports === null) {
@@ -375,7 +1001,7 @@ function findExportedNameOfNode(target, file, reflector) {
   return foundExportName;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
 var ImportFlags;
 (function(ImportFlags2) {
   ImportFlags2[ImportFlags2["None"] = 0] = "None";
@@ -447,9 +1073,9 @@ var AbsoluteModuleStrategy = class {
     if (ref.bestGuessOwningModule === null) {
       return null;
     } else if (!isDeclaration(ref.node)) {
-      throw new Error(`Debug assert: unable to import a Reference to non-declaration of type ${ts3.SyntaxKind[ref.node.kind]}.`);
+      throw new Error(`Debug assert: unable to import a Reference to non-declaration of type ${ts7.SyntaxKind[ref.node.kind]}.`);
     } else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && isTypeDeclaration(ref.node)) {
-      throw new Error(`Importing a type-only declaration of type ${ts3.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);
+      throw new Error(`Importing a type-only declaration of type ${ts7.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);
     }
     const { specifier, resolutionContext } = ref.bestGuessOwningModule;
     const exports = this.getExportsOfModule(specifier, resolutionContext);
@@ -591,7 +1217,7 @@ var UnifiedModulesStrategy = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
 var CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;
 var UnifiedModulesAliasingHost = class {
   constructor(unifiedModulesHost) {
@@ -658,7 +1284,7 @@ var AliasStrategy = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
 function relativePathBetween(from, to) {
   const relativePath = stripExtension(relative(dirname(resolve(from)), resolve(to)));
   return relativePath !== "" ? toRelativeImport(relativePath) : null;
@@ -667,7 +1293,7 @@ function normalizeSeparators(path) {
   return path.replace(/\\/g, "/");
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
 var NoopImportRewriter = class {
   shouldImportSymbol(symbol, specifier) {
     return true;
@@ -725,8 +1351,8 @@ function validateAndRewriteCoreSymbol(name) {
   return CORE_SUPPORTED_SYMBOLS.get(name);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/patch_alias_reference_resolution.mjs
-import ts4 from "typescript";
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/patch_alias_reference_resolution.mjs
+import ts8 from "typescript";
 var patchedReferencedAliasesSymbol = Symbol("patchedReferencedAliases");
 function loadIsReferencedAliasDeclarationPatch(context) {
   if (!isTransformationContextWithEmitResolver(context)) {
@@ -751,7 +1377,7 @@ function loadIsReferencedAliasDeclarationPatch(context) {
   return emitResolver[patchedReferencedAliasesSymbol] = referencedAliases;
 }
 function isAliasImportDeclaration(node) {
-  return ts4.isImportSpecifier(node) || ts4.isNamespaceImport(node) || ts4.isImportClause(node);
+  return ts8.isImportSpecifier(node) || ts8.isNamespaceImport(node) || ts8.isImportClause(node);
 }
 function isTransformationContextWithEmitResolver(context) {
   return context.getEmitResolver !== void 0;
@@ -760,7 +1386,7 @@ function throwIncompatibleTransformationContextError() {
   throw Error("Angular compiler is incompatible with this version of the TypeScript compiler.\n\nIf you recently updated TypeScript and this issue surfaces now, consider downgrading.\n\nPlease report an issue on the Angular repositories when this issue surfaces and you are using a supposedly compatible TypeScript version.");
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
 var DefaultImportDeclaration = Symbol("DefaultImportDeclaration");
 function attachDefaultImportDeclaration(expr, importDecl) {
   expr[DefaultImportDeclaration] = importDecl;
@@ -801,7 +1427,100 @@ var DefaultImportTracker = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
+import ts9 from "typescript";
+var AssumeEager = "AssumeEager";
+var DeferredSymbolTracker = class {
+  constructor(typeChecker) {
+    this.typeChecker = typeChecker;
+    this.imports = /* @__PURE__ */ new Map();
+  }
+  extractImportedSymbols(importDecl) {
+    const symbolMap = /* @__PURE__ */ new Map();
+    if (importDecl.importClause === void 0) {
+      throw new Error(`Provided import declaration doesn't have any symbols.`);
+    }
+    if (importDecl.importClause.namedBindings !== void 0) {
+      const bindings = importDecl.importClause.namedBindings;
+      if (ts9.isNamedImports(bindings)) {
+        for (const element of bindings.elements) {
+          symbolMap.set(element.name.text, AssumeEager);
+        }
+      } else {
+        symbolMap.set(bindings.name.text, AssumeEager);
+      }
+    } else if (importDecl.importClause.name !== void 0) {
+      symbolMap.set(importDecl.importClause.name.text, AssumeEager);
+    } else {
+      throw new Error("Unrecognized import structure.");
+    }
+    return symbolMap;
+  }
+  markAsDeferrableCandidate(identifier, importDecl) {
+    if (!this.imports.has(importDecl)) {
+      const symbolMap2 = this.extractImportedSymbols(importDecl);
+      this.imports.set(importDecl, symbolMap2);
+    }
+    const symbolMap = this.imports.get(importDecl);
+    if (!symbolMap.has(identifier.text)) {
+      throw new Error(`The '${identifier.text}' identifier doesn't belong to the provided import declaration.`);
+    }
+    if (symbolMap.get(identifier.text) === AssumeEager) {
+      symbolMap.set(identifier.text, this.lookupIdentifiersInSourceFile(identifier.text, importDecl));
+    }
+    const identifiers = symbolMap.get(identifier.text);
+    identifiers.delete(identifier);
+  }
+  canDefer(importDecl) {
+    if (!this.imports.has(importDecl)) {
+      return false;
+    }
+    const symbolsMap = this.imports.get(importDecl);
+    for (const [symbol, refs] of symbolsMap) {
+      if (refs === AssumeEager || refs.size > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getDeferrableImportDecls() {
+    const deferrableDecls = /* @__PURE__ */ new Set();
+    for (const [importDecl] of this.imports) {
+      if (this.canDefer(importDecl)) {
+        deferrableDecls.add(importDecl);
+      }
+    }
+    return deferrableDecls;
+  }
+  lookupIdentifiersInSourceFile(name, importDecl) {
+    const results = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (node === importDecl) {
+        return;
+      }
+      if (ts9.isIdentifier(node) && node.text === name) {
+        const sym = this.typeChecker.getSymbolAtLocation(node);
+        if (sym === void 0) {
+          return;
+        }
+        if (sym.declarations === void 0 || sym.declarations.length === 0) {
+          return;
+        }
+        const importClause = sym.declarations[0];
+        const decl = getContainingImportDeclaration(importClause);
+        if (decl !== importDecl) {
+          return;
+        }
+        results.add(node);
+      }
+      ts9.forEachChild(node, visit);
+    };
+    visit(importDecl.getSourceFile());
+    return results;
+  }
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
 var ModuleResolver = class {
   constructor(program, compilerOptions, host, moduleResolutionCache) {
     this.program = program;
@@ -864,6 +1583,14 @@ export {
   attachDefaultImportDeclaration,
   getDefaultImportDeclaration,
   DefaultImportTracker,
+  ClassMemberKind,
+  typeNodeToValueExpr,
+  isNamedClassDeclaration,
+  TypeScriptReflectionHost,
+  reflectTypeEntityToDeclaration,
+  filterToMembersWithDecorator,
+  reflectObjectLiteral,
+  DeferredSymbolTracker,
   Reference,
   ModuleResolver
 };
@@ -874,4 +1601,4 @@ export {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-//# sourceMappingURL=chunk-WF3L5COT.js.map
+//# sourceMappingURL=chunk-OCDXYAWW.js.map