@artel/artc 0.6.25222 → 0.6.25223

package/build/{chunk-ODWG5ZXF.js → chunk-DZNNWICP.js}

@@ -577,7 +577,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.25222" : "";
+var ArtelVersion = true ? "0.6.25223" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -1159,68 +1159,68 @@ __export(green_exports, {
 });
 
 // source/tree/KeywordKind.ts
-var KeywordKind = /* @__PURE__ */ ((KeywordKind6) => {
-  KeywordKind6[KeywordKind6["Unknown"] = 0] = "Unknown";
-  KeywordKind6[KeywordKind6["Let"] = 1] = "Let";
-  KeywordKind6[KeywordKind6["Autotype"] = 2] = "Autotype";
-  KeywordKind6[KeywordKind6["Aspect"] = 3] = "Aspect";
-  KeywordKind6[KeywordKind6["Object"] = 4] = "Object";
-  KeywordKind6[KeywordKind6["PlainObject"] = 5] = "PlainObject";
-  KeywordKind6[KeywordKind6["Variant"] = 6] = "Variant";
-  KeywordKind6[KeywordKind6["Run"] = 7] = "Run";
-  KeywordKind6[KeywordKind6["Try"] = 8] = "Try";
-  KeywordKind6[KeywordKind6["From"] = 9] = "From";
-  KeywordKind6[KeywordKind6["Else"] = 10] = "Else";
-  KeywordKind6[KeywordKind6["ElseIf"] = 11] = "ElseIf";
-  KeywordKind6[KeywordKind6["Function"] = 12] = "Function";
-  KeywordKind6[KeywordKind6["If"] = 13] = "If";
-  KeywordKind6[KeywordKind6["Is"] = 14] = "Is";
-  KeywordKind6[KeywordKind6["Return"] = 15] = "Return";
-  KeywordKind6[KeywordKind6["Type"] = 16] = "Type";
-  KeywordKind6[KeywordKind6["Basic"] = 17] = "Basic";
-  KeywordKind6[KeywordKind6["Import"] = 18] = "Import";
-  KeywordKind6[KeywordKind6["Important"] = 19] = "Important";
-  KeywordKind6[KeywordKind6["Error"] = 20] = "Error";
-  KeywordKind6[KeywordKind6["Finally"] = 21] = "Finally";
-  KeywordKind6[KeywordKind6["And"] = 22] = "And";
-  KeywordKind6[KeywordKind6["Or"] = 23] = "Or";
-  KeywordKind6[KeywordKind6["Xor"] = 24] = "Xor";
-  KeywordKind6[KeywordKind6["While"] = 25] = "While";
-  KeywordKind6[KeywordKind6["Loop"] = 26] = "Loop";
-  KeywordKind6[KeywordKind6["RepeatWhile"] = 27] = "RepeatWhile";
-  KeywordKind6[KeywordKind6["Yield"] = 28] = "Yield";
-  KeywordKind6[KeywordKind6["When"] = 29] = "When";
-  KeywordKind6[KeywordKind6["Creation"] = 30] = "Creation";
-  KeywordKind6[KeywordKind6["Catch"] = 31] = "Catch";
-  KeywordKind6[KeywordKind6["BreakLoop"] = 32] = "BreakLoop";
-  KeywordKind6[KeywordKind6["ContinueLoop"] = 33] = "ContinueLoop";
-  KeywordKind6[KeywordKind6["For"] = 34] = "For";
-  KeywordKind6[KeywordKind6["Const"] = 35] = "Const";
-  KeywordKind6[KeywordKind6["Hidden"] = 36] = "Hidden";
-  KeywordKind6[KeywordKind6["Abstract"] = 37] = "Abstract";
-  KeywordKind6[KeywordKind6["Redefinable"] = 38] = "Redefinable";
-  KeywordKind6[KeywordKind6["Redefined"] = 39] = "Redefined";
-  KeywordKind6[KeywordKind6["Async"] = 40] = "Async";
-  KeywordKind6[KeywordKind6["Static"] = 41] = "Static";
-  KeywordKind6[KeywordKind6["As"] = 42] = "As";
-  KeywordKind6[KeywordKind6["Not"] = 43] = "Not";
-  KeywordKind6[KeywordKind6["Switch"] = 44] = "Switch";
-  KeywordKind6[KeywordKind6["Case"] = 45] = "Case";
-  KeywordKind6[KeywordKind6["Dispose"] = 46] = "Dispose";
-  KeywordKind6[KeywordKind6["Destruction"] = 47] = "Destruction";
-  KeywordKind6[KeywordKind6["InHierarchy"] = 48] = "InHierarchy";
-  KeywordKind6[KeywordKind6["InFile"] = 49] = "InFile";
-  KeywordKind6[KeywordKind6["InPackage"] = 50] = "InPackage";
-  KeywordKind6[KeywordKind6["InType"] = 51] = "InType";
-  KeywordKind6[KeywordKind6["Yes"] = 52] = "Yes";
-  KeywordKind6[KeywordKind6["No"] = 53] = "No";
-  KeywordKind6[KeywordKind6["Reference"] = 54] = "Reference";
-  KeywordKind6[KeywordKind6["Translations"] = 55] = "Translations";
-  KeywordKind6[KeywordKind6["Base"] = 56] = "Base";
-  KeywordKind6[KeywordKind6["None"] = 57] = "None";
-  KeywordKind6[KeywordKind6["Get"] = 58] = "Get";
-  KeywordKind6[KeywordKind6["Set"] = 59] = "Set";
-  return KeywordKind6;
+var KeywordKind = /* @__PURE__ */ ((KeywordKind5) => {
+  KeywordKind5[KeywordKind5["Unknown"] = 0] = "Unknown";
+  KeywordKind5[KeywordKind5["Let"] = 1] = "Let";
+  KeywordKind5[KeywordKind5["Autotype"] = 2] = "Autotype";
+  KeywordKind5[KeywordKind5["Aspect"] = 3] = "Aspect";
+  KeywordKind5[KeywordKind5["Object"] = 4] = "Object";
+  KeywordKind5[KeywordKind5["PlainObject"] = 5] = "PlainObject";
+  KeywordKind5[KeywordKind5["Variant"] = 6] = "Variant";
+  KeywordKind5[KeywordKind5["Run"] = 7] = "Run";
+  KeywordKind5[KeywordKind5["Try"] = 8] = "Try";
+  KeywordKind5[KeywordKind5["From"] = 9] = "From";
+  KeywordKind5[KeywordKind5["Else"] = 10] = "Else";
+  KeywordKind5[KeywordKind5["ElseIf"] = 11] = "ElseIf";
+  KeywordKind5[KeywordKind5["Function"] = 12] = "Function";
+  KeywordKind5[KeywordKind5["If"] = 13] = "If";
+  KeywordKind5[KeywordKind5["Is"] = 14] = "Is";
+  KeywordKind5[KeywordKind5["Return"] = 15] = "Return";
+  KeywordKind5[KeywordKind5["Type"] = 16] = "Type";
+  KeywordKind5[KeywordKind5["Basic"] = 17] = "Basic";
+  KeywordKind5[KeywordKind5["Import"] = 18] = "Import";
+  KeywordKind5[KeywordKind5["Important"] = 19] = "Important";
+  KeywordKind5[KeywordKind5["Error"] = 20] = "Error";
+  KeywordKind5[KeywordKind5["Finally"] = 21] = "Finally";
+  KeywordKind5[KeywordKind5["And"] = 22] = "And";
+  KeywordKind5[KeywordKind5["Or"] = 23] = "Or";
+  KeywordKind5[KeywordKind5["Xor"] = 24] = "Xor";
+  KeywordKind5[KeywordKind5["While"] = 25] = "While";
+  KeywordKind5[KeywordKind5["Loop"] = 26] = "Loop";
+  KeywordKind5[KeywordKind5["RepeatWhile"] = 27] = "RepeatWhile";
+  KeywordKind5[KeywordKind5["Yield"] = 28] = "Yield";
+  KeywordKind5[KeywordKind5["When"] = 29] = "When";
+  KeywordKind5[KeywordKind5["Creation"] = 30] = "Creation";
+  KeywordKind5[KeywordKind5["Catch"] = 31] = "Catch";
+  KeywordKind5[KeywordKind5["BreakLoop"] = 32] = "BreakLoop";
+  KeywordKind5[KeywordKind5["ContinueLoop"] = 33] = "ContinueLoop";
+  KeywordKind5[KeywordKind5["For"] = 34] = "For";
+  KeywordKind5[KeywordKind5["Const"] = 35] = "Const";
+  KeywordKind5[KeywordKind5["Hidden"] = 36] = "Hidden";
+  KeywordKind5[KeywordKind5["Abstract"] = 37] = "Abstract";
+  KeywordKind5[KeywordKind5["Redefinable"] = 38] = "Redefinable";
+  KeywordKind5[KeywordKind5["Redefined"] = 39] = "Redefined";
+  KeywordKind5[KeywordKind5["Async"] = 40] = "Async";
+  KeywordKind5[KeywordKind5["Static"] = 41] = "Static";
+  KeywordKind5[KeywordKind5["As"] = 42] = "As";
+  KeywordKind5[KeywordKind5["Not"] = 43] = "Not";
+  KeywordKind5[KeywordKind5["Switch"] = 44] = "Switch";
+  KeywordKind5[KeywordKind5["Case"] = 45] = "Case";
+  KeywordKind5[KeywordKind5["Dispose"] = 46] = "Dispose";
+  KeywordKind5[KeywordKind5["Destruction"] = 47] = "Destruction";
+  KeywordKind5[KeywordKind5["InHierarchy"] = 48] = "InHierarchy";
+  KeywordKind5[KeywordKind5["InFile"] = 49] = "InFile";
+  KeywordKind5[KeywordKind5["InPackage"] = 50] = "InPackage";
+  KeywordKind5[KeywordKind5["InType"] = 51] = "InType";
+  KeywordKind5[KeywordKind5["Yes"] = 52] = "Yes";
+  KeywordKind5[KeywordKind5["No"] = 53] = "No";
+  KeywordKind5[KeywordKind5["Reference"] = 54] = "Reference";
+  KeywordKind5[KeywordKind5["Translations"] = 55] = "Translations";
+  KeywordKind5[KeywordKind5["Base"] = 56] = "Base";
+  KeywordKind5[KeywordKind5["None"] = 57] = "None";
+  KeywordKind5[KeywordKind5["Get"] = 58] = "Get";
+  KeywordKind5[KeywordKind5["Set"] = 59] = "Set";
+  return KeywordKind5;
 })(KeywordKind || {});
 
 // source/tree/NodeKind.ts
@@ -2530,18 +2530,44 @@ var Scanner = class _Scanner {
     return this.token;
   }
   lookAhead(callback) {
-    return this.tryScanOrLookAhead(
-      callback,
-      /* alwaysRestoreState: */
-      true
-    );
+    const savedToken = this.token;
+    const savedCurrentPosition = this.currentPosition;
+    const savedBraceBalance = this.braceBalance;
+    let savedTextTemplateBraceBalanceStack = void 0;
+    if (this.textTemplateBraceBalanceStack.length > 0) {
+      savedTextTemplateBraceBalanceStack = this.textTemplateBraceBalanceStack.slice();
+    }
+    const result = callback();
+    this.token = savedToken;
+    this.currentPosition = savedCurrentPosition;
+    this.braceBalance = savedBraceBalance;
+    if (savedTextTemplateBraceBalanceStack !== void 0) {
+      this.textTemplateBraceBalanceStack = savedTextTemplateBraceBalanceStack;
+    } else {
+      this.textTemplateBraceBalanceStack.length = 0;
+    }
+    return result;
   }
   tryScan(callback) {
-    return this.tryScanOrLookAhead(
-      callback,
-      /* alwaysRestoreState: */
-      false
-    );
+    const savedToken = this.token;
+    const savedCurrentPosition = this.currentPosition;
+    const savedBraceBalance = this.braceBalance;
+    let savedTextTemplateBraceBalanceStack = void 0;
+    if (this.textTemplateBraceBalanceStack.length > 0) {
+      savedTextTemplateBraceBalanceStack = this.textTemplateBraceBalanceStack.slice();
+    }
+    const result = callback();
+    if (result === void 0) {
+      this.token = savedToken;
+      this.currentPosition = savedCurrentPosition;
+      this.braceBalance = savedBraceBalance;
+      if (savedTextTemplateBraceBalanceStack !== void 0) {
+        this.textTemplateBraceBalanceStack = savedTextTemplateBraceBalanceStack;
+      } else {
+        this.textTemplateBraceBalanceStack.length = 0;
+      }
+    }
+    return result;
   }
   nextToken() {
     if (this.skipWhitespace) {
@@ -2866,27 +2892,6 @@ var Scanner = class _Scanner {
     this.token = new Token(kind, value, startPosition, unterminated);
     return this.token;
   }
-  tryScanOrLookAhead(callback, alwaysRestoreState) {
-    const savedToken = this.token;
-    const savedCurrentPosition = this.currentPosition;
-    const savedBraceBalance = this.braceBalance;
-    let savedTextTemplateBraceBalanceStack = void 0;
-    if (this.textTemplateBraceBalanceStack.length > 0) {
-      savedTextTemplateBraceBalanceStack = this.textTemplateBraceBalanceStack.slice();
-    }
-    const result = callback();
-    if (alwaysRestoreState || !result) {
-      this.token = savedToken;
-      this.currentPosition = savedCurrentPosition;
-      this.braceBalance = savedBraceBalance;
-      if (savedTextTemplateBraceBalanceStack !== void 0) {
-        this.textTemplateBraceBalanceStack = savedTextTemplateBraceBalanceStack;
-      } else {
-        this.textTemplateBraceBalanceStack.length = 0;
-      }
-    }
-    return result;
-  }
   isCloseBraceEndingTextTemplate() {
     return this.textTemplateBraceBalanceStack.length > 0 && this.braceBalance === 1;
   }
@@ -7179,14 +7184,11 @@ var FunctionBlock = class extends BaseNode {
   get openBraceToken() {
     return this.children[0];
   }
-  get expression() {
+  get expressionOrStatementList() {
     return this.children[1];
   }
-  get statementList() {
-    return this.children[2];
-  }
   get closeBraceToken() {
-    return this.children[3];
+    return this.children[2];
   }
   get thisAsNode() {
     return this;
@@ -7194,9 +7196,9 @@ var FunctionBlock = class extends BaseNode {
   createChildren() {
     return [
       this.green.openBraceToken.toRed(childRangeStart(this, 0), this),
-      this.green.expression?.toRed(childRangeStart(this, 1), this),
-      this.green.statementList?.toRed(childRangeStart(this, 2), this),
-      this.green.closeBraceToken.toRed(childRangeStart(this, 3), this)
+      // @ts-ignore: Expression produces a union type that is too complex to represent.
+      this.green.expressionOrStatementList.toRed(childRangeStart(this, 1), this),
+      this.green.closeBraceToken.toRed(childRangeStart(this, 2), this)
     ];
   }
 };
@@ -11065,22 +11067,19 @@ var StatementBlock2 = class extends BaseNode2 {
   }
 };
 var FunctionBlock2 = class extends BaseNode2 {
-  constructor(openBraceToken, expression, statementList, closeBraceToken) {
+  constructor(openBraceToken, expressionOrStatementList, closeBraceToken) {
     super();
     this.kind = 94 /* FunctionBlock */;
-    this.children = [openBraceToken, expression, statementList, closeBraceToken];
+    this.children = [openBraceToken, expressionOrStatementList, closeBraceToken];
   }
   get openBraceToken() {
     return this.children[0];
   }
-  get expression() {
+  get expressionOrStatementList() {
     return this.children[1];
   }
-  get statementList() {
-    return this.children[2];
-  }
   get closeBraceToken() {
-    return this.children[3];
+    return this.children[2];
   }
   get thisAsNode() {
     return this;
@@ -14233,15 +14232,15 @@ var LocalizationContext = class {
   getTranslationLocale(packageEntity) {
     return this._translationPackageByTranslated.get(packageEntity)?.getTranslationLocale() ?? packageEntity.getLocale();
   }
-  getTranslatedTypeEntityMembers(typeEntity) {
-    if (!isPackageTypeEntity(typeEntity)) {
+  getTranslatedTypeOrExtensionEntityMembers(entity) {
+    if (entity.kind === 11 /* TypeExtension */ || !isPackageTypeEntity(entity)) {
       return void 0;
     }
-    const translationPackage = this._translationPackageByTranslated.get(typeEntity.getContainingPackage());
+    const translationPackage = this._translationPackageByTranslated.get(entity.getContainingPackage());
     if (translationPackage === void 0) {
       return void 0;
     }
-    return translationPackage.getTypeEntityMembers(typeEntity);
+    return translationPackage.getTypeEntityMembers(entity);
   }
   getEntityName(entity) {
     const containingPackage = getPackageContainingEntity(entity);
@@ -18847,7 +18846,7 @@ var TextParser = class {
     this._diagnosticStartPositions = new Set(this._diagnosticStartPositions);
     this._skippedTokenOrKeywords = savedSkippedTokenOrKeywords.slice();
     const result = this._scanner.tryScan(callback);
-    if (!result) {
+    if (result === void 0) {
       this._nextTokenStartPosition = savedCurrentTokenStartPosition;
       this._nextToken = savedNextToken;
       this._currentTokenOrKeyword = savedTokenOrKeyword;
@@ -18964,11 +18963,9 @@ var TextParser = class {
       if (keywordPart !== void 0) {
         const keywordStart = this._nextTokenStartPosition;
         if (keywordPart.subsequentParts !== void 0) {
-          let parts;
-          this.tryParse(() => {
+          const parts = this.tryParse(() => {
             this.nextToken();
-            parts = this.tryParseKeywordParts(keywordPart.subsequentParts);
-            return parts !== void 0;
+            return this.tryParseKeywordParts(keywordPart.subsequentParts);
           });
           if (parts !== void 0) {
             result = { tokens: [identifier2, ...parts.tokens], kind: parts.kind, startPosition: keywordStart };
@@ -19351,27 +19348,28 @@ var StatementParser = class {
     let result;
     const blockStart = this.parser.tokenOrKeywordStartPosition();
     const openBraceToken = this.parser.parseExpectedToken(43 /* OpenBrace */);
-    let expression = void 0;
-    let statementList = void 0;
     if (!openBraceToken.isMissing) {
-      if (allowSingleExpression && this.canParseAsBlockWithSingleExpression()) {
-        expression = this.parser.expressionParser.parseExpression(false);
-      } else {
-        statementList = this.parseStatementList();
+      let expressionOrStatementList;
+      if (allowSingleExpression) {
+        expressionOrStatementList = this.tryParseFunctionBlockExpression();
+      }
+      if (expressionOrStatementList === void 0) {
+        expressionOrStatementList = this.parseStatementList();
       }
       const closeBraceToken = this.parser.parseExpectedToken(20 /* CloseBrace */);
       result = this.parser.intern(
-        new FunctionBlock2(openBraceToken, expression, statementList, closeBraceToken),
+        new FunctionBlock2(openBraceToken, expressionOrStatementList, closeBraceToken),
         blockStart
       );
     } else {
+      const expressionOrStatementList = this.parser.intern(new StatementList2([]), blockStart);
       const flags = 1 /* Missing */;
       const closeBraceToken = this.parser.intern(
         new Token5(20 /* CloseBrace */, "", [], flags, void 0),
         blockStart
       );
       result = this.parser.intern(
-        new FunctionBlock2(openBraceToken, statementList, expression, closeBraceToken),
+        new FunctionBlock2(openBraceToken, expressionOrStatementList, closeBraceToken),
         blockStart
       );
       result = this.parser.intern(result, blockStart);
@@ -19497,14 +19495,17 @@ var StatementParser = class {
     const result = new EnumerationVariableDeclaration2(name);
     return this.parser.intern(result, declarationStart);
   }
-  canParseAsBlockWithSingleExpression() {
+  tryParseFunctionBlockExpression() {
+    let result;
     if (!this.parser.expressionParser.isStartOfExpression(false)) {
-      return false;
+      result = void 0;
+    } else {
+      result = this.parser.tryParse(() => {
+        const expression = this.parser.expressionParser.parseExpression(false);
+        return this.parser.currentTokenOrKeyword.isToken(20 /* CloseBrace */) ? expression : void 0;
+      });
     }
-    return this.parser.lookAhead(() => {
-      this.parser.expressionParser.parseExpression(false);
-      return this.parser.currentTokenOrKeyword.isToken(20 /* CloseBrace */);
-    });
+    return result;
   }
   canParseOptionalExpression(isFollowedByStatementBlock) {
     if (!this.parser.expressionParser.isStartOfExpression(isFollowedByStatementBlock)) {
@@ -20864,7 +20865,7 @@ var TagParser = class {
     const hashSignToken = this.parser.parseExpectedToken(35 /* HashSign */);
     const name = this.parser.parseQualifiedName(36 /* TagNameExpected */);
     let typeArgumentClause;
-    if (this.parser.typeArgumentParser.canParseTypeArgumentClause()) {
+    if (this.parser.typeArgumentParser.isStartOfTypeArgumentClause()) {
       typeArgumentClause = this.parser.typeArgumentParser.parseTypeArgumentClause();
     }
     let openParenthesisToken;
@@ -21008,6 +21009,9 @@ var TypeArgumentParser = class {
     const result = new TypeArgumentList2(elements);
     return this.parser.intern(result, listStart);
   }
+  isStartOfTypeArgumentClause() {
+    return this.parser.currentTokenOrKeyword.isToken(36 /* LessThan */);
+  }
   canParseTypeArgumentClause() {
     return this.parser.lookAhead(() => {
       const typeArgumentClause = this.parseTypeArgumentClause();
@@ -23684,6 +23688,9 @@ var Constructor = class {
   isHidden() {
     return this._entity.isHidden();
   }
+  isStatic() {
+    return false;
+  }
   equals(other) {
     if (this === other) {
       return true;
@@ -23712,6 +23719,9 @@ var Destructor = class _Destructor {
   isHidden() {
     return this._entity.isHidden();
   }
+  isStatic() {
+    return false;
+  }
   applySubstitutions(substitutions) {
     return new _Destructor(this._entity, this._substitutions.substituteTypes(substitutions.map));
   }
@@ -23746,6 +23756,9 @@ var Indexer = class _Indexer {
   isHidden() {
     return this._entity.isHidden();
   }
+  isStatic() {
+    return this._entity.isStatic();
+  }
   applySubstitutions(substitutions) {
     return new _Indexer(this._entity, this._substitutions.substituteTypes(substitutions.map));
   }
@@ -23774,6 +23787,9 @@ var DereferenceOperator = class _DereferenceOperator {
   isHidden() {
     return this._entity.isHidden();
   }
+  isStatic() {
+    return false;
+  }
   applySubstitutions(substitutions) {
     return new _DereferenceOperator(this._entity, this._substitutions.substituteTypes(substitutions.map));
   }
@@ -23950,9 +23966,9 @@ var FoundAnonymousDeclaration = class _FoundAnonymousDeclaration {
 
 // source/analysis/TypeMemberLookup.ts
 var TypeMemberLookup = class _TypeMemberLookup {
-  constructor(_analyzer, _type, _localizationContext) {
+  constructor(_analyzer, _typeOrExtension, _localizationContext) {
     this._analyzer = _analyzer;
-    this._type = _type;
+    this._typeOrExtension = _typeOrExtension;
     this._localizationContext = _localizationContext;
     this._searchLocale = new Cached();
   }
@@ -23962,12 +23978,12 @@ var TypeMemberLookup = class _TypeMemberLookup {
   get searchLocale() {
     return this._searchLocale.getOrInsertWith(() => {
       let result;
-      const typeEntity = this._type.getEntity();
-      if (typeEntity !== void 0) {
-        if (isNamedTypeEntity(typeEntity)) {
-          result = this.getLocaleOfTypeEntity(typeEntity);
+      const typeOrExtensionEntity = this._typeOrExtension.getEntity();
+      if (typeOrExtensionEntity !== void 0) {
+        if (typeOrExtensionEntity.kind === 2 /* Type */ && isNamedTypeEntity(typeOrExtensionEntity)) {
+          result = this.getLocaleOfTypeEntity(typeOrExtensionEntity);
         } else {
-          result = getPackageContainingEntity(typeEntity).getLocale();
+          result = getPackageContainingEntity(typeOrExtensionEntity).getLocale();
         }
       } else {
         result = this._localizationContext?.originalLocale ?? DefaultLocale;
@@ -23975,37 +23991,54 @@ var TypeMemberLookup = class _TypeMemberLookup {
       return result;
     });
   }
+  static ofType(analyzer, type, localizationContext) {
+    const typeOrExtension = new TypeOrExtension_type(type);
+    return new _TypeMemberLookup(analyzer, typeOrExtension, localizationContext);
+  }
   static ofTypeEntity(analyzer, entity, localizationContext) {
     const type = analyzer.instantiateTypeByIdentitySubstitution(entity);
-    return new _TypeMemberLookup(analyzer, type, localizationContext);
+    return _TypeMemberLookup.ofType(analyzer, type, localizationContext);
   }
-  getNamedMembers(hidingMatcher, typeExtensionsLookup) {
+  static ofTypeExtension(analyzer, typeExtension, localizationContext) {
+    const typeOrExtension = new TypeOrExtension_extension(typeExtension);
+    return new _TypeMemberLookup(analyzer, typeOrExtension, localizationContext);
+  }
+  static ofTypeOrExtension(analyzer, typeOrExtension, localizationContext) {
+    return new _TypeMemberLookup(analyzer, typeOrExtension, localizationContext);
+  }
+  getNamedMembers(options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new NamedTypeMemberLookup(this._analyzer, this.searchLocale, this._localizationContext);
-    return lookup.getMembers(this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getMembers(this._typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getNamedMembersByName(name, hidingMatcher, typeExtensionsLookup) {
+  getNamedMembersByName(name, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new NamedTypeMemberLookup(this._analyzer, this.searchLocale, this._localizationContext);
-    return lookup.getMembersByName(name, this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getMembersByName(name, this._typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOperators(hidingMatcher, typeExtensionsLookup) {
+  getOperators(options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new OperatorLookup(this._analyzer, this._localizationContext);
-    return lookup.getOperators(this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getOperators(this._typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOperatorsByKind(kind, hidingMatcher, typeExtensionsLookup) {
+  getOperatorsByKind(kind, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new OperatorLookup(this._analyzer, this._localizationContext);
-    return lookup.getOperatorsByKind(kind, this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getOperatorsByKind(
+      kind,
+      this._typeOrExtension,
+      options,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
   }
   getConstructors(hidingMatcher, typeExtensionsLookup) {
-    const lookup = new ConstructorLookup(this._localizationContext);
-    return lookup.getConstructors(this._type, hidingMatcher, typeExtensionsLookup);
+    const lookup = new ConstructorLookup(this._analyzer, this._localizationContext);
+    return lookup.getConstructors(this._typeOrExtension, hidingMatcher, typeExtensionsLookup);
   }
-  getIndexers(hidingMatcher, typeExtensionsLookup) {
+  getIndexers(options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new IndexerLookup(this._analyzer, this._localizationContext);
-    return lookup.getIndexers(this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getIndexers(this._typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getDereferenceOperators(hidingMatcher, typeExtensionsLookup) {
+  getDereferenceOperators(options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
     const lookup = new DereferenceOperatorLookup(this._analyzer, this._localizationContext);
-    return lookup.getDereferenceOperators(this._type, hidingMatcher, typeExtensionsLookup);
+    return lookup.getDereferenceOperators(this._typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
   getLocaleOfTypeEntity(typeEntity) {
     const containingPackage = getPackageContainingEntity(typeEntity);
@@ -24017,63 +24050,108 @@ var TypeMemberLookup = class _TypeMemberLookup {
   }
 };
 var BoundTypeMemberLookup = class _BoundTypeMemberLookup {
-  constructor(analyzer, type, localizationContext, hidingMatcher, typeExtensionLookup) {
-    this._lookup = new TypeMemberLookup(analyzer, type, localizationContext);
+  constructor(analyzer, typeOrExtension, localizationContext, options = 0 /* None */, hidingMatcher, typeExtensionLookup) {
+    this._lookup = TypeMemberLookup.ofTypeOrExtension(analyzer, typeOrExtension, localizationContext);
+    this._options = options;
     this._hidingMatcher = hidingMatcher;
     this._typeExtensionLookup = typeExtensionLookup;
   }
-  static ofTypeEntity(analyzer, entity, localizationContext, hidingMatcher, typeExtensionLookup) {
+  static ofType(analyzer, type, localizationContext, options = 0 /* None */, hidingMatcher, typeExtensionLookup) {
+    const typeOrExtension = new TypeOrExtension_type(type);
+    return new _BoundTypeMemberLookup(
+      analyzer,
+      typeOrExtension,
+      localizationContext,
+      options,
+      hidingMatcher,
+      typeExtensionLookup
+    );
+  }
+  static ofTypeEntity(analyzer, entity, localizationContext, options = 0 /* None */, hidingMatcher, typeExtensionLookup) {
     const type = analyzer.instantiateTypeByIdentitySubstitution(entity);
-    return new _BoundTypeMemberLookup(analyzer, type, localizationContext, hidingMatcher, typeExtensionLookup);
+    return this.ofType(analyzer, type, localizationContext, options, hidingMatcher, typeExtensionLookup);
+  }
+  static ofTypeExtension(analyzer, typeExtension, localizationContext, options = 0 /* None */, hidingMatcher, typeExtensionLookup) {
+    const typeOrExtension = new TypeOrExtension_extension(typeExtension);
+    return new _BoundTypeMemberLookup(
+      analyzer,
+      typeOrExtension,
+      localizationContext,
+      options,
+      hidingMatcher,
+      typeExtensionLookup
+    );
   }
   getNamedMembers() {
-    return this._lookup.getNamedMembers(this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getNamedMembers(this._options, this._hidingMatcher, this._typeExtensionLookup);
   }
   getNamedMembersByName(name) {
-    return this._lookup.getNamedMembersByName(name, this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getNamedMembersByName(
+      name,
+      this._options,
+      this._hidingMatcher,
+      this._typeExtensionLookup
+    );
   }
   getOperators() {
-    return this._lookup.getOperators(this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getOperators(this._options, this._hidingMatcher, this._typeExtensionLookup);
   }
   getOperatorsByKind(kind) {
-    return this._lookup.getOperatorsByKind(kind, this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getOperatorsByKind(
+      kind,
+      this._options,
+      this._hidingMatcher,
+      this._typeExtensionLookup
+    );
   }
   getConstructors() {
     return this._lookup.getConstructors(this._hidingMatcher, this._typeExtensionLookup);
   }
   getIndexers() {
-    return this._lookup.getIndexers(this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getIndexers(this._options, this._hidingMatcher, this._typeExtensionLookup);
   }
   getDereferenceOperators() {
-    return this._lookup.getDereferenceOperators(this._hidingMatcher, this._typeExtensionLookup);
+    return this._lookup.getDereferenceOperators(this._options, this._hidingMatcher, this._typeExtensionLookup);
   }
 };
+var TypeMemberLookupOptions = /* @__PURE__ */ ((TypeMemberLookupOptions2) => {
+  TypeMemberLookupOptions2[TypeMemberLookupOptions2["None"] = 0] = "None";
+  TypeMemberLookupOptions2[TypeMemberLookupOptions2["OnlyInstanceMembers"] = 1] = "OnlyInstanceMembers";
+  TypeMemberLookupOptions2[TypeMemberLookupOptions2["OnlyStaticMembers"] = 2] = "OnlyStaticMembers";
+  return TypeMemberLookupOptions2;
+})(TypeMemberLookupOptions || {});
 var TypeMemberLookupBase = class {
   constructor(analyzer) {
     this._analyzer = analyzer;
   }
-  getAllMembersOfType(type, hidingMatcher, typeExtensionsLookup) {
-    switch (type.kind) {
-      case "structured":
-        return this.getAllMembersOfStructuredType(type, hidingMatcher, typeExtensionsLookup);
-      case "variant":
-        return this.getAllMembersOfVariantType(type, hidingMatcher, typeExtensionsLookup);
-      case "method":
-        return this.getAllMembersOfMethodType(type, hidingMatcher, typeExtensionsLookup);
-      case "alias":
-        return this.getAllMembersOfAliasType(type, hidingMatcher, typeExtensionsLookup);
-      case "parameter":
-        return this.getAllMembersOfParameterType(type, hidingMatcher, typeExtensionsLookup);
-      case "union":
-        return this.getAllMembersOfUnionType(type, hidingMatcher, typeExtensionsLookup);
-      case "unresolved":
-        return [];
-      default:
-        Debug.never(type);
+  getAllMembers(typeOrExtension, options, hidingMatcher, typeExtensionsLookup) {
+    let result;
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      result = this.getAllMembersOfTypeOrExtension(
+        typeOrExtension,
+        options,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+    } else {
+      result = this.getAllMembersOfTypeOrExtension(
+        typeOrExtension,
+        1 /* OnlyInstanceMembers */,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+      const staticMembers = this.getAllMembersOfTypeOrExtension(
+        typeOrExtension,
+        2 /* OnlyStaticMembers */,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+      result = this.mergeMembers(result, [staticMembers], false);
     }
+    return result;
   }
-  getOriginalLocaleOfTypeEntity(typeEntity) {
-    return getPackageContainingEntity(typeEntity).getLocale();
+  getOriginalLocaleOfTypeOrExtensionEntity(entity) {
+    return getPackageContainingEntity(entity).getLocale();
   }
   mergeMembers(shadowingMembers, shadowedMembersFromMultipleTypes, mergeNonAspectShadowedMembersFirst) {
     const result = Array.from(shadowingMembers);
@@ -24113,94 +24191,167 @@ var TypeMemberLookupBase = class {
     }
     return result;
   }
-  getAllMembersOfStructuredType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfRegularType(
+  getAllMembersOfTypeOrExtension(typeOrExtension, options, hidingMatcher, typeExtensionsLookup) {
+    switch (typeOrExtension.kind) {
+      case "type":
+        return this.getAllMembersOfType(typeOrExtension.value, options, hidingMatcher, typeExtensionsLookup);
+      case "extension": {
+        let extendedType;
+        let substitutions;
+        const extendedTypeEntity = typeOrExtension.value.getExtendedTypeEntity();
+        if (extendedTypeEntity !== void 0) {
+          extendedType = this._analyzer.instantiateTypeByIdentitySubstitution(extendedTypeEntity);
+          substitutions = extendedType.getSubstitutions();
+        } else {
+          extendedType = void 0;
+          substitutions = Substitutions2.empty(this._analyzer);
+        }
+        return this.getAllMembersOfRegularTypeOrExtension(
+          typeOrExtension.value,
+          substitutions,
+          void 0,
+          void 0,
+          extendedType,
+          options,
+          hidingMatcher,
+          typeExtensionsLookup
+        );
+      }
+      default:
+        Debug.never(typeOrExtension);
+    }
+  }
+  getAllMembersOfType(type, options, hidingMatcher, typeExtensionsLookup) {
+    switch (type.kind) {
+      case "structured":
+        return this.getAllMembersOfStructuredType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "variant":
+        return this.getAllMembersOfVariantType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "method":
+        return this.getAllMembersOfMethodType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "alias":
+        return this.getAllMembersOfAliasType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "parameter":
+        return this.getAllMembersOfParameterType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "union":
+        return this.getAllMembersOfUnionType(type, options, hidingMatcher, typeExtensionsLookup);
+      case "unresolved":
+        return [];
+      default:
+        Debug.never(type);
+    }
+  }
+  getAllMembersOfStructuredType(type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembersOfRegularTypeOrExtension(
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseObjectType(),
       type.getBaseAspectTypes(),
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getAllMembersOfVariantType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfRegularType(
+  getAllMembersOfVariantType(type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembersOfRegularTypeOrExtension(
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseType(),
       void 0,
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getAllMembersOfMethodType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfRegularType(
+  getAllMembersOfMethodType(type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembersOfRegularTypeOrExtension(
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseType(),
       void 0,
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getAllMembersOfAliasType(type, hidingMatcher, typeExtensionsLookup) {
-    const ownMembers = this.getOwnMembersMatchingHiding(type.getEntity(), type.getSubstitutions(), hidingMatcher);
+  getAllMembersOfAliasType(type, options, hidingMatcher, typeExtensionsLookup) {
+    const ownMembers = this.getOwnMembersMatchingHiding(
+      type.getEntity(),
+      type.getSubstitutions(),
+      options,
+      hidingMatcher
+    );
     const baseAndExtensionMembers = new Array();
     const aliasedType = type.getAliasedType();
-    const aliasedTypeMembers = this.getAllMembersOfType(aliasedType, hidingMatcher, typeExtensionsLookup);
+    const aliasedTypeMembers = this.getAllMembersOfType(
+      aliasedType,
+      options,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
     baseAndExtensionMembers.push(aliasedTypeMembers);
     if (typeExtensionsLookup !== void 0) {
       const extensionMembers = this.getMembersOfExtensionsMatchingHiding(
         type.getEntity(),
         type.getSubstitutions(),
+        options,
         typeExtensionsLookup,
         hidingMatcher
       );
-      baseAndExtensionMembers.push(...extensionMembers);
+      baseAndExtensionMembers.push(extensionMembers);
     }
     const result = this.mergeMembers(ownMembers, baseAndExtensionMembers, false);
     return result;
   }
-  getAllMembersOfParameterType(type, hidingMatcher, typeExtensionsLookup) {
+  getAllMembersOfParameterType(type, options, hidingMatcher, typeExtensionsLookup) {
     let result = [];
     if (type.constraint !== void 0) {
-      result = this.getAllMembersOfType(type.constraint, hidingMatcher, typeExtensionsLookup);
+      result = this.getAllMembersOfType(type.constraint, options, hidingMatcher, typeExtensionsLookup);
     }
     return result;
   }
-  getAllMembersOfUnionType(type, hidingMatcher, typeExtensionsLookup) {
+  getAllMembersOfUnionType(type, options, hidingMatcher, typeExtensionsLookup) {
     const commonBaseTypes = this._analyzer.getCommonObjectAndAspectTypesOfUnion(type);
-    const result = commonBaseTypes.flatMap((t) => this.getAllMembersOfStructuredType(t, hidingMatcher, typeExtensionsLookup));
+    const result = commonBaseTypes.flatMap((t) => this.getAllMembersOfStructuredType(t, options, hidingMatcher, typeExtensionsLookup));
     return result;
   }
-  getAllMembersOfRegularType(typeEntity, substitutions, baseObjectType, baseAspectTypes, hidingMatcher, typeExtensionsLookup) {
-    const ownMembers = this.getOwnMembersMatchingHiding(typeEntity, substitutions, hidingMatcher);
+  getAllMembersOfRegularTypeOrExtension(entity, substitutions, baseObjectType, baseAspectTypes, extendedType, options, hidingMatcher, typeExtensionsLookup) {
+    const ownMembers = this.getOwnMembersMatchingHiding(entity, substitutions, options, hidingMatcher);
     const baseAndExtensionMembers = new Array();
     if (baseObjectType !== void 0) {
-      const members = this.getAllMembersOfType(baseObjectType, hidingMatcher, typeExtensionsLookup);
+      const members = this.getAllMembersOfType(baseObjectType, options, hidingMatcher, typeExtensionsLookup);
       baseAndExtensionMembers.push(members);
     }
     if (baseAspectTypes !== void 0 && baseAspectTypes.length > 0) {
-      const aspectsMembers = baseAspectTypes.map((a) => this.getAllMembersOfType(a, hidingMatcher, typeExtensionsLookup));
+      const aspectsMembers = baseAspectTypes.map((a) => this.getAllMembersOfType(a, options, hidingMatcher, typeExtensionsLookup));
       baseAndExtensionMembers.push(...aspectsMembers);
     }
-    if (typeExtensionsLookup !== void 0) {
+    if (extendedType !== void 0) {
+      const members = this.getAllMembersOfType(extendedType, options, hidingMatcher, typeExtensionsLookup);
+      baseAndExtensionMembers.push(members);
+    }
+    if (typeExtensionsLookup !== void 0 && entity.kind === 2 /* Type */) {
       const membersOfExtensions = this.getMembersOfExtensionsMatchingHiding(
-        typeEntity,
+        entity,
         substitutions,
+        options,
         typeExtensionsLookup,
         hidingMatcher
       );
-      baseAndExtensionMembers.push(...membersOfExtensions);
+      baseAndExtensionMembers.push(membersOfExtensions);
     }
     const result = this.mergeMembers(ownMembers, baseAndExtensionMembers, true);
     return result;
   }
-  getOwnMembersMatchingHiding(typeEntity, substitutions, hidingMatcher) {
-    if (!isTypeEntityWithMembers(typeEntity)) {
-      return [];
+  getOwnMembersMatchingHiding(entity, substitutions, options, hidingMatcher) {
+    let members = this.getOwnMembers(entity, substitutions);
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      const isStatic = (options & 2 /* OnlyStaticMembers */) !== 0;
+      members = members.filter((m) => m.value.isStatic() === isStatic);
     }
-    let members = this.getOwnMembers(typeEntity, substitutions);
     if (hidingMatcher !== void 0) {
       members = members.filter((m) => {
         const hiding = m.value.isHidden();
@@ -24209,142 +24360,243 @@ var TypeMemberLookupBase = class {
     }
     return members;
   }
-  getMembersOfExtensionsMatchingHiding(typeEntity, substitutions, typeExtensionsLookup, hidingMatcher) {
+  getMembersOfExtensionsMatchingHiding(typeEntity, substitutions, options, typeExtensionsLookup, hidingMatcher) {
     const extensions = typeExtensionsLookup.getTypeExtensionsByType(typeEntity);
-    let membersOfExtensions = this.getMembersOfExtensions(extensions, substitutions);
+    let members = this.getMembersOfExtensions(extensions, substitutions);
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      const isStatic = (options & 2 /* OnlyStaticMembers */) !== 0;
+      members = members.filter((m) => m.value.isStatic() === isStatic);
+    }
     if (hidingMatcher !== void 0) {
-      membersOfExtensions = membersOfExtensions.map(
-        (members) => members.filter((m) => {
-          const hiding = m.value.isHidden();
-          return hiding === void 0 || hidingMatcher.matches(hiding);
-        })
-      );
+      members = members.filter((m) => {
+        const hiding = m.value.isHidden();
+        return hiding === void 0 || hidingMatcher.matches(hiding);
+      });
     }
-    return membersOfExtensions;
+    return members;
   }
 };
 var TypeMemberLookupByKeyBase = class extends TypeMemberLookupBase {
   constructor(analyzer) {
     super(analyzer);
   }
-  getMembersOfTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
+  getMembersByKey(key, typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    let result;
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      result = this.getMembersOfTypeOrExtension(key, typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
+    } else {
+      result = this.getMembersOfTypeOrExtension(
+        key,
+        typeOrExtension,
+        1 /* OnlyInstanceMembers */,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+      if (result.length === 0) {
+        result = this.getMembersOfTypeOrExtension(
+          key,
+          typeOrExtension,
+          0 /* None */,
+          hidingMatcher,
+          typeExtensionsLookup
+        );
+      }
+    }
+    return result;
+  }
+  getMembersOfTypeOrExtension(key, typeOrExtension, options, hidingMatcher, typeExtensionsLookup) {
+    switch (typeOrExtension.kind) {
+      case "type":
+        return this.getMembersOfTypeByKey(key, typeOrExtension.value, options, hidingMatcher, typeExtensionsLookup);
+      case "extension": {
+        let extendedType;
+        let substitutions;
+        const extendedTypeEntity = typeOrExtension.value.getExtendedTypeEntity();
+        if (extendedTypeEntity !== void 0) {
+          extendedType = this._analyzer.instantiateTypeByIdentitySubstitution(extendedTypeEntity);
+          substitutions = extendedType.getSubstitutions();
+        } else {
+          extendedType = void 0;
+          substitutions = Substitutions2.empty(this._analyzer);
+        }
+        return this.getMembersOfRegularTypeOrExtensionByKey(
+          key,
+          typeOrExtension.value,
+          substitutions,
+          void 0,
+          void 0,
+          extendedType,
+          options,
+          hidingMatcher,
+          typeExtensionsLookup
+        );
+      }
+      default:
+        Debug.never(typeOrExtension);
+    }
+  }
+  getMembersOfTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
     switch (type.kind) {
       case "structured":
-        return this.getMembersOfStructuredTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfStructuredTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "variant":
-        return this.getMembersOfVariantTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfVariantTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "method":
-        return this.getMembersOfMethodTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfMethodTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "alias":
-        return this.getMembersOfAliasTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfAliasTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "parameter":
-        return this.getMembersOfParameterTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfParameterTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "union":
-        return this.getMembersOfUnionTypeByKey(key, type, hidingMatcher, typeExtensionsLookup);
+        return this.getMembersOfUnionTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup);
       case "unresolved":
         return [];
       default:
         Debug.never(type);
     }
   }
-  getMembersOfStructuredTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
-    return this.getMembersOfRegularTypeByKey(
+  getMembersOfStructuredTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getMembersOfRegularTypeOrExtensionByKey(
       key,
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseObjectType(),
       type.getBaseAspectTypes(),
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getMembersOfVariantTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
-    return this.getMembersOfRegularTypeByKey(
+  getMembersOfVariantTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getMembersOfRegularTypeOrExtensionByKey(
       key,
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseType(),
       void 0,
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getMembersOfMethodTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
-    return this.getMembersOfRegularTypeByKey(
+  getMembersOfMethodTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
+    return this.getMembersOfRegularTypeOrExtensionByKey(
       key,
       type.getEntity(),
       type.getSubstitutions(),
       type.getBaseType(),
       void 0,
+      void 0,
+      options,
       hidingMatcher,
       typeExtensionsLookup
     );
   }
-  getMembersOfAliasTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
+  getMembersOfAliasTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
     const ownMembers = this.getOwnMembersByKeyMatchingHiding(
       key,
       type.getEntity(),
       type.getSubstitutions(),
+      options,
       hidingMatcher
     );
     const baseAndExtensionMembers = new Array();
     const aliasedType = type.getAliasedType();
-    const aliasedTypeMembers = this.getMembersOfTypeByKey(key, aliasedType, hidingMatcher, typeExtensionsLookup);
+    const aliasedTypeMembers = this.getMembersOfTypeByKey(
+      key,
+      aliasedType,
+      options,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
     baseAndExtensionMembers.push(aliasedTypeMembers);
     if (typeExtensionsLookup !== void 0) {
       const extensionMembers = this.getMembersOfExtensionsByKeyMatchingHiding(
         key,
         type.getEntity(),
         type.getSubstitutions(),
+        options,
         typeExtensionsLookup,
         hidingMatcher
       );
-      baseAndExtensionMembers.push(...extensionMembers);
+      baseAndExtensionMembers.push(extensionMembers);
     }
     const result = this.mergeMembers(ownMembers, baseAndExtensionMembers, false);
     return result;
   }
-  getMembersOfParameterTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
+  getMembersOfParameterTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
     let result = new Array();
     if (type.constraint !== void 0) {
-      result = this.getMembersOfTypeByKey(key, type.constraint, hidingMatcher, typeExtensionsLookup);
+      result = this.getMembersOfTypeByKey(key, type.constraint, options, hidingMatcher, typeExtensionsLookup);
     }
     return result;
   }
-  getMembersOfUnionTypeByKey(key, type, hidingMatcher, typeExtensionsLookup) {
+  getMembersOfUnionTypeByKey(key, type, options, hidingMatcher, typeExtensionsLookup) {
     const commonBaseTypes = this._analyzer.getCommonObjectAndAspectTypesOfUnion(type);
-    const result = commonBaseTypes.flatMap((t) => this.getMembersOfStructuredTypeByKey(key, t, hidingMatcher, typeExtensionsLookup));
+    const result = commonBaseTypes.flatMap((t) => this.getMembersOfStructuredTypeByKey(
+      key,
+      t,
+      options,
+      hidingMatcher,
+      typeExtensionsLookup
+    ));
     return result;
   }
-  getMembersOfRegularTypeByKey(key, typeEntity, substitutions, baseObjectType, baseAspectTypes, hidingMatcher, typeExtensionsLookup) {
-    const ownMembers = this.getOwnMembersByKeyMatchingHiding(key, typeEntity, substitutions, hidingMatcher);
+  getMembersOfRegularTypeOrExtensionByKey(key, entity, substitutions, baseObjectType, baseAspectTypes, extendedType, options, hidingMatcher, typeExtensionsLookup) {
+    const ownMembers = this.getOwnMembersByKeyMatchingHiding(
+      key,
+      entity,
+      substitutions,
+      options,
+      hidingMatcher
+    );
     const baseAndExtensionMembers = new Array();
     if (baseObjectType !== void 0) {
-      const members = this.getMembersOfTypeByKey(key, baseObjectType, hidingMatcher, typeExtensionsLookup);
+      const members = this.getMembersOfTypeByKey(
+        key,
+        baseObjectType,
+        options,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
       baseAndExtensionMembers.push(members);
     }
     if (baseAspectTypes !== void 0 && baseAspectTypes.length > 0) {
-      const aspectsMembers = baseAspectTypes.map((a) => this.getMembersOfTypeByKey(key, a, hidingMatcher, typeExtensionsLookup));
+      const aspectsMembers = baseAspectTypes.map((a) => this.getMembersOfTypeByKey(key, a, options, hidingMatcher, typeExtensionsLookup));
       baseAndExtensionMembers.push(...aspectsMembers);
     }
-    if (typeExtensionsLookup !== void 0) {
+    if (extendedType !== void 0) {
+      const members = this.getMembersOfTypeByKey(
+        key,
+        extendedType,
+        options,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+      baseAndExtensionMembers.push(members);
+    }
+    if (typeExtensionsLookup !== void 0 && entity.kind === 2 /* Type */) {
       const membersOfExtensions = this.getMembersOfExtensionsByKeyMatchingHiding(
         key,
-        typeEntity,
+        entity,
         substitutions,
+        options,
         typeExtensionsLookup,
         hidingMatcher
       );
-      baseAndExtensionMembers.push(...membersOfExtensions);
+      baseAndExtensionMembers.push(membersOfExtensions);
     }
     const result = this.mergeMembers(ownMembers, baseAndExtensionMembers, true);
     return result;
   }
-  getOwnMembersByKeyMatchingHiding(key, typeEntity, substitutions, hidingMatcher) {
-    if (!isTypeEntityWithMembers(typeEntity)) {
-      return [];
+  getOwnMembersByKeyMatchingHiding(key, entity, substitutions, options, hidingMatcher) {
+    let members = this.getOwnMembersByKey(key, entity, substitutions);
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      const isStatic = (options & 2 /* OnlyStaticMembers */) !== 0;
+      members = members.filter((m) => m.value.isStatic() === isStatic);
     }
-    let members = this.getOwnMembersByKey(key, typeEntity, substitutions);
     if (hidingMatcher !== void 0) {
       members = members.filter((m) => {
         const hiding = m.value.isHidden();
@@ -24353,18 +24605,20 @@ var TypeMemberLookupByKeyBase = class extends TypeMemberLookupBase {
     }
     return members;
   }
-  getMembersOfExtensionsByKeyMatchingHiding(key, typeEntity, substitutions, typeExtensionsLookup, hidingMatcher) {
+  getMembersOfExtensionsByKeyMatchingHiding(key, typeEntity, substitutions, options, typeExtensionsLookup, hidingMatcher) {
     const extensions = typeExtensionsLookup.getTypeExtensionsByType(typeEntity);
-    let membersOfExtensions = this.getMembersOfExtensionsByKey(key, extensions, substitutions);
+    let members = this.getMembersOfExtensionsByKey(key, extensions, substitutions);
+    if ((options & (1 /* OnlyInstanceMembers */ | 2 /* OnlyStaticMembers */)) !== 0) {
+      const isStatic = (options & 2 /* OnlyStaticMembers */) !== 0;
+      members = members.filter((m) => m.value.isStatic() === isStatic);
+    }
     if (hidingMatcher !== void 0) {
-      membersOfExtensions = membersOfExtensions.map(
-        (members) => members.filter((m) => {
-          const hiding = m.value.isHidden();
-          return hiding === void 0 || hidingMatcher.matches(hiding);
-        })
-      );
+      members = members.filter((m) => {
+        const hiding = m.value.isHidden();
+        return hiding === void 0 || hidingMatcher.matches(hiding);
+      });
     }
-    return membersOfExtensions;
+    return members;
   }
 };
 var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
@@ -24373,17 +24627,17 @@ var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
     this._searchLocale = searchLocale;
     this._localizationContext = localizationContext;
   }
-  getMembersByName(name, type, hidingMatcher, typeExtensionsLookup) {
-    return super.getMembersOfTypeByKey(name, type, hidingMatcher, typeExtensionsLookup);
+  getMembersByName(name, typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return super.getMembersByKey(name, typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getMembers(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfType(type, hidingMatcher, typeExtensionsLookup);
+  getMembers(typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembers(typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOwnMembers(typeEntity, substitutions) {
+  getOwnMembers(entity, substitutions) {
     let result;
     const translatedMemberEntities = /* @__PURE__ */ new Set();
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
     if (translatedMembers !== void 0 && translatedMembers.translationPackage.getTranslationLocale() === this._searchLocale) {
       const members = translatedMembers.getNamedMembers();
       result = members.map((m) => FoundNamedDeclaration.translated(this.convertNamedMember(m.value, substitutions), m.name));
@@ -24393,7 +24647,7 @@ var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
     }
     const isExplicitOriginalNameRequired = originalLocale !== this._searchLocale;
     result = result.concat(
-      typeEntity.getMembers().getNamedMembers().filter((m) => !translatedMemberEntities.has(m)).map((m) => FoundNamedDeclaration.original(
+      entity.getMembers().getNamedMembers().filter((m) => !translatedMemberEntities.has(m)).map((m) => FoundNamedDeclaration.original(
         this.convertNamedMember(m, substitutions),
         m.getName(),
         originalLocale,
@@ -24403,7 +24657,7 @@ var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
     return result;
   }
   getMembersOfExtensions(extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getNamedMembers().map((m) => FoundNamedDeclaration.original(
         this.convertNamedMember(m, substitutions),
@@ -24414,13 +24668,13 @@ var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
     });
     return result;
   }
-  getOwnMembersByKey(name, typeEntity, substitutions) {
+  getOwnMembersByKey(name, entity, substitutions) {
     let result;
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
     if (name.isStrictlyOriginal || originalLocale === this._searchLocale) {
       const isExplicitOriginalNameRequired = originalLocale !== this._searchLocale;
-      result = typeEntity.getMembers().getNamedMembersByName(name.value).map(
+      result = entity.getMembers().getNamedMembersByName(name.value).map(
         (m) => FoundNamedDeclaration.original(
           this.convertNamedMember(m, substitutions),
           m.getName(),
@@ -24436,7 +24690,7 @@ var NamedTypeMemberLookup = class extends TypeMemberLookupByKeyBase {
     return result;
   }
   getMembersOfExtensionsByKey(name, extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getNamedMembersByName(name.value).map(
         (m) => FoundNamedDeclaration.original(
@@ -24490,16 +24744,16 @@ var OperatorLookup = class extends TypeMemberLookupByKeyBase {
     super(analyzer);
     this._localizationContext = localizationContext;
   }
-  getOperatorsByKind(kind, type, hidingMatcher, typeExtensionsLookup) {
-    return this.getMembersOfTypeByKey(kind, type, hidingMatcher, typeExtensionsLookup);
+  getOperatorsByKind(kind, typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return this.getMembersByKey(kind, typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOperators(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfType(type, hidingMatcher, typeExtensionsLookup);
+  getOperators(typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembers(typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOwnMembers(typeEntity, substitutions) {
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
-    const result = typeEntity.getMembers().getOperators().map((o) => {
+  getOwnMembers(entity, substitutions) {
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
+    const result = entity.getMembers().getOperators().map((o) => {
       const member = new Operator(this._analyzer, o, substitutions);
       if (translatedMembers !== void 0) {
         const translation = new Translation(translatedMembers.translationPackage);
@@ -24511,7 +24765,7 @@ var OperatorLookup = class extends TypeMemberLookupByKeyBase {
     return result;
   }
   getMembersOfExtensions(extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getOperators().map((o) => FoundAnonymousDeclaration.original(
         new Operator(this._analyzer, o, substitutions),
@@ -24520,10 +24774,10 @@ var OperatorLookup = class extends TypeMemberLookupByKeyBase {
     });
     return result;
   }
-  getOwnMembersByKey(kind, typeEntity, substitutions) {
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
-    const result = typeEntity.getMembers().getOperatorsByKind(kind).map((o) => {
+  getOwnMembersByKey(kind, entity, substitutions) {
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
+    const result = entity.getMembers().getOperatorsByKind(kind).map((o) => {
       const member = new Operator(this._analyzer, o, substitutions);
       if (translatedMembers !== void 0) {
         const translation = new Translation(translatedMembers.translationPackage);
@@ -24535,7 +24789,7 @@ var OperatorLookup = class extends TypeMemberLookupByKeyBase {
     return result;
   }
   getMembersOfExtensionsByKey(kind, extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getOperatorsByKind(kind).map((o) => FoundAnonymousDeclaration.original(
         new Operator(this._analyzer, o, substitutions),
@@ -24559,13 +24813,13 @@ var IndexerLookup = class extends TypeMemberLookupBase {
     super(analyzer);
     this._localizationContext = localizationContext;
   }
-  getIndexers(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfType(type, hidingMatcher, typeExtensionsLookup);
+  getIndexers(typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembers(typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOwnMembers(typeEntity, substitutions) {
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
-    const result = typeEntity.getMembers().getIndexers().map((i) => {
+  getOwnMembers(entity, substitutions) {
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
+    const result = entity.getMembers().getIndexers().map((i) => {
       const member = new Indexer(i, substitutions);
       if (translatedMembers !== void 0) {
         const translation = new Translation(translatedMembers.translationPackage);
@@ -24577,7 +24831,7 @@ var IndexerLookup = class extends TypeMemberLookupBase {
     return result;
   }
   getMembersOfExtensions(extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getIndexers().map((i) => FoundAnonymousDeclaration.original(new Indexer(i, substitutions), originalLocale));
     });
@@ -24598,13 +24852,13 @@ var DereferenceOperatorLookup = class extends TypeMemberLookupBase {
     super(analyzer);
     this._localizationContext = localizationContext;
   }
-  getDereferenceOperators(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getAllMembersOfType(type, hidingMatcher, typeExtensionsLookup);
+  getDereferenceOperators(typeOrExtension, options = 0 /* None */, hidingMatcher, typeExtensionsLookup) {
+    return this.getAllMembers(typeOrExtension, options, hidingMatcher, typeExtensionsLookup);
   }
-  getOwnMembers(typeEntity, substitutions) {
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = this.getOriginalLocaleOfTypeEntity(typeEntity);
-    const result = typeEntity.getMembers().getDereferenceOperators().map((i) => {
+  getOwnMembers(entity, substitutions) {
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = this.getOriginalLocaleOfTypeOrExtensionEntity(entity);
+    const result = entity.getMembers().getDereferenceOperators().map((i) => {
       const member = new DereferenceOperator(i, substitutions);
       if (translatedMembers !== void 0) {
         const translation = new Translation(translatedMembers.translationPackage);
@@ -24616,7 +24870,7 @@ var DereferenceOperatorLookup = class extends TypeMemberLookupBase {
     return result;
   }
   getMembersOfExtensions(extensions, substitutions) {
-    const result = extensions.map((e) => {
+    const result = extensions.flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getDereferenceOperators().map((i) => FoundAnonymousDeclaration.original(new DereferenceOperator(i, substitutions), originalLocale));
     });
@@ -24631,10 +24885,32 @@ var DereferenceOperatorLookup = class extends TypeMemberLookupBase {
   }
 };
 var ConstructorLookup = class {
-  constructor(localizationContext) {
+  constructor(analyzer, localizationContext) {
+    this._analyzer = analyzer;
     this._localizationContext = localizationContext;
   }
-  getConstructors(type, hidingMatcher, typeExtensionsLookup) {
+  getConstructors(typeOrExtension, hidingMatcher, typeExtensionsLookup) {
+    switch (typeOrExtension.kind) {
+      case "type":
+        return this.getConstructorsOfType(typeOrExtension.value, hidingMatcher, typeExtensionsLookup);
+      case "extension": {
+        const extendedTypeEntity = typeOrExtension.value.getExtendedTypeEntity();
+        if (extendedTypeEntity === void 0) {
+          return [];
+        }
+        const extendedType = this._analyzer.instantiateTypeByIdentitySubstitution(extendedTypeEntity);
+        return this.getConstructorsOfTypeWithOwnMembersOrExtension(
+          typeOrExtension.value,
+          extendedType,
+          hidingMatcher,
+          typeExtensionsLookup
+        );
+      }
+      default:
+        Debug.never(typeOrExtension);
+    }
+  }
+  getConstructorsOfType(type, hidingMatcher, typeExtensionsLookup) {
     switch (type.kind) {
       case "structured":
         return this.getConstructorsOfStructuredType(type, hidingMatcher, typeExtensionsLookup);
@@ -24653,13 +24929,28 @@ var ConstructorLookup = class {
     }
   }
   getConstructorsOfStructuredType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getConstructorsOfTypeWithOwnMembers(type.getEntity(), type, hidingMatcher, typeExtensionsLookup);
+    return this.getConstructorsOfTypeWithOwnMembersOrExtension(
+      type.getEntity(),
+      type,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
   }
   getConstructorsOfVariantType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getConstructorsOfTypeWithOwnMembers(type.getEntity(), type, hidingMatcher, typeExtensionsLookup);
+    return this.getConstructorsOfTypeWithOwnMembersOrExtension(
+      type.getEntity(),
+      type,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
   }
   getConstructorsOfMethodType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getConstructorsOfTypeWithOwnMembers(type.getEntity(), type, hidingMatcher, typeExtensionsLookup);
+    return this.getConstructorsOfTypeWithOwnMembersOrExtension(
+      type.getEntity(),
+      type,
+      hidingMatcher,
+      typeExtensionsLookup
+    );
   }
   getConstructorsOfAliasType(type, hidingMatcher, typeExtensionsLookup) {
     let result = this.getOwnConstructors(type.getEntity(), type, hidingMatcher);
@@ -24687,22 +24978,22 @@ var ConstructorLookup = class {
       }
       aliasedType = aliasedType.getAliasedType();
     }
-    const constructors = this.getConstructors(aliasedType, hidingMatcher, typeExtensionsLookup);
+    const constructors = this.getConstructorsOfType(aliasedType, hidingMatcher, typeExtensionsLookup);
     result = this.mergeConstructors(result, constructors);
     return result;
   }
-  getConstructorsOfTypeWithOwnMembers(typeEntity, type, hidingMatcher, typeExtensionsLookup) {
-    let result = this.getOwnConstructors(typeEntity, type, hidingMatcher);
-    if (typeExtensionsLookup !== void 0) {
-      const extensionConstructors = this.getExtensionConstructors(typeEntity, type, hidingMatcher, typeExtensionsLookup);
+  getConstructorsOfTypeWithOwnMembersOrExtension(entity, type, hidingMatcher, typeExtensionsLookup) {
+    let result = this.getOwnConstructors(entity, type, hidingMatcher);
+    if (typeExtensionsLookup !== void 0 && entity.kind === 2 /* Type */) {
+      const extensionConstructors = this.getExtensionConstructors(entity, type, hidingMatcher, typeExtensionsLookup);
       result = this.mergeConstructors(result, extensionConstructors);
     }
     return result;
   }
-  getOwnConstructors(typeEntity, type, hidingMatcher) {
-    const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
-    const originalLocale = getPackageContainingEntity(typeEntity).getLocale();
-    let result = typeEntity.getMembers().getConstructors().map((c) => {
+  getOwnConstructors(entity, type, hidingMatcher) {
+    const translatedMembers = this._localizationContext?.getTranslatedTypeOrExtensionEntityMembers(entity);
+    const originalLocale = getPackageContainingEntity(entity).getLocale();
+    let result = entity.getMembers().getConstructors().map((c) => {
       const member = new Constructor(c, type.getSubstitutions(), type);
       if (translatedMembers !== void 0) {
         const translation = new Translation(translatedMembers.translationPackage);
@@ -24719,8 +25010,8 @@ var ConstructorLookup = class {
     }
     return result;
   }
-  getExtensionConstructors(typeEntity, type, hidingMatcher, typeExtensionsLookup) {
-    let result = typeExtensionsLookup.getTypeExtensionsByType(typeEntity).flatMap((e) => {
+  getExtensionConstructors(entity, type, hidingMatcher, typeExtensionsLookup) {
+    let result = typeExtensionsLookup.getTypeExtensionsByType(entity).flatMap((e) => {
       const originalLocale = getPackageContainingEntity(e).getLocale();
       return e.getMembers().getConstructors().map(
         (c) => FoundAnonymousDeclaration.original(
@@ -24756,6 +25047,24 @@ var ConstructorLookup = class {
     return shadowingParameters.length === shadowedParameters.length && Query.from(shadowingParameters).zip(shadowedParameters, (l, r) => l.getType().equals(r.getType())).all((v) => v);
   }
 };
+var TypeOrExtension_type = class {
+  constructor(value) {
+    this.value = value;
+    this.kind = "type";
+  }
+  getEntity() {
+    return this.value.getEntity();
+  }
+};
+var TypeOrExtension_extension = class {
+  constructor(value) {
+    this.value = value;
+    this.kind = "extension";
+  }
+  getEntity() {
+    return this.value;
+  }
+};
 
 // source/ts-interop/Entities.ts
 import ts2 from "typescript";
@@ -25834,7 +26143,10 @@ var TsPropertyEntity = class {
       if (!this.isStatic() && this._containingType.typeEntityKind === 1 /* Structured */) {
         const baseType = this._containingType.getBaseObjectType().cycleFree;
         if (baseType !== void 0) {
-          result = new TypeMemberLookup(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(new SearchName(this.getName(), true)).find((m) => m.value.kind === "variable")?.value;
+          result = TypeMemberLookup.ofType(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(
+            new SearchName(this.getName(), true),
+            1 /* OnlyInstanceMembers */
+          ).find((m) => m.value.kind === "variable")?.value;
         }
       }
       return result !== void 0 ? [result] : [];
@@ -25952,7 +26264,10 @@ var TsAccessorEntity = class {
       if (!this.isStatic() && this._containingType.typeEntityKind === 1 /* Structured */) {
         const baseType = this._containingType.getBaseObjectType().cycleFree;
         if (baseType !== void 0) {
-          result = new TypeMemberLookup(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(new SearchName(this.getName(), true)).find((m) => m.value.kind === "variable")?.value;
+          result = TypeMemberLookup.ofType(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(
+            new SearchName(this.getName(), true),
+            1 /* OnlyInstanceMembers */
+          ).find((m) => m.value.kind === "variable")?.value;
         }
       }
       return result !== void 0 ? [result] : [];
@@ -26128,7 +26443,10 @@ var TsMethodEntity = class {
       if (!this.isStatic() && this._containingType.typeEntityKind === 1 /* Structured */) {
         const baseType = this._containingType.getBaseObjectType().cycleFree;
         if (baseType !== void 0) {
-          result = new TypeMemberLookup(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(new SearchName(this.getName(), true)).find((m) => m.value.kind === "method")?.value;
+          result = TypeMemberLookup.ofType(this._tsctx.analyzer, baseType, void 0).getNamedMembersByName(
+            new SearchName(this.getName(), true),
+            1 /* OnlyInstanceMembers */
+          ).find((m) => m.value.kind === "method")?.value;
         }
       }
       return result !== void 0 ? [result] : [];
@@ -26427,7 +26745,7 @@ var TsIndexSignatureEntity = class {
       if (!this.isStatic() && this._containingType.typeEntityKind === 1 /* Structured */) {
         const baseType = this._containingType.getBaseObjectType().cycleFree;
         if (baseType !== void 0) {
-          result = new TypeMemberLookup(this._tsctx.analyzer, baseType, void 0).getIndexers().at(0)?.value;
+          result = TypeMemberLookup.ofType(this._tsctx.analyzer, baseType, void 0).getIndexers(1 /* OnlyInstanceMembers */).at(0)?.value;
         }
       }
       return result !== void 0 ? [result] : [];
@@ -28736,7 +29054,7 @@ var TsInteropContext3 = class {
         this.analyzer.wellKnownDeclarations.defaultImport
       );
       Debug.assert(type.kind === "structured");
-      const constructor = new TypeMemberLookup(this.analyzer, type, void 0).getConstructors().at(0);
+      const constructor = TypeMemberLookup.ofType(this.analyzer, type, void 0).getConstructors().at(0);
       Debug.assertNotNull(constructor, `\u0422\u0438\u043F ${type.getEntity().getNaming()} \u0434\u043E\u043B\u0436\u0435\u043D \u0438\u043C\u0435\u0442\u044C \u043A\u043E\u043D\u0441\u0442\u0440\u0443\u043A\u0442\u043E\u0440.`);
       return new TagType(type, constructor.value, /* @__PURE__ */ new Map());
     });
@@ -30429,7 +30747,11 @@ var Resolver2 = class {
       ]);
     }
     const semanticContext = this._analyzer.semanticContext.containing(this._node);
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, targetType, semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(
+      this._analyzer,
+      targetType,
+      semanticContext.getLocalizationContext()
+    );
     const constructors = typeMemberLookup.getConstructors(semanticContext.getHidingMatcher(), semanticContext.getScopeLookup());
     if (constructors.length === 0) {
       return new Meaning_unresolved([this._analyzer.createNodeDiagnostic(
@@ -30505,7 +30827,7 @@ var Resolver3 = class {
     }
     const semanticContext = this._analyzer.semanticContext.containing(this._node);
     const hidingMatcher = semanticContext.getHidingMatcher();
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, baseType, semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(this._analyzer, baseType, semanticContext.getLocalizationContext());
     const constructors = typeMemberLookup.getConstructors(hidingMatcher);
     if (constructors.length === 0) {
       return new Meaning_unresolved2(
@@ -30712,7 +31034,7 @@ var Resolver4 = class {
       ]);
     }
     const semanticContext = this._analyzer.semanticContext.containing(this._node);
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext());
     const constructors = typeMemberLookup.getConstructors(semanticContext.getHidingMatcher(), semanticContext.getScopeLookup());
     if (constructors.length === 0) {
       return new Meaning_unresolved3([this._analyzer.createNodeDiagnostic(
@@ -30802,6 +31124,11 @@ var ControlFlowGraphVisualizer = class {
           nodeStack.push(node.predecessor);
           break;
         }
+        case "local-variable-declaration": {
+          addEdge(id, node.predecessor);
+          nodeStack.push(node.predecessor);
+          break;
+        }
         case "condition": {
           addEdge(id, node.predecessor);
           nodeStack.push(node.predecessor);
@@ -30862,6 +31189,11 @@ var ControlFlowGraphVisualizer = class {
         label = `{${nodeText}|\u041F\u0440\u0438\u0441\u0432\u0430\u0438\u0432\u0430\u043D\u0438\u0435}`;
         break;
       }
+      case "local-variable-declaration": {
+        const nodeText = toSourceCode(node.syntaxNode, void 0, true);
+        label = `{${nodeText}|\u041E\u0431\u044A\u044F\u0432\u043B\u0435\u043D\u0438\u0435}`;
+        break;
+      }
       case "split": {
         label = "\u0420\u0430\u0437\u0434\u0435\u043B\u0435\u043D\u0438\u0435";
         break;
@@ -31210,7 +31542,7 @@ var ControlFlowGraphBuilder = class {
   visitLocalVariableDeclaration(node) {
     this.visitChildren(node);
     if (node.initializer !== void 0) {
-      this.setAssignmentAsCurrentPredecessor(new ControlFlowNode.Assignment(this._currentPredecessor, node));
+      this._currentPredecessor = new ControlFlowNode.LocalVariableDeclaration(this._currentPredecessor, node);
     }
   }
   visitWhenTernaryExpression(node) {
@@ -31237,6 +31569,17 @@ var ControlFlowGraphBuilder = class {
       case 75 /* ParenthesizedExpression */:
         this.visitCondition(node.expression, conditionTargets);
         break;
+      case 85 /* KeywordExpression */: {
+        if (node.keyword.keywordKind === 52 /* Yes */) {
+          conditionTargets.trueTarget.addPredecessor(this._currentPredecessor);
+        } else if (node.keyword.keywordKind === 53 /* No */) {
+          conditionTargets.falseTarget.addPredecessor(this._currentPredecessor);
+        } else {
+          this.visitNode(node);
+          conditionTargets.addCommonPredecessor(this._currentPredecessor);
+        }
+        break;
+      }
       default:
         this.visitNode(node);
         conditionTargets.addCommonPredecessor(this._currentPredecessor);
@@ -31319,10 +31662,12 @@ var ConditionFlowTargets = class _ConditionFlowTargets {
     return new _ConditionFlowTargets(this.falseTarget, this.trueTarget);
   }
   createAndAddConditionPredecessor(condition, predecessor) {
-    const trueCondition = new ControlFlowNode.Condition(predecessor, condition, true);
-    this.trueTarget.addPredecessor(trueCondition);
-    const falseCondition = new ControlFlowNode.Condition(predecessor, condition, false);
-    this.falseTarget.addPredecessor(falseCondition);
+    if (predecessor.kind !== "unreachable") {
+      const trueCondition = new ControlFlowNode.Condition(predecessor, condition, true);
+      this.trueTarget.addPredecessor(trueCondition);
+      const falseCondition = new ControlFlowNode.Condition(predecessor, condition, false);
+      this.falseTarget.addPredecessor(falseCondition);
+    }
   }
   addCommonPredecessor(predecessor) {
     this.trueTarget.addPredecessor(predecessor);
@@ -31387,6 +31732,13 @@ function isNarrowableReferenceExpression(node) {
       return false;
   }
 }
+function unwrapExpressionForNarrowableReferenceCheck(node) {
+  let result = node;
+  while (result.kind === 75 /* ParenthesizedExpression */ || result.kind === 63 /* AssertionExpression */ || result.kind === 64 /* AssumptionExpression */) {
+    result = result.expression;
+  }
+  return result;
+}
 var ControlFlowNode;
 ((ControlFlowNode3) => {
   class ControlFlowNodeBase {
@@ -31441,6 +31793,21 @@ var ControlFlowNode;
     }
   }
   ControlFlowNode3.Assignment = Assignment;
+  class LocalVariableDeclaration5 extends ControlFlowNodeBase {
+    constructor(predecessor, syntaxNode) {
+      super();
+      this.predecessor = predecessor;
+      this.syntaxNode = syntaxNode;
+      this.kind = "local-variable-declaration";
+    }
+    get debuggerDisplay() {
+      return `Declaration: ${toSourceCode(this.syntaxNode, void 0, true)}`;
+    }
+    get thisAsNode() {
+      return this;
+    }
+  }
+  ControlFlowNode3.LocalVariableDeclaration = LocalVariableDeclaration5;
   class Split extends ControlFlowNodeBase {
     constructor(predecessors) {
       super();
@@ -31646,12 +32013,18 @@ var Resolver5 = class {
     if (receiverType.kind === "unresolved") {
       return new Meaning_unresolved4(void 0);
     }
-    const typeMemberLookup = new TypeMemberLookup(
+    const isStaticAccess = this._analyzer.checkExpressionDenotesType(this._node.expression) !== void 0;
+    const lookupOptions = isStaticAccess ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    const typeMemberLookup = TypeMemberLookup.ofType(
       this._analyzer,
       receiverType,
       this.semanticContext.getLocalizationContext()
     );
-    const operator = typeMemberLookup.getDereferenceOperators(this.semanticContext.getHidingMatcher(), this.semanticContext.getScopeLookup()).at(0);
+    const operator = typeMemberLookup.getDereferenceOperators(
+      lookupOptions,
+      this.semanticContext.getHidingMatcher(),
+      this.semanticContext.getScopeLookup()
+    ).at(0);
     if (operator !== void 0) {
       const accessKind = this.convertSyntacticAccessKind(
         this._analyzer.getSyntacticAccessKind(this._node),
@@ -31787,7 +32160,8 @@ var Resolver6 = class {
       }
     }
     const searchName = this._analyzer.createSearchNameFromIdentifier(this._node.identifier);
-    const namedDeclarations = this.semanticContext.getScopeLookup().getNamedDeclarationsByName(searchName);
+    const noInstanceMembers = this.semanticContext.isStatic();
+    const namedDeclarations = this.semanticContext.getScopeLookup().getNamedDeclarationsByName(searchName, noInstanceMembers);
     if (namedDeclarations.length === 1) {
       const namedDeclaration = namedDeclarations[0];
       if (namedDeclaration.value.kind === "package-alias") {
@@ -32244,12 +32618,18 @@ var Resolver7 = class {
     if (receiverType.kind === "unresolved") {
       return new ResolutionResult2(new Meaning_unresolved6());
     }
-    const typeMemberLookup = new TypeMemberLookup(
+    const isStaticAccess = this._analyzer.checkExpressionDenotesType(this._node.expression) !== void 0;
+    const lookupOptions = isStaticAccess ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    const typeMemberLookup = TypeMemberLookup.ofType(
       this._analyzer,
       receiverType,
       this.semanticContext.getLocalizationContext()
     );
-    const indexers = typeMemberLookup.getIndexers(this.semanticContext.getHidingMatcher(), this.semanticContext.getScopeLookup());
+    const indexers = typeMemberLookup.getIndexers(
+      lookupOptions,
+      this.semanticContext.getHidingMatcher(),
+      this.semanticContext.getScopeLookup()
+    );
     if (indexers.length === 1) {
       const accessKind = this.convertSyntacticAccessKind(
         this._analyzer.getSyntacticAccessKind(this._node),
@@ -32706,7 +33086,7 @@ var Resolver8 = class {
     const type = this._analyzer.instantiateTypeByIdentitySubstitution(typeEntity);
     const semanticContext = this._analyzer.semanticContext.containing(this._node);
     const hidingMatcher = semanticContext.getHidingMatcher();
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext());
     const constructors = typeMemberLookup.getConstructors(hidingMatcher);
     if (constructors.length === 0) {
       return new Meaning_unresolved7(this._analyzer.createNodeDiagnostic(
@@ -32988,8 +33368,16 @@ var Resolver10 = class {
         )
       );
     }
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, this.semanticContext.getLocalizationContext());
-    const namedMembers = typeMemberLookup.getNamedMembersByName(this.propertySearchName, this.semanticContext.getHidingMatcher());
+    const typeMemberLookup = TypeMemberLookup.ofType(
+      this._analyzer,
+      type,
+      this.semanticContext.getLocalizationContext()
+    );
+    const namedMembers = typeMemberLookup.getNamedMembersByName(
+      this.propertySearchName,
+      2 /* OnlyStaticMembers */,
+      this.semanticContext.getHidingMatcher()
+    );
     if (namedMembers.length === 0) {
       return new ResolutionResult3(
         new Meaning_unresolved8(),
@@ -33056,14 +33444,22 @@ var Resolver10 = class {
       return new ResolutionResult3(new Meaning_unresolved8());
     }
     if (this._node.propertyName.ifOperatorNameThenKind !== void 0) {
-      const resolved = this.tryResolveOperatorAccessMeaning(type, this._node.propertyName.ifOperatorNameThenKind);
+      const resolved = this.tryResolveInstanceOperatorAccessMeaning(
+        type,
+        this._node.propertyName.ifOperatorNameThenKind
+      );
       if (resolved !== void 0) {
         return resolved;
       }
     }
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, this.semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(
+      this._analyzer,
+      type,
+      this.semanticContext.getLocalizationContext()
+    );
     const namedMembers = typeMemberLookup.getNamedMembersByName(
       this.propertySearchName,
+      0 /* None */,
       this.semanticContext.getHidingMatcher(),
       this.semanticContext.getScopeLookup()
     );
@@ -33112,10 +33508,19 @@ var Resolver10 = class {
       this._analyzer.createNodeDiagnostic(66 /* AmbiguousAccess */, this._node.propertyName)
     );
   }
-  tryResolveOperatorAccessMeaning(type, syntacticOperatorKind) {
+  tryResolveInstanceOperatorAccessMeaning(type, syntacticOperatorKind) {
     const operatorKinds2 = operatorKindsBySyntacticalOperatorKind[syntacticOperatorKind];
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, this.semanticContext.getLocalizationContext());
-    const operators = operatorKinds2.flatMap((k) => typeMemberLookup.getOperatorsByKind(k, this.semanticContext.getHidingMatcher(), this.semanticContext.getScopeLookup()));
+    const typeMemberLookup = TypeMemberLookup.ofType(
+      this._analyzer,
+      type,
+      this.semanticContext.getLocalizationContext()
+    );
+    const operators = operatorKinds2.flatMap((k) => typeMemberLookup.getOperatorsByKind(
+      k,
+      0 /* None */,
+      this.semanticContext.getHidingMatcher(),
+      this.semanticContext.getScopeLookup()
+    ));
     if (operators.length === 0) {
       return void 0;
     }
@@ -33575,7 +33980,7 @@ var SourceFileScope = class {
     const result = Query.from(groups).map((g) => g.toArray()).skipWhile((d) => d.length === 0).first() ?? [];
     return result;
   }
-  getNamedDeclarations(hidingMatcher) {
+  getNamedDeclarations(_noInstanceMembers, hidingMatcher) {
     const groups = new Array();
     {
       const group = Query.from(this._sourceFileMembers.getPackageAliases()).map((d) => this.convertPackageAliasToNamedDeclaration(d)).chain(
@@ -33597,7 +34002,7 @@ var SourceFileScope = class {
       return result;
     }).flatMap((d) => d).toArray();
   }
-  getNamedDeclarationsByName(name, hidingMatcher) {
+  getNamedDeclarationsByName(name, _noInstanceMembers, hidingMatcher) {
     const groups = new Array();
     {
       const group = Query.from(this._sourceFileMembers.getPackageAliasesByName(name)).map((d) => this.convertPackageAliasToNamedDeclaration(d)).chain(Query.fromNullable(this.packageNameSegmentsByKey.get(name.value.key)).map((s) => FoundNamedDeclaration.original(
@@ -33617,10 +34022,10 @@ var SourceFileScope = class {
     const result = Query.from(groups).map((g) => g.toArray()).skipWhile((d) => d.length === 0).first() ?? [];
     return result;
   }
-  getOperators(_hidingMatcher) {
+  getOperators(_noInstanceMembers, _hidingMatcher) {
     return [];
   }
-  getOperatorsByKind(_kind, _hidingMatcher) {
+  getOperatorsByKind(_kind, _noInstanceMembers, _hidingMatcher) {
     return [];
   }
   getTypeExtensionsByType(type, hidingMatcher) {
@@ -33709,10 +34114,10 @@ var GenericScope = class {
     }).toArray();
     return result;
   }
-  getNamedDeclarations(hidingMatcher) {
+  getNamedDeclarations(_noInstanceMembers, hidingMatcher) {
     return Query.from(this._namedDeclarations).filter((d) => this.checkHiding(d.isHidden(), hidingMatcher)).map((d) => FoundNamedDeclaration.original(d, d.getName(), this._locale, false)).toArray();
   }
-  getNamedDeclarationsByName(name, hidingMatcher) {
+  getNamedDeclarationsByName(name, _noInstanceMembers, hidingMatcher) {
     const declarations = this.namedDeclarationsByName.get(name.value.key);
     if (declarations === void 0) {
       return [];
@@ -33725,10 +34130,10 @@ var GenericScope = class {
     }).toArray();
     return result;
   }
-  getOperators(_hidingMatcher) {
+  getOperators(_noInstanceMembers, _hidingMatcher) {
     return [];
   }
-  getOperatorsByKind(_kind, _hidingMatcher) {
+  getOperatorsByKind(_kind, _noInstanceMembers, _hidingMatcher) {
     return [];
   }
   getTypeExtensionsByType(typeEntity, hidingMatcher) {
@@ -33767,10 +34172,10 @@ var ParameterDeclarationsScope = class {
   getTypesOrContainersWithTypesByName(name, hidingMatcher) {
     return [];
   }
-  getNamedDeclarations(hidingMatcher) {
+  getNamedDeclarations(_noInstanceMembers, hidingMatcher) {
     return Query.from(this.namedDeclarations).filter((d) => this.checkHiding(d.isHidden(), hidingMatcher)).map((d) => FoundNamedDeclaration.original(d, d.getName(), this.locale, false)).toArray();
   }
-  getNamedDeclarationsByName(name, hidingMatcher) {
+  getNamedDeclarationsByName(name, noInstanceMembers, hidingMatcher) {
     const declarations = this.namedDeclarationsByName.get(name.value.key);
     if (declarations === void 0) {
       return [];
@@ -33783,10 +34188,10 @@ var ParameterDeclarationsScope = class {
     }).toArray();
     return result;
   }
-  getOperators(_hidingMatcher) {
+  getOperators(_noInstanceMembers, _hidingMatcher) {
     return [];
   }
-  getOperatorsByKind(_kind, _hidingMatcher) {
+  getOperatorsByKind(_kind, _noInstanceMembers, _hidingMatcher) {
     return [];
   }
   getTypeExtensionsByType(typeEntity, hidingMatcher) {
@@ -33796,7 +34201,7 @@ var ParameterDeclarationsScope = class {
     return hiding === void 0 || hidingMatcher === void 0 || hidingMatcher.matches(hiding);
   }
 };
-var TypeWithMembersBodyScope = class {
+var TypeWithMembersOrExtensionBodyScope = class {
   constructor(_memberLookup, _typeExtensionsLookup) {
     this._memberLookup = _memberLookup;
     this._typeExtensionsLookup = _typeExtensionsLookup;
@@ -33807,17 +34212,21 @@ var TypeWithMembersBodyScope = class {
   getTypesOrContainersWithTypesByName(_name, _hidingMatcher) {
     return [];
   }
-  getNamedDeclarations(hidingMatcher) {
-    return this._memberLookup.getNamedMembers(hidingMatcher, this._typeExtensionsLookup).map((m) => this.convertNamedMember(m));
+  getNamedDeclarations(noInstanceMembers = false, hidingMatcher) {
+    const options = noInstanceMembers ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    return this._memberLookup.getNamedMembers(options, hidingMatcher, this._typeExtensionsLookup).map((m) => this.convertNamedMember(m));
   }
-  getNamedDeclarationsByName(name, hidingMatcher) {
-    return this._memberLookup.getNamedMembersByName(name, hidingMatcher, this._typeExtensionsLookup).map((m) => this.convertNamedMember(m));
+  getNamedDeclarationsByName(name, noInstanceMembers = false, hidingMatcher) {
+    const options = noInstanceMembers ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    return this._memberLookup.getNamedMembersByName(name, options, hidingMatcher, this._typeExtensionsLookup).map((m) => this.convertNamedMember(m));
   }
-  getOperators(hidingMatcher) {
-    return this._memberLookup.getOperators(hidingMatcher, this._typeExtensionsLookup);
+  getOperators(noInstanceMembers = false, hidingMatcher) {
+    const options = noInstanceMembers ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    return this._memberLookup.getOperators(options, hidingMatcher, this._typeExtensionsLookup);
   }
-  getOperatorsByKind(kind, hidingMatcher) {
-    return this._memberLookup.getOperatorsByKind(kind, hidingMatcher, this._typeExtensionsLookup);
+  getOperatorsByKind(kind, noInstanceMembers = false, hidingMatcher) {
+    const options = noInstanceMembers ? 2 /* OnlyStaticMembers */ : 0 /* None */;
+    return this._memberLookup.getOperatorsByKind(kind, options, hidingMatcher, this._typeExtensionsLookup);
   }
   getTypeExtensionsByType(_typeEntity, _hidingMatcher) {
     return [];
@@ -33833,141 +34242,6 @@ var TypeWithMembersBodyScope = class {
     }
   }
 };
-var TypeExtensionBodyScope = class {
-  constructor(_analyzer, _extendedTypeMemberLookup, _extendedType, _typeExtensionEntity, _typeExtensionsLookup, _locale) {
-    this._analyzer = _analyzer;
-    this._extendedTypeMemberLookup = _extendedTypeMemberLookup;
-    this._extendedType = _extendedType;
-    this._typeExtensionEntity = _typeExtensionEntity;
-    this._typeExtensionsLookup = _typeExtensionsLookup;
-    this._locale = _locale;
-    this._substitutions = new Cached();
-  }
-  get substitutions() {
-    return this._substitutions.getOrInsertWith(() => {
-      if (this._extendedType !== void 0) {
-        return Substitutions2.identity(this._analyzer, this._extendedType.getTypeParameters());
-      }
-      return Substitutions2.empty(this._analyzer);
-    });
-  }
-  getTypesOrContainersWithTypes(_hidingMatcher) {
-    return [];
-  }
-  getTypesOrContainersWithTypesByName(_name, _hidingMatcher) {
-    return [];
-  }
-  getNamedDeclarations(hidingMatcher) {
-    const groups = new Array();
-    {
-      const group = Query.from(this._typeExtensionEntity.getMembers().getNamedMembers()).mapAndFilter((m) => this.convertNamedTypeExtensionMember(m));
-      groups.push(group);
-    }
-    if (this._extendedTypeMemberLookup !== void 0) {
-      const group = Query.from(this._extendedTypeMemberLookup.getNamedMembers(hidingMatcher, this._typeExtensionsLookup)).map((m) => this.convertExtendedTypeMember(m));
-      groups.push(group);
-    }
-    return Query.from(groups).scan(new Array(), (seen, group) => {
-      const result = group.filter((d) => seen.every((sd) => !this.checkNamedDeclarationShadowing(sd, d))).toArray();
-      seen.push(...result);
-      return result;
-    }).flatMap((d) => d).toArray();
-  }
-  getNamedDeclarationsByName(name, hidingMatcher) {
-    let result;
-    result = Query.from(this._typeExtensionEntity.getMembers().getNamedMembersByName(name.value)).mapAndFilter((m) => this.convertNamedTypeExtensionMember(m)).toArray();
-    if (result.length === 0 && this._extendedTypeMemberLookup !== void 0) {
-      result = this._extendedTypeMemberLookup.getNamedMembersByName(name, hidingMatcher, this._typeExtensionsLookup).map((m) => this.convertExtendedTypeMember(m));
-    }
-    return result;
-  }
-  getOperators(hidingMatcher) {
-    const groups = new Array();
-    {
-      const group = Query.from(this._typeExtensionEntity.getMembers().getOperators()).mapAndFilter((o) => this.convertTypeExtensionOperator(o));
-      groups.push(group);
-    }
-    if (this._extendedTypeMemberLookup !== void 0) {
-      const group = Query.from(this._extendedTypeMemberLookup.getOperators(hidingMatcher, this._typeExtensionsLookup));
-      groups.push(group);
-    }
-    return Query.from(groups).scan(new Array(), (seen, group) => {
-      const result = group.filter((d) => seen.every((sd) => !this.checkOperatorShadowing(sd, d))).toArray();
-      seen.push(...result);
-      return result;
-    }).flatMap((d) => d).toArray();
-  }
-  getOperatorsByKind(kind, hidingMatcher) {
-    let result;
-    result = this._typeExtensionEntity.getMembers().getOperatorsByKind(kind).map((o) => this.convertTypeExtensionOperator(o));
-    if (result.length === 0 && this._extendedTypeMemberLookup !== void 0) {
-      result = this._extendedTypeMemberLookup.getOperatorsByKind(kind, hidingMatcher, this._typeExtensionsLookup);
-    }
-    return result;
-  }
-  getTypeExtensionsByType(_typeEntity, _hidingMatcher) {
-    return [];
-  }
-  convertNamedTypeExtensionMember(member) {
-    switch (member.kind) {
-      case 0 /* Variable */: {
-        const variable = new Variable(member, this.substitutions);
-        return FoundNamedDeclaration.original(
-          new NamedDeclaration_variable(new NamedDeclarationVariable_typeMember(variable)),
-          variable.getName(),
-          this._locale,
-          false
-        );
-      }
-      case 1 /* Method */: {
-        const method = new Method(this._analyzer, member, this.substitutions);
-        return FoundNamedDeclaration.original(
-          new NamedDeclaration_method(new NamedDeclarationMethod_typeMember(method)),
-          method.getName(),
-          this._locale,
-          false
-        );
-      }
-      default:
-        Debug.never(member);
-    }
-  }
-  convertTypeExtensionOperator(entity) {
-    return FoundAnonymousDeclaration.original(
-      new Operator(this._analyzer, entity, this.substitutions),
-      this._locale
-    );
-  }
-  convertExtendedTypeMember(member) {
-    switch (member.value.kind) {
-      case "variable":
-        return member.withValue(new NamedDeclaration_variable(new NamedDeclarationVariable_typeMember(member.value)));
-      case "method":
-        return member.withValue(new NamedDeclaration_method(new NamedDeclarationMethod_typeMember(member.value)));
-      default:
-        Debug.never(member.value);
-    }
-  }
-  checkOperatorShadowing(source, target) {
-    if (source.value.getOperatorKind() !== target.value.getOperatorKind()) {
-      return false;
-    }
-    const sourceValueParameters = source.value.getValueParameters();
-    const targetValueParameters = target.value.getValueParameters();
-    return sourceValueParameters.length === targetValueParameters.length && Query.from(sourceValueParameters).zip(targetValueParameters, (l, r) => l.getType().equals(r.getType())).all((v) => v);
-  }
-  checkNamedDeclarationShadowing(source, target) {
-    if (source.value.kind === "method" && target.value.kind === "method") {
-      if (!source.name.value.considerEqual(target.name.value)) {
-        return false;
-      }
-      const sourceValueParameters = source.value.value.getValueParameters();
-      const targetValueParameters = target.value.value.getValueParameters();
-      return sourceValueParameters.length === targetValueParameters.length && Query.from(sourceValueParameters).zip(targetValueParameters, (l, r) => l.getType().equals(r.getType())).all((v) => v);
-    }
-    return source.name.value.considerEqual(target.name.value);
-  }
-};
 
 // source/analysis/Lookup.ts
 var Lookup = class {
@@ -33991,32 +34265,32 @@ var Lookup = class {
     }
     return [];
   }
-  getNamedDeclarations() {
-    return this._scopeChain.toQuery().map((s) => s.getNamedDeclarations(this._hidingMatcher)).scan(new Array(), (seen, declarations) => {
+  getNamedDeclarations(noInstanceMembers = false) {
+    return this._scopeChain.toQuery().map((s) => s.getNamedDeclarations(noInstanceMembers, this._hidingMatcher)).scan(new Array(), (seen, declarations) => {
       const result = Query.from(declarations).filter((d) => seen.every((sd) => !this.checkNamedDeclarationShadowing(sd, d))).toArray();
       seen.push(...result);
       return result;
     }).flatMap((d) => d).toArray();
   }
-  getNamedDeclarationsByName(name) {
+  getNamedDeclarationsByName(name, noInstanceMembers) {
     for (const scope of this._scopeChain.enumerateScopes()) {
-      const result = scope.getNamedDeclarationsByName(name, this._hidingMatcher);
+      const result = scope.getNamedDeclarationsByName(name, noInstanceMembers, this._hidingMatcher);
       if (result.length > 0) {
         return result;
       }
     }
     return [];
   }
-  getOperators() {
-    return this._scopeChain.toQuery().map((s) => s.getOperators(this._hidingMatcher)).scan(new Array(), (seen, declarations) => {
+  getOperators(noInstanceMembers) {
+    return this._scopeChain.toQuery().map((s) => s.getOperators(noInstanceMembers, this._hidingMatcher)).scan(new Array(), (seen, declarations) => {
       const result = Query.from(declarations).filter((d) => seen.every((sd) => !this.checkOperatorShadowing(sd, d))).toArray();
       seen.push(...result);
       return result;
     }).flatMap((d) => d).toArray();
   }
-  getOperatorsByKind(kind) {
+  getOperatorsByKind(kind, noInstanceMembers) {
     for (const scope of this._scopeChain.enumerateScopes()) {
-      const result = scope.getOperatorsByKind(kind, this._hidingMatcher);
+      const result = scope.getOperatorsByKind(kind, noInstanceMembers, this._hidingMatcher);
       if (result.length > 0) {
         return result;
       }
@@ -34338,6 +34612,9 @@ var SemanticContextWithParent = class {
   getHidingMatcher() {
     return new SemanticContextBasedEntityHidingMatcher(this);
   }
+  isStatic() {
+    return this._parentContext.isStatic();
+  }
 };
 var SourceFileSemanticContext = class {
   constructor(analyzer, node) {
@@ -34378,6 +34655,9 @@ var SourceFileSemanticContext = class {
   getLocalizationContext() {
     return this._analyzer.createLocalizationContext(this._sourceFile);
   }
+  isStatic() {
+    return false;
+  }
 };
 var LastSemanticContextOfType = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
@@ -34397,6 +34677,9 @@ var LastSemanticContextOfType = class extends SemanticContextWithParent {
   isInFinallyClause() {
     return false;
   }
+  isStatic() {
+    return false;
+  }
   getContainingType() {
     switch (this._node.kind) {
       case 22 /* PackageAliasTypeDeclaration */:
@@ -34515,6 +34798,18 @@ var LastSemanticContextOfMethod = class extends SemanticContextWithParent {
   isInFinallyClause() {
     return false;
   }
+  isStatic() {
+    switch (this._node.kind) {
+      case 52 /* TypeMethodDeclaration */:
+        return this._analyzer.entity.ofTypeMethodDeclaration(this._node).isStatic();
+      case 58 /* NestedMethodDeclaration */:
+        return this._parentContext.isStatic();
+      case 27 /* PackageMethodDeclaration */:
+        return false;
+      default:
+        Debug.never(this._node);
+    }
+  }
 };
 var MethodTypeParameterSemanticContext = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
@@ -34611,6 +34906,9 @@ var OperatorSemanticContext = class extends SemanticContextWithParent {
   getContainingSubprogram() {
     return this._subprogramInfo.getOrInsertWith(() => new SubprogramInfo.Operator(this._analyzer, this._node));
   }
+  isStatic() {
+    return this._analyzer.entity.ofOperatorDeclaration(this._node).isStatic();
+  }
 };
 var ConstructorSemanticContext = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
@@ -34666,7 +34964,6 @@ var IndexerSemanticContext = class extends SemanticContextWithParent {
 var GetterSemanticContext = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
     super(parentContext);
-    this._scopeChain = new Cached();
     this._subprogramInfo = new Cached();
     this._analyzer = analyzer;
     this._node = node;
@@ -34677,6 +34974,20 @@ var GetterSemanticContext = class extends SemanticContextWithParent {
   getContainingSubprogram() {
     return this._subprogramInfo.getOrInsertWith(() => new SubprogramInfo.Getter(this._analyzer, this._node));
   }
+  isStatic() {
+    switch (this._node.kind) {
+      case 55 /* TypeVariableGetterDeclaration */:
+        return this._analyzer.entity.ofComputedTypeVariableDeclaration(this._node).isStatic();
+      case 47 /* TypeIndexedGetterDeclaration */:
+        return this._analyzer.entity.ofTypeIndexerDeclaration(this._node).isStatic();
+      case 50 /* TypeDereferencedVariableGetterDeclaration */:
+        return this._analyzer.entity.ofTypeDereferenceOperatorDeclaration(this._node).isStatic();
+      case 36 /* PackageVariableGetterDeclaration */:
+        return false;
+      default:
+        Debug.never(this._node);
+    }
+  }
 };
 var SetterSemanticContext = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
@@ -34688,6 +34999,20 @@ var SetterSemanticContext = class extends SemanticContextWithParent {
   getContainingSubprogram() {
     return this._subprogramInfo.getOrInsertWith(() => new SubprogramInfo.Setter(this._analyzer, this._node));
   }
+  isStatic() {
+    switch (this._node.kind) {
+      case 56 /* TypeVariableSetterDeclaration */:
+        return this._analyzer.entity.ofComputedTypeVariableDeclaration(this._node).isStatic();
+      case 48 /* TypeIndexedSetterDeclaration */:
+        return this._analyzer.entity.ofTypeIndexerDeclaration(this._node).isStatic();
+      case 51 /* TypeDereferencedVariableSetterDeclaration */:
+        return this._analyzer.entity.ofTypeDereferenceOperatorDeclaration(this._node).isStatic();
+      case 37 /* PackageVariableSetterDeclaration */:
+        return false;
+      default:
+        Debug.never(this._node);
+    }
+  }
 };
 var StatementBlockSemanticContext = class extends SemanticContextWithParent {
   constructor(analyzer, node, parentContext) {
@@ -34789,6 +35114,16 @@ var CatchClauseSemanticContext = class extends SemanticContextWithParent {
     });
   }
 };
+var TypeVariableWithInitializerSemanticContext = class extends SemanticContextWithParent {
+  constructor(analyzer, node, parentContext) {
+    super(parentContext);
+    this._analyzer = analyzer;
+    this._node = node;
+  }
+  isStatic() {
+    return this._analyzer.entity.ofTypeVariableDeclaration(this._node).isStatic();
+  }
+};
 var SemanticContextBasedEntityHidingMatcher = class {
   constructor(semanticContext) {
     this._sourceFile = new Cached();
@@ -35134,6 +35469,15 @@ var SemanticContextBuilder = class {
     }
     return result;
   }
+  ofTypeVariableDeclarationWithInitializer(node) {
+    let result = this._semanticContexts.get(node);
+    if (result === void 0) {
+      const parent = this.containingInternal(node, void 0);
+      result = new TypeVariableWithInitializerSemanticContext(this._analyzer, node, parent);
+      this._semanticContexts.set(node, result);
+    }
+    return result;
+  }
   containingInternal(node, offset) {
     if (node.kind === 1 /* SourceFile */) {
       return this.ofSourceFile(node);
@@ -35240,6 +35584,15 @@ var SemanticContextBuilder = class {
             return this.ofPackageConstructorDeclaration(cursor);
           }
           break;
+        case 54 /* TypeVariableDeclaration */:
+          if (cursor.initializer !== void 0) {
+            if (offset === void 0) {
+              return this.ofTypeVariableDeclarationWithInitializer(cursor);
+            } else if (cursor.equalsToken !== void 0 && offset >= cursor.equalsToken.rangeWithTrivia.end) {
+              return this.ofTypeVariableDeclarationWithInitializer(cursor);
+            }
+          }
+          break;
       }
       cursor = cursor.parent;
     }
@@ -35478,7 +35831,7 @@ var StatementBlockScopeBuilder = class {
     }
   }
   static buildGenericScopeForFunctionBlock(analyzer, node) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
@@ -35488,108 +35841,117 @@ var StatementBlockScopeBuilder = class {
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForMethodBlockLiteral(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofMethodBlockLiteral(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForPackageMethodDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofPackageMethodDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeVariableGetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofTypeVariableGetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeVariableSetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const valueVariable = analyzer.valueLocalVariableEntity.ofTypeVariableSetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(valueVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForPackageVariableGetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofPackageVariableGetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForPackageVariableSetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const valueVariable = analyzer.valueLocalVariableEntity.ofPackageVariableSetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(valueVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeIndexedGetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofTypeIndexedGetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeIndexedSetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const valueVariable = analyzer.valueLocalVariableEntity.ofTypeIndexedSetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(valueVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofTypeDereferencedVariableGetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const valueVariable = analyzer.valueLocalVariableEntity.ofTypeDereferencedVariableSetterDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(valueVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForNestedMethodDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofNestedMethodDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForMethodLiteral(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofMethodLiteral(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeConstructorDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForTypeMethodDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofTypeMethodDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
   static buildScopeForOperatorDeclaration(analyzer, node, parent) {
-    const namedDeclarations = this.getLocalNamedDeclarations(analyzer, node.statementList);
+    const namedDeclarations = this.getLocalNamedDeclarationsOfFunctionBlock(analyzer, node);
     const resultVariable = analyzer.resultLocalVariableEntity.ofOperatorDeclaration(parent);
     namedDeclarations.push(new NamedDeclaration_variable(new NamedDeclarationVariable_entity(resultVariable)));
     const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
     return new GenericScope(namedDeclarations, [], locale);
   }
+  static getLocalNamedDeclarationsOfFunctionBlock(analyzer, node) {
+    let result;
+    if (node.expressionOrStatementList.kind === 92 /* StatementList */) {
+      result = this.getLocalNamedDeclarations(analyzer, node.expressionOrStatementList);
+    } else {
+      result = [];
+    }
+    return result;
+  }
   static getLocalNamedDeclarations(analyzer, statements) {
     const result = new Array();
     if (statements !== void 0) {
@@ -35793,7 +36155,7 @@ var Resolver11 = class {
     const typeArguments = Query.fromNullable(this._node.typeArgumentClause?.typeArgumentList.typeArguments).map((t) => this._analyzer.type.ofTypeSpecifier(t)).toArray();
     const type = this._analyzer.instantiateType(suitableTypes[0].value, typeArguments);
     const semanticContext = this.semanticContext;
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext());
+    const typeMemberLookup = TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext());
     const constructors = typeMemberLookup.getConstructors(semanticContext.getHidingMatcher(), semanticContext.getScopeLookup());
     if (constructors.length === 0) {
       return new ResolutionResult4(
@@ -35973,6 +36335,7 @@ var TypeNarrower = class {
   constructor(analyzer, referenceExpression, initialType, controlFlowNode) {
     // Инициализируется в методе `getType`.
     this._typeByNode = /* @__PURE__ */ new Map();
+    this._isVariableAssignedInLoopCheckResults = /* @__PURE__ */ new Map();
     this._analyzer = analyzer;
     this._referenceExpression = referenceExpression;
     this._initialType = initialType;
@@ -36000,6 +36363,9 @@ var TypeNarrower = class {
         case "assignment":
           result = this.getTypeAtAssignment(node);
           break;
+        case "local-variable-declaration":
+          result = this.getTypeAtLocalVariableDeclaration(node);
+          break;
         case "split":
           result = this.getTypeAtSplit(node);
           break;
@@ -36035,41 +36401,33 @@ var TypeNarrower = class {
     }
   }
   getTypeAtAssignment(node) {
-    let reference;
-    let right;
-    switch (node.syntaxNode.kind) {
-      case 91 /* AssignmentStatement */: {
-        if (node.syntaxNode.operator.tokenKind === 57 /* Equals */) {
-          reference = this.getReferenceAtNodeIfNarrowable(node.syntaxNode.left);
-        }
-        right = node.syntaxNode.right;
-        break;
-      }
-      case 59 /* LocalVariableDeclaration */: {
-        reference = this.getReferenceAtLocalVariableDeclaration(node.syntaxNode);
-        right = node.syntaxNode.initializer;
-        break;
-      }
-      default:
-        Debug.never(node.syntaxNode);
+    if (node.syntaxNode.operator.tokenKind !== 57 /* Equals */) {
+      return this.getTypeAtControlFlowNode(node.predecessor);
     }
-    if (reference !== void 0 && right !== void 0) {
+    const reference = this.getReferenceAtNodeIfNarrowable(node.syntaxNode.left);
+    if (reference !== void 0) {
       if (reference.equals(this._reference)) {
-        const rightType = this._analyzer.type.ofExpression(right);
-        const typeAssignabilityFlags = this._analyzer.getTypeAssignabilityFlags(rightType, this._initialType);
-        if ((typeAssignabilityFlags & (1 /* NotAssignable */ | 16 /* ImplicitConversion */)) !== 0) {
-          return this.getTypeAtControlFlowNode(node.predecessor);
-        }
-        if (NodeTypeUtils.isNoneLiteral(unwrapParenthesizedExpressions(right))) {
-          return this._analyzer.makeNoneAssignableToType(this.getTypeAtControlFlowNode(node.predecessor));
-        }
-        return rightType;
+        const rightType = this._analyzer.type.ofExpression(node.syntaxNode.right);
+        return this.getTypeAtAssignmentOrDeclaration(rightType, node.predecessor, false);
       } else if (this._reference.contains(reference)) {
         return this._initialType;
       }
     }
     return this.getTypeAtControlFlowNode(node.predecessor);
   }
+  getTypeAtLocalVariableDeclaration(node) {
+    const reference = this.getReferenceAtLocalVariableDeclaration(node.syntaxNode);
+    if (reference.equals(this._reference)) {
+      if (node.syntaxNode.initializer !== void 0) {
+        const initializerType = this._analyzer.type.ofExpression(node.syntaxNode.initializer);
+        return this.getTypeAtAssignmentOrDeclaration(initializerType, node.predecessor, true);
+      } else {
+        return this._initialType;
+      }
+    } else {
+      return this.getTypeAtControlFlowNode(node.predecessor);
+    }
+  }
   getTypeAtSplit(node) {
     const types = new Array();
     for (const predecessor of node.predecessors) {
@@ -36079,7 +36437,23 @@ var TypeNarrower = class {
     return this._analyzer.typeFactory.getUnionType(types);
   }
   getTypeAtLoop(node) {
-    return this._initialType;
+    if (this.checkIfVariableIsAssignedInLoop(node)) {
+      return this._initialType;
+    } else {
+      return this.getTypeAtControlFlowNode(node.predecessor);
+    }
+  }
+  getTypeAtAssignmentWithImplicitConversion(rightType) {
+    let result;
+    if (this._initialType.kind === "union" && rightType.kind !== "union") {
+      const constituentTypes = this._initialType.originalTypes.filter((t) => this._analyzer.isTypeAssignableTo(rightType, t));
+      result = this._analyzer.typeFactory.getUnionType(constituentTypes);
+    } else if (!this._analyzer.isNoneAssignableToType(rightType)) {
+      result = this._analyzer.excludeNoneFromType(this._initialType);
+    } else {
+      result = this._initialType;
+    }
+    return result;
   }
   getTypeAtComparisonWithNone(type, isEqual) {
     if (isEqual) {
@@ -36096,6 +36470,19 @@ var TypeNarrower = class {
       return this._analyzer.excludeTypeFromUnion(typeAtPredecessor, checkedType);
     }
   }
+  getTypeAtAssignmentOrDeclaration(rightType, predecessor, isDeclaration) {
+    const typeAssignabilityFlags = this._analyzer.getTypeAssignabilityFlags(rightType, this._initialType);
+    if (typeAssignabilityFlags === 0 /* NotAssignable */) {
+      return this._initialType;
+    }
+    if ((typeAssignabilityFlags & 8 /* ImplicitConversion */) !== 0) {
+      return this.getTypeAtAssignmentWithImplicitConversion(rightType);
+    }
+    if (rightType.equals(this._analyzer.standardTypes.none)) {
+      return isDeclaration ? this._initialType : this._analyzer.makeNoneAssignableToType(this.getTypeAtControlFlowNode(predecessor));
+    }
+    return rightType;
+  }
   addTypeIfUnique(types, type) {
     if (type.kind === "union") {
       for (const constituentType of type.originalTypes) {
@@ -36107,19 +36494,64 @@ var TypeNarrower = class {
       }
     }
   }
-  isSameReferenceAsNarrowedExpression(referenceExpression) {
-    const reference = this.getReferenceAtNodeIfNarrowable(referenceExpression);
-    return reference !== void 0 && reference.equals(this._reference);
+  checkIfVariableIsAssignedInLoop(node) {
+    let result = this._isVariableAssignedInLoopCheckResults.get(node);
+    if (result === void 0) {
+      result = node.loopingPredecessors.some((p) => this.checkIfVariableIsAssignedAtNode(p, node));
+      this._isVariableAssignedInLoopCheckResults.set(node, result);
+    }
+    return result;
   }
-  unwrapExpression(node) {
-    let result = node;
-    while (result.kind === 75 /* ParenthesizedExpression */ || result.kind === 63 /* AssertionExpression */ || result.kind === 64 /* AssumptionExpression */) {
-      result = result.expression;
+  checkIfVariableIsAssignedAtNode(node, loopNode) {
+    if (node === loopNode) {
+      return false;
+    }
+    if (node.kind === "loop") {
+      return this.checkIfVariableIsAssignedInLoop(node);
+    }
+    let result = this._isVariableAssignedInLoopCheckResults.get(node);
+    if (result === void 0) {
+      switch (node.kind) {
+        case "start":
+        case "unreachable":
+          result = false;
+          break;
+        case "condition":
+          result = this.checkIfVariableIsAssignedAtNode(node.predecessor, loopNode);
+          break;
+        case "split":
+          result = node.predecessors.some((p) => this.checkIfVariableIsAssignedAtNode(p, loopNode));
+          break;
+        case "assignment": {
+          const left = unwrapExpressionForNarrowableReferenceCheck(node.syntaxNode.left);
+          if (isNarrowableReferenceExpression(left) && (this._reference.equalsExpression(left) || this._reference.containsExpression(left))) {
+            result = true;
+          } else {
+            result = this.checkIfVariableIsAssignedAtNode(node.predecessor, loopNode);
+          }
+          break;
+        }
+        case "local-variable-declaration": {
+          if (this._reference.kind === "local-variable" && this.getReferenceAtLocalVariableDeclaration(node.syntaxNode).equals(this._reference)) {
+            result = true;
+          } else {
+            result = this.checkIfVariableIsAssignedAtNode(node.predecessor, loopNode);
+          }
+          break;
+        }
+        default:
+          Debug.never(node);
+      }
+      this._isVariableAssignedInLoopCheckResults.set(node, result);
     }
     return result;
   }
+  isSameReferenceAsNarrowedExpression(referenceExpression) {
+    const reference = this.getReferenceAtNodeIfNarrowable(referenceExpression);
+    return reference !== void 0 && reference.equals(this._reference);
+  }
   getReferenceAtNodeIfNarrowable(node) {
-    node = this.unwrapExpression(node);
+    node = unwrapExpressionForNarrowableReferenceCheck(node);
     let result;
     if (isNarrowableReferenceExpression(node)) {
       result = this.getReferenceAtNode(node);
@@ -36139,8 +36571,9 @@ var TypeNarrower = class {
             switch (entity.subkind) {
               case "local":
               case "parameter":
-                return new NarrowableReference.LocalVariable(entity);
+                return new NarrowableReference.LocalVariable(this._analyzer, entity);
               case "package":
+                return new NarrowableReference.PackageVariable(this._analyzer, entity);
               case "type":
                 return void 0;
               default:
@@ -36148,9 +36581,13 @@ var TypeNarrower = class {
             }
           } else if (variable.kind === "type-member") {
             if (variable.value.isStatic()) {
-              return new NarrowableReference.StaticTypeVariable(variable.value);
+              return new NarrowableReference.StaticTypeVariable(this._analyzer, variable.value);
             } else {
-              return new NarrowableReference.InstanceTypeVariable(variable.value, new NarrowableReference.Object());
+              return new NarrowableReference.InstanceTypeVariable(
+                this._analyzer,
+                variable.value,
+                new NarrowableReference.Object()
+              );
             }
           } else {
             Debug.never(variable);
@@ -36161,16 +36598,18 @@ var TypeNarrower = class {
       case 78 /* PropertyAccessExpression */: {
         const meaning = this._analyzer.resolvePropertyAccessExpression(node).meaning;
         if (meaning.kind === "instance-variable-access") {
-          const receiverExpression = this.unwrapExpression(node.expression);
+          const receiverExpression = unwrapExpressionForNarrowableReferenceCheck(node.expression);
           if (isNarrowableReferenceExpression(receiverExpression)) {
             const receiver = this.getReferenceAtNode(receiverExpression);
             if (receiver !== void 0) {
-              return new NarrowableReference.InstanceTypeVariable(meaning.variable.value, receiver);
+              return new NarrowableReference.InstanceTypeVariable(this._analyzer, meaning.variable.value, receiver);
             }
           }
           return void 0;
         } else if (meaning.kind === "static-variable-access") {
-          return new NarrowableReference.StaticTypeVariable(meaning.variable.value);
+          return new NarrowableReference.StaticTypeVariable(this._analyzer, meaning.variable.value);
+        } else if (meaning.kind === "package-variable-access") {
+          return new NarrowableReference.PackageVariable(this._analyzer, meaning.variable.value);
         }
         return void 0;
       }
@@ -36180,13 +36619,14 @@ var TypeNarrower = class {
   }
   getReferenceAtLocalVariableDeclaration(node) {
     const entity = this._analyzer.entity.ofLocalVariableDeclaration(node);
-    return new NarrowableReference.LocalVariable(entity);
+    return new NarrowableReference.LocalVariable(this._analyzer, entity);
   }
 };
 var NarrowableReference;
 ((NarrowableReference2) => {
   class LocalVariable {
-    constructor(entity) {
+    constructor(_analyzer, entity) {
+      this._analyzer = _analyzer;
       this.entity = entity;
       this.kind = "local-variable";
     }
@@ -36196,10 +36636,56 @@ var NarrowableReference;
     contains(_other) {
       return false;
     }
+    equalsExpression(expression) {
+      if (expression.kind !== 88 /* IdentifierExpression */) {
+        return false;
+      }
+      const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
+      return meaning.kind === "variable-access" && meaning.variable.value.getEntity() === this.entity;
+    }
+    containsExpression(_expression) {
+      return false;
+    }
   }
   NarrowableReference2.LocalVariable = LocalVariable;
+  class PackageVariable {
+    constructor(_analyzer, entity) {
+      this._analyzer = _analyzer;
+      this.entity = entity;
+      this.kind = "package-variable";
+    }
+    equals(other) {
+      return other.kind === "package-variable" && this.entity === other.entity;
+    }
+    contains(_other) {
+      return false;
+    }
+    equalsExpression(expression) {
+      if (expression.kind === 88 /* IdentifierExpression */) {
+        const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
+        return meaning.kind === "variable-access" && meaning.variable.value.getEntity() === this.entity;
+      } else if (expression.kind === 78 /* PropertyAccessExpression */) {
+        let result = NarrowableReferenceComparisonUtils.checkExpressionDenotesPackage(
+          this._analyzer,
+          expression.expression
+        );
+        if (result) {
+          const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
+          result = meaning.kind === "package-variable-access" && meaning.variable.value === this.entity;
+        }
+        return result;
+      } else {
+        return false;
+      }
+    }
+    containsExpression(_expression) {
+      return false;
+    }
+  }
+  NarrowableReference2.PackageVariable = PackageVariable;
   class InstanceTypeVariable {
-    constructor(variable, receiver) {
+    constructor(_analyzer, variable, receiver) {
+      this._analyzer = _analyzer;
       this.variable = variable;
       this.receiver = receiver;
       this.kind = "instance-type-variable";
@@ -36213,10 +36699,41 @@ var NarrowableReference;
       }
       return this.receiver.contains(other);
     }
+    equalsExpression(expression) {
+      if (expression.kind === 88 /* IdentifierExpression */) {
+        if (this.receiver.kind !== "object") {
+          return false;
+        }
+        const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
+        return meaning.kind === "variable-access" && meaning.variable.value.kind === "type-member" && meaning.variable.value.value.equals(this.variable);
+      } else if (expression.kind === 78 /* PropertyAccessExpression */) {
+        const receiverExpression = unwrapExpressionForNarrowableReferenceCheck(expression.expression);
+        if (!isNarrowableReferenceExpression(receiverExpression)) {
+          return false;
+        }
+        if (!this.receiver.equalsExpression(receiverExpression)) {
+          return false;
+        }
+        const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
+        return meaning.kind === "instance-variable-access" && meaning.variable.value.equals(this.variable);
+      } else {
+        return false;
+      }
+    }
+    containsExpression(expression) {
+      let result = false;
+      let reference = this;
+      while (!result && reference.kind === "instance-type-variable") {
+        reference = reference.receiver;
+        result = reference.equalsExpression(expression);
+      }
+      return result;
+    }
   }
   NarrowableReference2.InstanceTypeVariable = InstanceTypeVariable;
   class StaticTypeVariable {
-    constructor(variable) {
+    constructor(_analyzer, variable) {
+      this._analyzer = _analyzer;
       this.variable = variable;
       this.kind = "static-type-variable";
     }
@@ -36226,6 +36743,27 @@ var NarrowableReference;
     contains(_other) {
       return false;
     }
+    equalsExpression(expression) {
+      if (expression.kind === 88 /* IdentifierExpression */) {
+        const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
+        return meaning.kind === "variable-access" && meaning.variable.value.kind === "type-member" && meaning.variable.value.value.equals(this.variable);
+      } else if (expression.kind === 78 /* PropertyAccessExpression */) {
+        let result = NarrowableReferenceComparisonUtils.checkExpressionDenotesType(
+          this._analyzer,
+          expression.expression
+        );
+        if (result) {
+          const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
+          result = meaning.kind === "static-variable-access" && meaning.variable.value.equals(this.variable);
+        }
+        return result;
+      } else {
+        return false;
+      }
+    }
+    containsExpression(_expression) {
+      return false;
+    }
   }
   NarrowableReference2.StaticTypeVariable = StaticTypeVariable;
   class Object2 {
@@ -36238,9 +36776,49 @@ var NarrowableReference;
     contains(_other) {
       return false;
     }
+    equalsExpression(expression) {
+      return expression.kind === 86 /* ObjectExpression */;
+    }
+    containsExpression(_expression) {
+      return false;
+    }
   }
   NarrowableReference2.Object = Object2;
 })(NarrowableReference || (NarrowableReference = {}));
+var NarrowableReferenceComparisonUtils = class {
+  static checkExpressionDenotesType(analyzer, expression) {
+    expression = unwrapParenthesizedExpressions(expression);
+    if (expression.kind === 88 /* IdentifierExpression */) {
+      const meaning = analyzer.resolveIdentifierExpression(expression).meaning;
+      return meaning.kind === "type-access";
+    } else if (expression.kind === 78 /* PropertyAccessExpression */) {
+      let result = this.checkExpressionDenotesPackage(analyzer, expression.expression);
+      if (result) {
+        const meaning = analyzer.resolvePropertyAccessExpression(expression).meaning;
+        result = meaning.kind === "package-type-access";
+      }
+      return result;
+    } else {
+      return false;
+    }
+  }
+  static checkExpressionDenotesPackage(analyzer, expression) {
+    expression = unwrapParenthesizedExpressions(expression);
+    if (expression.kind === 88 /* IdentifierExpression */) {
+      const meaning = analyzer.resolveIdentifierExpression(expression).meaning;
+      return meaning.kind === "package-name-segment-access" || meaning.kind === "package-alias-access";
+    } else if (expression.kind === 78 /* PropertyAccessExpression */) {
+      let result = this.checkExpressionDenotesPackage(analyzer, expression.expression);
+      if (result) {
+        const meaning = analyzer.resolvePropertyAccessExpression(expression).meaning;
+        result = meaning.kind === "package-name-segment-access";
+      }
+      return result;
+    } else {
+      return false;
+    }
+  }
+};
 
 // source/analysis/TypeOverloadResolver.ts
 var Resolver12 = class {
@@ -36276,8 +36854,13 @@ var UserDefinableBinaryOperatorResolver = class {
     const typeExtensionLookup = semanticContext.getScopeLookup();
     const lctx = semanticContext.getLocalizationContext();
     const nonNullableLeftType = this._analyzer.excludeNoneFromType(this.leftType);
-    const leftTypeMemberLookup = new TypeMemberLookup(this._analyzer, nonNullableLeftType, lctx);
-    const operators = leftTypeMemberLookup.getOperatorsByKind(this._operatorKind, hidingMatcher, typeExtensionLookup).filter((o) => o.value.getValueParameters().length === 1);
+    const leftTypeMemberLookup = TypeMemberLookup.ofType(this._analyzer, nonNullableLeftType, lctx);
+    const operators = leftTypeMemberLookup.getOperatorsByKind(
+      this._operatorKind,
+      1 /* OnlyInstanceMembers */,
+      hidingMatcher,
+      typeExtensionLookup
+    ).filter((o) => o.value.getValueParameters().length === 1);
     if (operators.length > 0) {
       const suitableOperators = this.chooseSuitableOperators(operators);
       if (suitableOperators.length === 1) {
@@ -36394,8 +36977,13 @@ var UserDefinableUnaryOperatorResolver = class {
     const typeExtensionLookup = semanticContext.getScopeLookup();
     const nonNullableOperandType = this._analyzer.excludeNoneFromType(operandType);
     const lctx = semanticContext.getLocalizationContext();
-    const typeMemberLookup = new TypeMemberLookup(this._analyzer, nonNullableOperandType, lctx);
-    const operators = typeMemberLookup.getOperatorsByKind(this.operatorKind, hidingMatcher, typeExtensionLookup).filter((o) => o.value.getValueParameters().length === 0);
+    const typeMemberLookup = TypeMemberLookup.ofType(this._analyzer, nonNullableOperandType, lctx);
+    const operators = typeMemberLookup.getOperatorsByKind(
+      this.operatorKind,
+      1 /* OnlyInstanceMembers */,
+      hidingMatcher,
+      typeExtensionLookup
+    ).filter((o) => o.value.getValueParameters().length === 0);
     if (operators.length === 1) {
       return new WithDiagnostics_ok(operators[0]);
     }
@@ -36501,7 +37089,7 @@ var Analyzer = class _Analyzer {
       Debug.assertNotNull(parameter, "There must be type parameter.");
       result = implementedEnumerableAspect.getSubstitutions().map.get(parameter) ?? this.standardTypes.unresolved;
     } else {
-      const memberLookup = new TypeMemberLookup(this, type, void 0);
+      const memberLookup = TypeMemberLookup.ofType(this, type, void 0);
       const member = memberLookup.getNamedMembersByName(new SearchName(new Name(_Analyzer.enumeratorMethodName), true)).at(0);
       if (member?.value.kind === "method") {
         const returnType = member.value.getReturnType();
@@ -37814,9 +38402,9 @@ var Analyzer = class _Analyzer {
       return void 0;
     }
     const block = node.block;
-    let expression = block.expression;
-    if (expression === void 0) {
-      const firstStatement = block.statementList?.statements.first();
+    let expression;
+    if (block.expressionOrStatementList.kind === 92 /* StatementList */) {
+      const firstStatement = block.expressionOrStatementList?.statements.first();
       if (firstStatement?.kind !== 106 /* ExpressionStatement */) {
         diagnostics?.addDiagnostic(this.createNodeDiagnostic(
           108 /* IncorrectBodyOfRedefinableAliasTypeMethod */,
@@ -37825,6 +38413,8 @@ var Analyzer = class _Analyzer {
         return void 0;
       }
       expression = firstStatement.expression;
+    } else {
+      expression = block.expressionOrStatementList;
     }
     if (expression.kind !== 69 /* CallExpression */) {
       diagnostics?.addDiagnostic(this.createNodeDiagnostic(
@@ -39022,7 +39612,7 @@ var TargetType = class {
     return void 0;
   }
   getTargetTypeOfChildOfFunctionBlock(parent, child) {
-    Debug.assert(child === parent.expression);
+    Debug.assert(child === parent.expressionOrStatementList);
     const semanticContext = this._analyzer.semanticContext.ofFunctionBlock(parent);
     let returnType = semanticContext.getContainingSubprogram()?.getReturnType();
     if (returnType !== void 0 && returnType.equals(this._analyzer.standardTypes.none)) {
@@ -40014,8 +40604,8 @@ var Scope = class {
         Substitutions2.identity(this._analyzer, entity.getTypeParameters())
       );
       const semanticContext = this._analyzer.semanticContext.containing(node);
-      result = new TypeWithMembersBodyScope(
-        new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext()),
+      result = new TypeWithMembersOrExtensionBodyScope(
+        TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext()),
         semanticContext.getScopeLookup()
       );
       this._structuredTypeDeclarationBodyScopes.set(node, result);
@@ -40077,8 +40667,8 @@ var Scope = class {
         Substitutions2.identity(this._analyzer, entity.getTypeParameters())
       );
       const semanticContext = this._analyzer.semanticContext.containing(node);
-      result = new TypeWithMembersBodyScope(
-        new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext()),
+      result = new TypeWithMembersOrExtensionBodyScope(
+        TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext()),
         semanticContext.getScopeLookup()
       );
       this._variantTypeDeclarationBodyScopes.set(node, result);
@@ -40094,8 +40684,8 @@ var Scope = class {
         Substitutions2.identity(this._analyzer, entity.getTypeParameters())
       );
       const semanticContext = this._analyzer.semanticContext.containing(node);
-      result = new TypeWithMembersBodyScope(
-        new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext()),
+      result = new TypeWithMembersOrExtensionBodyScope(
+        TypeMemberLookup.ofType(this._analyzer, type, semanticContext.getLocalizationContext()),
         semanticContext.getScopeLookup()
       );
       this._aliasTypeDeclarationBodyScopes.set(node, result);
@@ -40150,22 +40740,13 @@ var Scope = class {
     let result = this._typeExtensionDeclarationScopes.get(node);
     if (result === void 0) {
       const entity = this._analyzer.entity.ofTypeExtensionDeclaration(node);
-      const extendedTypeEntity = entity.getExtendedTypeEntity();
-      let extendedTypeMemberLookup;
       const semanticContext = this._analyzer.semanticContext.containing(node);
-      if (extendedTypeEntity !== void 0) {
-        const type = this._analyzer.instantiateTypeByIdentitySubstitution(extendedTypeEntity);
-        extendedTypeMemberLookup = new TypeMemberLookup(this._analyzer, type, semanticContext.getLocalizationContext());
-      }
-      const locale = TreeQuery.fromNode(node).packageEntity(this._analyzer).getLocale();
-      result = new TypeExtensionBodyScope(
+      const memberLookup = TypeMemberLookup.ofTypeExtension(
         this._analyzer,
-        extendedTypeMemberLookup,
-        extendedTypeEntity,
         entity,
-        semanticContext.getScopeLookup(),
-        locale
+        semanticContext.getLocalizationContext()
       );
+      result = new TypeWithMembersOrExtensionBodyScope(memberLookup, semanticContext.getScopeLookup());
       this._typeExtensionDeclarationScopes.set(node, result);
     }
     return result;
@@ -40277,7 +40858,7 @@ var DefaultConstructors = class {
       if (baseType !== void 0) {
         const semanticContext = this._analyzer.semanticContext.containing(node);
         const hidingMatcher = semanticContext.getHidingMatcher();
-        const lookup = new TypeMemberLookup(this._analyzer, baseType, void 0);
+        const lookup = TypeMemberLookup.ofType(this._analyzer, baseType, void 0);
         result = lookup.getConstructors(hidingMatcher).map((c) => new DefaultConstructorEntity(this._analyzer, typeEntity, variablesToInitialize, c));
       } else {
         result = [new DefaultConstructorEntity(this._analyzer, typeEntity, variablesToInitialize, void 0)];
@@ -40418,7 +40999,14 @@ var OverriddenMember = class {
     const hidingMatcher = semanticContext.getHidingMatcher();
     const typeExtensionLookup = semanticContext.getScopeLookup();
     for (const type of this.enumerateTypesForOverriddenMemberLookup(container.typeEntity)) {
-      yield new BoundTypeMemberLookup(this._analyzer, type, localizationContext, hidingMatcher, typeExtensionLookup);
+      yield BoundTypeMemberLookup.ofType(
+        this._analyzer,
+        type,
+        localizationContext,
+        1 /* OnlyInstanceMembers */,
+        hidingMatcher,
+        typeExtensionLookup
+      );
     }
   }
   *enumerateTypesForOverriddenMemberLookup(entity) {
@@ -41111,22 +41699,22 @@ var TypeAssignabilityCheck = class {
   }
   isTypeAssignableTo(source, target) {
     const assignabilityFlags = this.getAssignabilityFlags(source, target);
-    return assignabilityFlags !== 1 /* NotAssignable */;
+    return assignabilityFlags !== 0 /* NotAssignable */;
   }
   getAssignabilityFlags(source, target) {
     source = unaliasType(source);
     target = unaliasType(target);
     if (source.kind === "unresolved" || target.kind === "unresolved") {
-      return 1 /* NotAssignable */;
+      return 0 /* NotAssignable */;
     }
     if (source.equals(target)) {
-      return 2 /* Identity */;
+      return 1 /* Identity */;
     }
     if (target.kind === "parameter") {
       if (source.kind === "parameter" && source.getEntity() === target.getEntity() && (this._analyzer.canTypeParameterBeNone(target) || !this._analyzer.canTypeParameterBeNone(source))) {
-        return 2 /* Identity */;
+        return 1 /* Identity */;
       } else {
-        return 1 /* NotAssignable */;
+        return 0 /* NotAssignable */;
       }
     }
     if (source.kind === "parameter" && source.constraint !== void 0) {
@@ -41135,16 +41723,16 @@ var TypeAssignabilityCheck = class {
         constraint = this._analyzer.excludeNoneFromType(constraint);
       }
       const result = this.getAssignabilityFlags(constraint, target);
-      if (result !== 1 /* NotAssignable */) {
+      if (result !== 0 /* NotAssignable */) {
         return result;
       }
     }
     if (source.kind === "union") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* NotAssignable */;
       for (const type of source.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(type, target);
-        if (constituentTypeResult === 1 /* NotAssignable */) {
-          result = 1 /* NotAssignable */;
+        if (constituentTypeResult === 0 /* NotAssignable */) {
+          result = 0 /* NotAssignable */;
           break;
         }
         result |= constituentTypeResult;
@@ -41152,7 +41740,7 @@ var TypeAssignabilityCheck = class {
       return result;
     }
     if (target.kind === "union") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* NotAssignable */;
       for (const type of target.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(source, type);
         if (this.areNewFlagsBetter(result, constituentTypeResult)) {
@@ -41162,24 +41750,24 @@ var TypeAssignabilityCheck = class {
       return result;
     }
     if (source.equals(this._analyzer.standardTypes.none) || target.equals(this._analyzer.standardTypes.none)) {
-      return source.equals(target) ? 2 /* Identity */ : 1 /* NotAssignable */;
+      return source.equals(target) ? 1 /* Identity */ : 0 /* NotAssignable */;
     }
     if (!this._analyzer.canTypeBeNone(source) && target.equals(this._analyzer.standardTypes.refObject)) {
-      return 4 /* DerivedToBase */;
+      return 2 /* DerivedToBase */;
     }
     if (source.equals(this._analyzer.standardTypes.integer) && target.equals(this._analyzer.standardTypes.number)) {
-      return 16 /* ImplicitConversion */;
+      return 8 /* ImplicitConversion */;
     }
     if (source.equals(this._analyzer.standardTypes.char) && target.equals(this._analyzer.standardTypes.text)) {
-      return 16 /* ImplicitConversion */;
+      return 8 /* ImplicitConversion */;
     }
     if (source.equals(this._analyzer.standardTypes.textTemplate) && target.equals(this._analyzer.standardTypes.text)) {
-      return 16 /* ImplicitConversion */;
+      return 8 /* ImplicitConversion */;
     }
     if (source.kind === "variant") {
       let result = this.getAssignabilityFlags(source.getUnderlyingType(), target);
-      if (result !== 1 /* NotAssignable */) {
-        result |= 16 /* ImplicitConversion */;
+      if (result !== 0 /* NotAssignable */) {
+        result |= 8 /* ImplicitConversion */;
       }
       return result;
     }
@@ -41189,7 +41777,7 @@ var TypeAssignabilityCheck = class {
     if (source.kind === "structured" && target.kind === "structured") {
       return this.getAssignabilityFlagsForStructuredTypes(source, target);
     }
-    return 1 /* NotAssignable */;
+    return 0 /* NotAssignable */;
   }
   getAssignabilityFlagsForStructuredTypes(source, target) {
     const queue = [source];
@@ -41207,7 +41795,7 @@ var TypeAssignabilityCheck = class {
         queue.unshift(...currentType.getBaseAspectTypes().map((t) => unaliasType(t)).filter((t) => t.kind === "structured"));
       }
     }
-    return isAssignable ? 4 /* DerivedToBase */ : 1 /* NotAssignable */;
+    return isAssignable ? 2 /* DerivedToBase */ : 0 /* NotAssignable */;
   }
   /**
    * @example
@@ -41221,30 +41809,30 @@ var TypeAssignabilityCheck = class {
    */
   getAssignabilityFlagsForMethodTypes(source, target) {
     if (source.isAsync() !== target.isAsync()) {
-      return 1 /* NotAssignable */;
+      return 0 /* NotAssignable */;
     }
     const sourceValueParameters = source.getValueParameters();
     const targetValueParameters = target.getValueParameters();
     if (sourceValueParameters.length !== targetValueParameters.length) {
-      return 1 /* NotAssignable */;
+      return 0 /* NotAssignable */;
     }
     for (let i = 0; i < sourceValueParameters.length; i++) {
       const sourceParameterType = sourceValueParameters[i].getType();
       const targetParameterType = targetValueParameters[i].getType();
       if (!this.isTypeAssignableTo(targetParameterType, sourceParameterType)) {
-        return 1 /* NotAssignable */;
+        return 0 /* NotAssignable */;
       }
     }
     if (!this.isTypeAssignableTo(source.getReturnType(), target.getReturnType())) {
-      return 1 /* NotAssignable */;
+      return 0 /* NotAssignable */;
     }
-    return 8 /* MethodTypes */;
+    return 4 /* MethodTypes */;
   }
   areNewFlagsBetter(currentFlags, newFlags) {
     if (newFlags === currentFlags) {
       return false;
     }
-    if (currentFlags === 1 /* NotAssignable */) {
+    if (currentFlags === 0 /* NotAssignable */) {
       return true;
     }
     const currentLowestScore = this.getLowestFlagsScore(currentFlags);
@@ -41258,9 +41846,12 @@ var TypeAssignabilityCheck = class {
     }
   }
   getLowestFlagsScore(flags) {
+    if (flags === 0 /* NotAssignable */) {
+      return -1;
+    }
     let lowestScore = Number.MAX_SAFE_INTEGER;
     let current = 1 /* First */;
-    while (current <= 16 /* Last */) {
+    while (current <= 8 /* Last */) {
       if ((flags & current) !== 0) {
         const score = this.getSingleFlagScore(current);
         if (score < lowestScore) {
@@ -41274,7 +41865,7 @@ var TypeAssignabilityCheck = class {
   getFlagCount(flags) {
     let result = 0;
     let current = 1 /* First */;
-    while (current <= 16 /* Last */) {
+    while (current <= 8 /* Last */) {
       if ((flags & current) !== 0) {
         result++;
       }
@@ -41288,15 +41879,15 @@ var TypeAssignabilityCheck = class {
    */
   getSingleFlagScore(flag) {
     switch (flag) {
-      case 1 /* NotAssignable */:
+      case 0 /* NotAssignable */:
         return 0;
-      case 2 /* Identity */:
+      case 1 /* Identity */:
         return 10;
-      case 4 /* DerivedToBase */:
+      case 2 /* DerivedToBase */:
         return 9;
-      case 8 /* MethodTypes */:
+      case 4 /* MethodTypes */:
         return 8;
-      case 16 /* ImplicitConversion */:
+      case 8 /* ImplicitConversion */:
         return 7;
       default:
         Debug.typeIsAssignableTo();
@@ -41305,13 +41896,13 @@ var TypeAssignabilityCheck = class {
   }
 };
 var TypeAssignabilityFlags = /* @__PURE__ */ ((TypeAssignabilityFlags2) => {
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["NotAssignable"] = 1] = "NotAssignable";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["Identity"] = 2] = "Identity";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["DerivedToBase"] = 4] = "DerivedToBase";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["MethodTypes"] = 8] = "MethodTypes";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["ImplicitConversion"] = 16] = "ImplicitConversion";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["First"] = 1 /* NotAssignable */] = "First";
-  TypeAssignabilityFlags2[TypeAssignabilityFlags2["Last"] = 16 /* ImplicitConversion */] = "Last";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["NotAssignable"] = 0] = "NotAssignable";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["Identity"] = 1] = "Identity";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["DerivedToBase"] = 2] = "DerivedToBase";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["MethodTypes"] = 4] = "MethodTypes";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["ImplicitConversion"] = 8] = "ImplicitConversion";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["First"] = 1 /* Identity */] = "First";
+  TypeAssignabilityFlags2[TypeAssignabilityFlags2["Last"] = 8 /* ImplicitConversion */] = "Last";
   return TypeAssignabilityFlags2;
 })(TypeAssignabilityFlags || {});
 var PackageImports = class {
@@ -46533,6 +47124,15 @@ function isTypeEntityWithMembers(entity) {
       Debug.never(entity);
   }
 }
+function isTypeWithMembersOrExtensionEntity(entity) {
+  if (entity.kind === 2 /* Type */) {
+    return isTypeEntityWithMembers(entity);
+  } else if (entity.kind === 11 /* TypeExtension */) {
+    return true;
+  } else {
+    return false;
+  }
+}
 function isTypeEntity(entity) {
   return entity.kind === 2 /* Type */;
 }
@@ -54857,22 +55457,14 @@ var IrBuilder = class {
     return new PackageMethodDeclaration3(modifiers, [], body, entity, false, this.getSourceLocation(declaration));
   }
   buildFunctionBlockOfFunction(node, resultLocalVariable) {
-    const isResultNone = this._analyzer.isFunctionResultNone(node);
     let statements = void 0;
-    if (node.expression !== void 0) {
-      const expression = this.buildExpression(node.expression);
-      if (isResultNone) {
-        statements = [new ExpressionStatement3(expression, this.getSourceLocation(node.expression))];
-      } else {
-        statements = [new ReturnStatement3(expression, void 0)];
-      }
-    } else if (node.statementList !== void 0) {
+    if (node.expressionOrStatementList.kind === 92 /* StatementList */) {
       const usageCount = this._declarationsUsageCountResult.getUsageCount(resultLocalVariable);
       if (usageCount === 0) {
-        statements = node.statementList.statements.map((s) => this.buildStatement(s)).toArray();
+        statements = node.expressionOrStatementList.statements.map((s) => this.buildStatement(s)).toArray();
       } else {
         if (usageCount === 1) {
-          const statement = node.statementList.statements.single((s) => s.kind !== 103 /* EmptyStatement */);
+          const statement = node.expressionOrStatementList.statements.single((s) => s.kind !== 103 /* EmptyStatement */);
           if (statement?.kind === 91 /* AssignmentStatement */ && statement.left.kind === 88 /* IdentifierExpression */) {
             const meaning = this._analyzer.resolveIdentifierExpression(statement.left).meaning;
             if (meaning.kind === "variable-access" && meaning.variable.value.getEntity() === resultLocalVariable) {
@@ -54894,26 +55486,30 @@ var IrBuilder = class {
           );
           statements = [
             resultVariableDeclarationStatement,
-            ...node.statementList.statements.map((s) => this.buildStatement(s)),
+            ...node.expressionOrStatementList.statements.map((s) => this.buildStatement(s)),
             returnStatement2
           ];
         }
       }
     } else {
-      statements = [];
+      const isResultNone = this._analyzer.isFunctionResultNone(node);
+      const expression = this.buildExpression(node.expressionOrStatementList);
+      if (isResultNone) {
+        statements = [new ExpressionStatement3(expression, this.getSourceLocation(node.expressionOrStatementList))];
+      } else {
+        statements = [new ReturnStatement3(expression, void 0)];
+      }
     }
     return new BlockStatement(statements, this.getSourceLocation(node));
   }
   buildFunctionBlockOfFunctionWithoutResult(node) {
     let statements;
-    if (node.expression !== void 0) {
-      const expression = this.buildExpression(node.expression);
-      const statement = new ExpressionStatement3(expression, this.getSourceLocation(node.expression));
-      statements = [statement];
-    } else if (node.statementList !== void 0) {
-      statements = node.statementList.statements.map((s) => this.buildStatement(s)).toArray();
+    if (node.expressionOrStatementList.kind === 92 /* StatementList */) {
+      statements = node.expressionOrStatementList.statements.map((s) => this.buildStatement(s)).toArray();
     } else {
-      statements = [];
+      const expression = this.buildExpression(node.expressionOrStatementList);
+      const statement = new ExpressionStatement3(expression, this.getSourceLocation(node.expressionOrStatementList));
+      statements = [statement];
     }
     return new BlockStatement(statements, this.getSourceLocation(node));
   }
@@ -59669,6 +60265,7 @@ export {
   EntityKind,
   isPackageTypeEntity,
   isTypeEntityWithMembers,
+  isTypeWithMembersOrExtensionEntity,
   isTypeEntity,
   isNamedTypeEntity,
   isPackageMemberEntity,
@@ -59686,6 +60283,7 @@ export {
   FoundAnonymousDeclaration,
   TypeMemberLookup,
   BoundTypeMemberLookup,
+  TypeMemberLookupOptions,
   TsProgramState,
   TsProgramLoader,
   createTsInteropInputsForCompilation,
@@ -59733,6 +60331,7 @@ export {
   MethodLiteralSemanticContext,
   ForStatementSemanticContext,
   CatchClauseSemanticContext,
+  TypeVariableWithInitializerSemanticContext,
   SourceFileMembers,
   TargetTypeHint,
   Analyzer,