var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// index.ts
var antlr4_c3_exports = {};
__export(antlr4_c3_exports, {
  ArrayType: () => ArrayType,
  BaseSymbol: () => BaseSymbol,
  BlockSymbol: () => BlockSymbol,
  CandidatesCollection: () => CandidatesCollection,
  ClassSymbol: () => ClassSymbol,
  CodeCompletionCore: () => CodeCompletionCore,
  DuplicateSymbolError: () => DuplicateSymbolError,
  FieldSymbol: () => FieldSymbol,
  FundamentalType: () => FundamentalType,
  InterfaceSymbol: () => InterfaceSymbol,
  LiteralSymbol: () => LiteralSymbol,
  MemberVisibility: () => MemberVisibility,
  MethodFlags: () => MethodFlags,
  MethodSymbol: () => MethodSymbol,
  Modifier: () => Modifier,
  NamespaceSymbol: () => NamespaceSymbol,
  ParameterSymbol: () => ParameterSymbol,
  ReferenceKind: () => ReferenceKind,
  RoutineSymbol: () => RoutineSymbol,
  ScopedSymbol: () => ScopedSymbol,
  SymbolTable: () => SymbolTable,
  TypeAlias: () => TypeAlias,
  TypeKind: () => TypeKind,
  TypedSymbol: () => TypedSymbol,
  VariableSymbol: () => VariableSymbol
});
module.exports = __toCommonJS(antlr4_c3_exports);

// src/types.ts
var MemberVisibility = /* @__PURE__ */ ((MemberVisibility2) => {
  MemberVisibility2[MemberVisibility2["Unknown"] = 0] = "Unknown";
  MemberVisibility2[MemberVisibility2["Open"] = 1] = "Open";
  MemberVisibility2[MemberVisibility2["Public"] = 2] = "Public";
  MemberVisibility2[MemberVisibility2["Protected"] = 3] = "Protected";
  MemberVisibility2[MemberVisibility2["Private"] = 4] = "Private";
  MemberVisibility2[MemberVisibility2["FilePrivate"] = 5] = "FilePrivate";
  MemberVisibility2[MemberVisibility2["Library"] = 6] = "Library";
  return MemberVisibility2;
})(MemberVisibility || {});
var Modifier = /* @__PURE__ */ ((Modifier3) => {
  Modifier3[Modifier3["Static"] = 0] = "Static";
  Modifier3[Modifier3["Final"] = 1] = "Final";
  Modifier3[Modifier3["Sealed"] = 2] = "Sealed";
  Modifier3[Modifier3["Abstract"] = 3] = "Abstract";
  Modifier3[Modifier3["Deprecated"] = 4] = "Deprecated";
  Modifier3[Modifier3["Virtual"] = 5] = "Virtual";
  Modifier3[Modifier3["Const"] = 6] = "Const";
  Modifier3[Modifier3["Overwritten"] = 7] = "Overwritten";
  return Modifier3;
})(Modifier || {});
var TypeKind = /* @__PURE__ */ ((TypeKind2) => {
  TypeKind2[TypeKind2["Unknown"] = 0] = "Unknown";
  TypeKind2[TypeKind2["Integer"] = 1] = "Integer";
  TypeKind2[TypeKind2["Float"] = 2] = "Float";
  TypeKind2[TypeKind2["Number"] = 3] = "Number";
  TypeKind2[TypeKind2["String"] = 4] = "String";
  TypeKind2[TypeKind2["Char"] = 5] = "Char";
  TypeKind2[TypeKind2["Boolean"] = 6] = "Boolean";
  TypeKind2[TypeKind2["Class"] = 7] = "Class";
  TypeKind2[TypeKind2["Interface"] = 8] = "Interface";
  TypeKind2[TypeKind2["Array"] = 9] = "Array";
  TypeKind2[TypeKind2["Map"] = 10] = "Map";
  TypeKind2[TypeKind2["Enum"] = 11] = "Enum";
  TypeKind2[TypeKind2["Alias"] = 12] = "Alias";
  return TypeKind2;
})(TypeKind || {});
var ReferenceKind = /* @__PURE__ */ ((ReferenceKind3) => {
  ReferenceKind3[ReferenceKind3["Irrelevant"] = 0] = "Irrelevant";
  ReferenceKind3[ReferenceKind3["Pointer"] = 1] = "Pointer";
  ReferenceKind3[ReferenceKind3["Reference"] = 2] = "Reference";
  ReferenceKind3[ReferenceKind3["Instance"] = 3] = "Instance";
  return ReferenceKind3;
})(ReferenceKind || {});

// src/BaseSymbol.ts
var BaseSymbol = class {
  static {
    __name(this, "BaseSymbol");
  }
  /** The name of the symbol or empty if anonymous. */
  name;
  /** Reference to the parse tree which contains this symbol. */
  context;
  modifiers = /* @__PURE__ */ new Set();
  visibility = 0 /* Unknown */;
  #parent;
  constructor(name = "") {
    this.name = name;
  }
  get parent() {
    return this.#parent;
  }
  get firstSibling() {
    if (!this.#parent) {
      return void 0;
    }
    return this.#parent?.firstChild;
  }
  /**
   * @returns the symbol before this symbol in its scope.
   */
  get previousSibling() {
    if (!this.#parent) {
      return void 0;
    }
    if (!this.#parent) {
      return this;
    }
    return this.#parent.previousSiblingOf(this);
  }
  /**
   * @returns the symbol following this symbol in its scope.
   */
  get nextSibling() {
    return this.#parent?.nextSiblingOf(this);
  }
  get lastSibling() {
    return this.#parent?.lastChild;
  }
  /**
   * @returns the next symbol in definition order, regardless of the scope.
   */
  get next() {
    return this.#parent?.nextOf(this);
  }
  /**
   * @returns the outermost entity (below the symbol table) that holds us.
   */
  get root() {
    let run = this.#parent;
    while (run) {
      if (!run.parent || this.isSymbolTable(run.parent)) {
        return run;
      }
      run = run.parent;
    }
    return run;
  }
  /**
   * @returns the symbol table we belong too or undefined if we are not yet assigned.
   */
  get symbolTable() {
    if (this.isSymbolTable(this)) {
      return this;
    }
    let run = this.#parent;
    while (run) {
      if (this.isSymbolTable(run)) {
        return run;
      }
      run = run.parent;
    }
    return void 0;
  }
  /**
   * @returns the list of symbols from this one up to root.
   */
  get symbolPath() {
    const result = [];
    let run = this;
    while (run) {
      result.push(run);
      if (!run.parent) {
        break;
      }
      run = run.parent;
    }
    return result;
  }
  /**
   * This is rather an internal method and should rarely be used by external code.
   *
   * @param parent The new parent to use.
   */
  setParent(parent) {
    this.#parent = parent;
  }
  /**
   * Remove this symbol from its parent scope.
   */
  removeFromParent() {
    this.#parent?.removeSymbol(this);
    this.#parent = void 0;
  }
  /**
   * Asynchronously looks up a symbol with a given name, in a bottom-up manner.
   *
   * @param name The name of the symbol to find.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns A promise resolving to the first symbol with a given name, in the order of appearance in this scope
   *          or any of the parent scopes (conditionally).
   */
  async resolve(name, localOnly = false) {
    return this.#parent?.resolve(name, localOnly);
  }
  /**
   * Synchronously looks up a symbol with a given name, in a bottom-up manner.
   *
   * @param name The name of the symbol to find.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns the first symbol with a given name, in the order of appearance in this scope
   *          or any of the parent scopes (conditionally).
   */
  resolveSync(name, localOnly = false) {
    return this.#parent?.resolveSync(name, localOnly);
  }
  /**
   * @param t The type of objects to return.
   *
   * @returns the next enclosing parent of the given type.
   */
  getParentOfType(t) {
    let run = this.#parent;
    while (run) {
      if (run instanceof t) {
        return run;
      }
      run = run.parent;
    }
    return void 0;
  }
  /**
   * Creates a qualified identifier from this symbol and its parent.
   * If `full` is true then all parents are traversed in addition to this instance.
   *
   * @param separator The string to be used between the parts.
   * @param full A flag indicating if the full path is to be returned.
   * @param includeAnonymous Use a special string for empty scope names.
   *
   * @returns the constructed qualified identifier.
   */
  qualifiedName(separator = ".", full = false, includeAnonymous = false) {
    if (!includeAnonymous && this.name.length === 0) {
      return "";
    }
    let result = this.name.length === 0 ? "<anonymous>" : this.name;
    let run = this.#parent;
    while (run) {
      if (includeAnonymous || run.name.length > 0) {
        result = (run.name.length === 0 ? "<anonymous>" : run.name) + separator + result;
      }
      if (!full || !run.parent) {
        break;
      }
      run = run.parent;
    }
    return result;
  }
  /**
   * Type guard to check for ISymbolTable.
   *
   * @param candidate The object to check.
   *
   * @returns true if the object is a symbol table.
   */
  isSymbolTable(candidate) {
    return candidate.info !== void 0;
  }
};

// src/ArrayType.ts
var ArrayType = class extends BaseSymbol {
  static {
    __name(this, "ArrayType");
  }
  elementType;
  size;
  // > 0 if fixed length.
  referenceKind;
  constructor(name, referenceKind, elemType, size = 0) {
    super(name);
    this.referenceKind = referenceKind;
    this.elementType = elemType;
    this.size = size;
  }
  get baseTypes() {
    return [];
  }
  get kind() {
    return 9 /* Array */;
  }
  get reference() {
    return this.referenceKind;
  }
};

// src/DuplicateSymbolError.ts
var DuplicateSymbolError = class extends Error {
  static {
    __name(this, "DuplicateSymbolError");
  }
};

// src/ScopedSymbol.ts
var ScopedSymbol = class _ScopedSymbol extends BaseSymbol {
  static {
    __name(this, "ScopedSymbol");
  }
  /** All child symbols in definition order. */
  #children = [];
  // All used child names. Used to detect name collisions.
  #names = /* @__PURE__ */ new Map();
  constructor(name = "") {
    super(name);
  }
  /**
   * @returns A promise resolving to all direct child symbols with a scope (e.g. classes in a module).
   */
  get directScopes() {
    return this.getSymbolsOfType(_ScopedSymbol);
  }
  get children() {
    return this.#children;
  }
  get firstChild() {
    if (this.#children.length > 0) {
      return this.#children[0];
    }
    return void 0;
  }
  get lastChild() {
    if (this.#children.length > 0) {
      return this.#children[this.#children.length - 1];
    }
    return void 0;
  }
  clear() {
    this.#children = [];
    this.#names.clear();
  }
  /**
   * Adds the given symbol to this scope. If it belongs already to a different scope
   * it is removed from that before adding it here.
   *
   * @param symbol The symbol to add as a child.
   */
  addSymbol(symbol) {
    symbol.removeFromParent();
    const symbolTable = this.symbolTable;
    const count = this.#names.get(symbol.name);
    if (!symbolTable || !symbolTable.options.allowDuplicateSymbols) {
      if (count !== void 0) {
        throw new DuplicateSymbolError("Attempt to add duplicate symbol '" + (symbol.name ?? "<anonymous>") + "'");
      } else {
        this.#names.set(symbol.name, 1);
      }
      const index = this.#children.indexOf(symbol);
      if (index > -1) {
        throw new DuplicateSymbolError("Attempt to add duplicate symbol '" + (symbol.name ?? "<anonymous>") + "'");
      }
    } else {
      this.#names.set(symbol.name, count === void 0 ? 1 : count + 1);
    }
    this.#children.push(symbol);
    symbol.setParent(this);
  }
  removeSymbol(symbol) {
    const index = this.#children.indexOf(symbol);
    if (index > -1) {
      this.#children.splice(index, 1);
      symbol.setParent(void 0);
      const count = this.#names.get(symbol.name);
      if (count !== void 0) {
        if (count === 1) {
          this.#names.delete(symbol.name);
        } else {
          this.#names.set(symbol.name, count - 1);
        }
      }
    }
  }
  /**
   * Asynchronously retrieves child symbols of a given type from this symbol.
   *
   * @param t The type of of the objects to return.
   *
   * @returns A promise resolving to all (nested) children of the given type.
   */
  async getNestedSymbolsOfType(t) {
    const result = [];
    const childPromises = [];
    this.#children.forEach((child) => {
      if (child instanceof t) {
        result.push(child);
      }
      if (child instanceof _ScopedSymbol) {
        childPromises.push(child.getNestedSymbolsOfType(t));
      }
    });
    const childSymbols = await Promise.all(childPromises);
    childSymbols.forEach((entry) => {
      result.push(...entry);
    });
    return result;
  }
  /**
   * Synchronously retrieves child symbols of a given type from this symbol.
   *
   * @param t The type of of the objects to return.
   *
   * @returns A list of all (nested) children of the given type.
   */
  getNestedSymbolsOfTypeSync(t) {
    const result = [];
    this.#children.forEach((child) => {
      if (child instanceof t) {
        result.push(child);
      }
      if (child instanceof _ScopedSymbol) {
        result.push(...child.getNestedSymbolsOfTypeSync(t));
      }
    });
    return result;
  }
  /**
   * @param name If given only returns symbols with that name.
   *
   * @returns A promise resolving to symbols from this and all nested scopes in the order they were defined.
   */
  async getAllNestedSymbols(name) {
    const result = [];
    const childPromises = [];
    this.#children.forEach((child) => {
      if (!name || child.name === name) {
        result.push(child);
      }
      if (child instanceof _ScopedSymbol) {
        childPromises.push(child.getAllNestedSymbols(name));
      }
    });
    const childSymbols = await Promise.all(childPromises);
    childSymbols.forEach((entry) => {
      result.push(...entry);
    });
    return result;
  }
  /**
   * @param name If given only returns symbols with that name.
   *
   * @returns A list of all symbols from this and all nested scopes in the order they were defined.
   */
  getAllNestedSymbolsSync(name) {
    const result = [];
    this.#children.forEach((child) => {
      if (!name || child.name === name) {
        result.push(child);
      }
      if (child instanceof _ScopedSymbol) {
        result.push(...child.getAllNestedSymbolsSync(name));
      }
    });
    return result;
  }
  /**
   * @param t The type of of the objects to return.
   *
   * @returns A promise resolving to direct children of a given type.
   */
  getSymbolsOfType(t) {
    return new Promise((resolve) => {
      const result = [];
      this.#children.forEach((child) => {
        if (child instanceof t) {
          result.push(child);
        }
      });
      resolve(result);
    });
  }
  /**
   * TODO: add optional position dependency (only symbols defined before a given caret pos are viable).
   *
   * @param t The type of the objects to return.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns A promise resolving to all symbols of the the given type, accessible from this scope (if localOnly is
   *          false), within the owning symbol table.
   */
  async getAllSymbols(t, localOnly = false) {
    const result = [];
    for (const child of this.#children) {
      if (child instanceof t) {
        result.push(child);
      }
      if (this.isNamespace(child)) {
        const childSymbols = await child.getAllSymbols(t, true);
        result.push(...childSymbols);
      }
    }
    if (!localOnly) {
      if (this.parent) {
        const childSymbols = await this.getAllSymbols(t, true);
        result.push(...childSymbols);
      }
    }
    return result;
  }
  /**
   * TODO: add optional position dependency (only symbols defined before a given caret pos are viable).
   *
   * @param t The type of the objects to return.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns A list with all symbols of the the given type, accessible from this scope (if localOnly is
   *          false), within the owning symbol table.
   */
  getAllSymbolsSync(t, localOnly = false) {
    const result = [];
    for (const child of this.#children) {
      if (child instanceof t) {
        result.push(child);
      }
      if (this.isNamespace(child)) {
        const childSymbols = child.getAllSymbolsSync(t, true);
        result.push(...childSymbols);
      }
    }
    if (!localOnly) {
      if (this.parent) {
        const childSymbols = this.getAllSymbolsSync(t, true);
        result.push(...childSymbols);
      }
    }
    return result;
  }
  /**
   * @param name The name of the symbol to resolve.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns A promise resolving to the first symbol with a given name, in the order of appearance in this scope
   *          or any of the parent scopes (conditionally).
   */
  async resolve(name, localOnly = false) {
    return new Promise((resolve) => {
      for (const child of this.#children) {
        if (child.name === name) {
          resolve(child);
          return;
        }
      }
      if (!localOnly) {
        if (this.parent) {
          resolve(this.parent.resolve(name, false));
          return;
        }
      }
      resolve(void 0);
    });
  }
  /**
   * @param name The name of the symbol to resolve.
   * @param localOnly If true only child symbols are returned, otherwise also symbols from the parent of this symbol
   *                  (recursively).
   *
   * @returns the first symbol with a given name, in the order of appearance in this scope
   *          or any of the parent scopes (conditionally).
   */
  resolveSync(name, localOnly = false) {
    for (const child of this.#children) {
      if (child.name === name) {
        return child;
      }
    }
    if (!localOnly) {
      if (this.parent) {
        return this.parent.resolveSync(name, false);
      }
    }
    return void 0;
  }
  /**
   * @param path The path consisting of symbol names separator by `separator`.
   * @param separator The character to separate path segments.
   *
   * @returns the symbol located at the given path through the symbol hierarchy.
   */
  symbolFromPath(path, separator = ".") {
    const elements = path.split(separator);
    let index = 0;
    if (elements[0] === this.name || elements[0].length === 0) {
      ++index;
    }
    let result = this;
    while (index < elements.length) {
      if (!(result instanceof _ScopedSymbol)) {
        return void 0;
      }
      const child = result.children.find((candidate) => {
        return candidate.name === elements[index];
      });
      if (!child) {
        return void 0;
      }
      result = child;
      ++index;
    }
    return result;
  }
  /**
   * @param child The child to search for.
   *
   * @returns the index of the given child symbol in the child list or -1 if it couldn't be found.
   */
  indexOfChild(child) {
    return this.#children.findIndex((value) => {
      return value === child;
    });
  }
  /**
   * @param child The reference node.
   *
   * @returns the sibling symbol after the given child symbol, if one exists.
   */
  nextSiblingOf(child) {
    const index = this.indexOfChild(child);
    if (index === -1 || index >= this.#children.length - 1) {
      return void 0;
    }
    return this.#children[index + 1];
  }
  /**
   * @param child The reference node.
   *
   * @returns the sibling symbol before the given child symbol, if one exists.
   */
  previousSiblingOf(child) {
    const index = this.indexOfChild(child);
    if (index < 1) {
      return void 0;
    }
    return this.#children[index - 1];
  }
  /**
   * @param child The reference node.
   *
   * @returns the next symbol in definition order, regardless of the scope.
   */
  nextOf(child) {
    if (!child.parent) {
      return void 0;
    }
    if (child.parent !== this) {
      return child.parent.nextOf(child);
    }
    if (child instanceof _ScopedSymbol && child.children.length > 0) {
      return child.children[0];
    }
    const sibling = this.nextSiblingOf(child);
    if (sibling) {
      return sibling;
    }
    return this.parent.nextOf(this);
  }
  isNamespace(candidate) {
    return candidate.inline !== void 0 && candidate.attributes !== void 0;
  }
};

// src/BlockSymbol.ts
var BlockSymbol = class extends ScopedSymbol {
  static {
    __name(this, "BlockSymbol");
  }
};

// src/TypedSymbol.ts
var TypedSymbol = class extends BaseSymbol {
  static {
    __name(this, "TypedSymbol");
  }
  type;
  constructor(name, type) {
    super(name);
    this.type = type;
  }
};

// src/VariableSymbol.ts
var VariableSymbol = class extends TypedSymbol {
  static {
    __name(this, "VariableSymbol");
  }
  value;
  constructor(name, value, type) {
    super(name, type);
    this.value = value;
  }
};

// src/FieldSymbol.ts
var FieldSymbol = class extends VariableSymbol {
  static {
    __name(this, "FieldSymbol");
  }
  setter;
  getter;
};

// src/ParameterSymbol.ts
var ParameterSymbol = class extends VariableSymbol {
  static {
    __name(this, "ParameterSymbol");
  }
};

// src/RoutineSymbol.ts
var RoutineSymbol = class extends ScopedSymbol {
  static {
    __name(this, "RoutineSymbol");
  }
  returnType;
  // Can be null if result is void.
  constructor(name, returnType) {
    super(name);
    this.returnType = returnType;
  }
  getVariables(_localOnly = true) {
    return this.getSymbolsOfType(VariableSymbol);
  }
  getParameters(_localOnly = true) {
    return this.getSymbolsOfType(ParameterSymbol);
  }
};

// src/MethodSymbol.ts
var MethodFlags = /* @__PURE__ */ ((MethodFlags2) => {
  MethodFlags2[MethodFlags2["None"] = 0] = "None";
  MethodFlags2[MethodFlags2["Virtual"] = 1] = "Virtual";
  MethodFlags2[MethodFlags2["Const"] = 2] = "Const";
  MethodFlags2[MethodFlags2["Overwritten"] = 4] = "Overwritten";
  MethodFlags2[MethodFlags2["SetterOrGetter"] = 8] = "SetterOrGetter";
  MethodFlags2[MethodFlags2["Explicit"] = 16] = "Explicit";
  return MethodFlags2;
})(MethodFlags || {});
var MethodSymbol = class extends RoutineSymbol {
  static {
    __name(this, "MethodSymbol");
  }
  methodFlags = 0 /* None */;
};

// src/ClassSymbol.ts
var ClassSymbol = class extends ScopedSymbol {
  static {
    __name(this, "ClassSymbol");
  }
  isStruct = false;
  reference = 0 /* Irrelevant */;
  /** Usually only one member, unless the language supports multiple inheritance (like C++). */
  // eslint-disable-next-line no-use-before-define
  extends;
  /** Typescript allows a class to implement a class, not only interfaces. */
  // eslint-disable-next-line no-use-before-define
  implements;
  constructor(name, ext, impl) {
    super(name);
    this.extends = ext;
    this.implements = impl;
  }
  get baseTypes() {
    return this.extends;
  }
  get kind() {
    return 7 /* Class */;
  }
  /**
   * @param _includeInherited Not used.
   *
   * @returns a list of all methods.
   */
  getMethods(_includeInherited = false) {
    return this.getSymbolsOfType(MethodSymbol);
  }
  /**
   * @param _includeInherited Not used.
   *
   * @returns all fields.
   */
  getFields(_includeInherited = false) {
    return this.getSymbolsOfType(FieldSymbol);
  }
};

// src/FundamentalType.ts
var FundamentalType = class _FundamentalType {
  static {
    __name(this, "FundamentalType");
  }
  static integerType = new _FundamentalType("int", 1 /* Integer */, 3 /* Instance */);
  static floatType = new _FundamentalType("float", 2 /* Float */, 3 /* Instance */);
  static stringType = new _FundamentalType("string", 4 /* String */, 3 /* Instance */);
  static boolType = new _FundamentalType("bool", 6 /* Boolean */, 3 /* Instance */);
  name;
  typeKind;
  referenceKind;
  constructor(name, typeKind = 0 /* Unknown */, referenceKind = 0 /* Irrelevant */) {
    this.name = name;
    this.typeKind = typeKind;
    this.referenceKind = referenceKind;
  }
  get baseTypes() {
    return [];
  }
  get kind() {
    return this.typeKind;
  }
  get reference() {
    return this.referenceKind;
  }
};

// src/InterfaceSymbol.ts
var InterfaceSymbol = class extends ScopedSymbol {
  static {
    __name(this, "InterfaceSymbol");
  }
  reference = 0 /* Irrelevant */;
  /** Typescript allows an interface to extend a class, not only interfaces. */
  // eslint-disable-next-line no-use-before-define
  extends;
  constructor(name, ext) {
    super(name);
    this.extends = ext;
  }
  get baseTypes() {
    return this.extends;
  }
  get kind() {
    return 8 /* Interface */;
  }
  /**
   * @param _includeInherited not used
   *
   * @returns a list of all methods.
   */
  getMethods(_includeInherited = false) {
    return this.getSymbolsOfType(MethodSymbol);
  }
  /**
   * @param _includeInherited Not used.
   *
   * @returns all fields.
   */
  getFields(_includeInherited = false) {
    return this.getSymbolsOfType(FieldSymbol);
  }
};

// src/LiteralSymbol.ts
var LiteralSymbol = class extends TypedSymbol {
  static {
    __name(this, "LiteralSymbol");
  }
  value;
  constructor(name, value, type) {
    super(name, type);
    this.value = value;
  }
};

// src/NamespaceSymbol.ts
var NamespaceSymbol = class extends ScopedSymbol {
  static {
    __name(this, "NamespaceSymbol");
  }
  inline;
  attributes;
  constructor(name, inline = false, attributes = []) {
    super(name);
    this.inline = inline;
    this.attributes = attributes;
  }
};

// src/TypeAlias.ts
var TypeAlias = class extends BaseSymbol {
  static {
    __name(this, "TypeAlias");
  }
  targetType;
  constructor(name, target) {
    super(name);
    this.targetType = target;
  }
  get baseTypes() {
    return [this.targetType];
  }
  get kind() {
    return 12 /* Alias */;
  }
  get reference() {
    return 0 /* Irrelevant */;
  }
};

// src/CodeCompletionCore.ts
var import_antlr4ng = require("antlr4ng");

// src/utils.ts
var longestCommonPrefix = /* @__PURE__ */ __name((arr1, arr2) => {
  if (!arr1 || !arr2) {
    return [];
  }
  let i;
  for (i = 0; i < Math.min(arr1.length, arr2.length); i++) {
    if (arr1[i] !== arr2[i]) {
      break;
    }
  }
  return arr1.slice(0, i);
}, "longestCommonPrefix");

// src/CodeCompletionCore.ts
var CandidatesCollection = class {
  static {
    __name(this, "CandidatesCollection");
  }
  tokens = /* @__PURE__ */ new Map();
  rules = /* @__PURE__ */ new Map();
};
var FollowSetWithPath = class {
  static {
    __name(this, "FollowSetWithPath");
  }
  intervals;
  path = [];
  following = [];
};
var CodeCompletionCore = class _CodeCompletionCore {
  static {
    __name(this, "CodeCompletionCore");
  }
  static followSetsByATN = /* @__PURE__ */ new Map();
  static atnStateTypeMap = [
    "invalid",
    "basic",
    "rule start",
    "block start",
    "plus block start",
    "star block start",
    "token start",
    "rule stop",
    "block end",
    "star loop back",
    "star loop entry",
    "plus loop back",
    "loop end"
  ];
  // Debugging options. Print human readable ATN state and other info.
  /** Not dependent on showDebugOutput. Prints the collected rules + tokens to terminal. */
  showResult = false;
  /** Enables printing ATN state info to terminal. */
  showDebugOutput = false;
  /** Only relevant when showDebugOutput is true. Enables transition printing for a state. */
  debugOutputWithTransitions = false;
  /** Also depends on showDebugOutput. Enables call stack printing for each rule recursion. */
  showRuleStack = false;
  /**
   * Tailoring of the result:
   * Tokens which should not appear in the candidates set.
   */
  ignoredTokens;
  /**
   * Rules which replace any candidate token they contain.
   * This allows to return descriptive rules (e.g. className, instead of ID/identifier).
   */
  preferredRules;
  /**
   * Specify if preferred rules should translated top-down (higher index rule returns first) or
   * bottom-up (lower index rule returns first).
   */
  translateRulesTopDown = false;
  parser;
  atn;
  vocabulary;
  ruleNames;
  tokens;
  precedenceStack;
  tokenStartIndex = 0;
  statesProcessed = 0;
  /**
   * A mapping of rule index + token stream position to end token positions.
   * A rule which has been visited before with the same input position will always produce the same output positions.
   */
  shortcutMap = /* @__PURE__ */ new Map();
  /** The collected candidates (rules and tokens). */
  candidates = new CandidatesCollection();
  constructor(parser) {
    this.parser = parser;
    this.atn = parser.atn;
    this.vocabulary = parser.vocabulary;
    this.ruleNames = parser.ruleNames;
    this.ignoredTokens = /* @__PURE__ */ new Set();
    this.preferredRules = /* @__PURE__ */ new Set();
  }
  /**
   * This is the main entry point. The caret token index specifies the token stream index for the token which
   * currently covers the caret (or any other position you want to get code completion candidates for).
   * Optionally you can pass in a parser rule context which limits the ATN walk to only that or called rules.
   * This can significantly speed up the retrieval process but might miss some candidates (if they are outside of
   * the given context).
   *
   * @param caretTokenIndex The index of the token at the caret position.
   * @param context An option parser rule context to limit the search space.
   * @returns The collection of completion candidates.
   */
  collectCandidates(caretTokenIndex, context) {
    this.shortcutMap.clear();
    this.candidates.rules.clear();
    this.candidates.tokens.clear();
    this.statesProcessed = 0;
    this.precedenceStack = [];
    this.tokenStartIndex = context?.start ? context.start.tokenIndex : 0;
    const tokenStream = this.parser.tokenStream;
    this.tokens = [];
    let offset = this.tokenStartIndex;
    while (true) {
      const token = tokenStream.get(offset++);
      if (!token) {
        break;
      }
      if (token.channel === import_antlr4ng.Token.DEFAULT_CHANNEL) {
        this.tokens.push(token);
        if (token.tokenIndex >= caretTokenIndex || token.type === import_antlr4ng.Token.EOF) {
          break;
        }
      }
      if (token.type === import_antlr4ng.Token.EOF) {
        break;
      }
    }
    const callStack = [];
    const startRule = context ? context.ruleIndex : 0;
    this.processRule(this.atn.ruleToStartState[startRule], 0, callStack, 0, 0);
    if (this.showResult) {
      console.log(`States processed: ${this.statesProcessed}`);
      console.log("\n\nCollected rules:\n");
      for (const rule of this.candidates.rules) {
        let path = "";
        for (const token of rule[1].ruleList) {
          path += this.ruleNames[token] + " ";
        }
        console.log(this.ruleNames[rule[0]] + ", path: ", path);
      }
      const sortedTokens = /* @__PURE__ */ new Set();
      for (const token of this.candidates.tokens) {
        let value = this.vocabulary.getDisplayName(token[0]) ?? "";
        for (const following of token[1]) {
          value += " " + this.vocabulary.getDisplayName(following);
        }
        sortedTokens.add(value);
      }
      console.log("\n\nCollected tokens:\n");
      for (const symbol of sortedTokens) {
        console.log(symbol);
      }
      console.log("\n\n");
    }
    return this.candidates;
  }
  /**
   * Checks if the predicate associated with the given transition evaluates to true.
   *
   * @param transition The transition to check.
   * @returns the evaluation result of the predicate.
   */
  checkPredicate(transition) {
    return transition.getPredicate().evaluate(this.parser, import_antlr4ng.ParserRuleContext.empty);
  }
  /**
   * Walks the rule chain upwards or downwards (depending on translateRulesTopDown) to see if that matches any of the
   * preferred rules. If found, that rule is added to the collection candidates and true is returned.
   *
   * @param ruleWithStartTokenList The list to convert.
   * @returns true if any of the stack entries was converted.
   */
  translateStackToRuleIndex(ruleWithStartTokenList) {
    if (this.preferredRules.size === 0) {
      return false;
    }
    if (this.translateRulesTopDown) {
      for (let i = ruleWithStartTokenList.length - 1; i >= 0; i--) {
        if (this.translateToRuleIndex(i, ruleWithStartTokenList)) {
          return true;
        }
      }
    } else {
      for (let i = 0; i < ruleWithStartTokenList.length; i++) {
        if (this.translateToRuleIndex(i, ruleWithStartTokenList)) {
          return true;
        }
      }
    }
    return false;
  }
  /**
   * Given the index of a rule from a rule chain, check if that matches any of the preferred rules. If it matches,
   * that rule is added to the collection candidates and true is returned.
   *
   * @param i The rule index.
   * @param ruleWithStartTokenList The list to check.
   * @returns true if the specified rule is in the list of preferred rules.
   */
  translateToRuleIndex(i, ruleWithStartTokenList) {
    const { ruleIndex, startTokenIndex } = ruleWithStartTokenList[i];
    if (this.preferredRules.has(ruleIndex)) {
      const path = ruleWithStartTokenList.slice(0, i).map(({ ruleIndex: candidate }) => {
        return candidate;
      });
      let addNew = true;
      for (const rule of this.candidates.rules) {
        if (rule[0] !== ruleIndex || rule[1].ruleList.length !== path.length) {
          continue;
        }
        if (path.every((v, j) => {
          return v === rule[1].ruleList[j];
        })) {
          addNew = false;
          break;
        }
      }
      if (addNew) {
        this.candidates.rules.set(ruleIndex, {
          startTokenIndex,
          ruleList: path
        });
        if (this.showDebugOutput) {
          console.log("=====> collected: ", this.ruleNames[ruleIndex]);
        }
      }
      return true;
    }
    return false;
  }
  /**
   * This method follows the given transition and collects all symbols within the same rule that directly follow it
   * without intermediate transitions to other rules and only if there is a single symbol for a transition.
   *
   * @param transition The transition from which to start.
   * @returns A list of toke types.
   */
  getFollowingTokens(transition) {
    const result = [];
    const pipeline = [transition.target];
    while (pipeline.length > 0) {
      const state = pipeline.pop();
      if (state) {
        state.transitions.forEach((outgoing) => {
          if (outgoing.transitionType === import_antlr4ng.Transition.ATOM) {
            if (!outgoing.isEpsilon) {
              const list = outgoing.label.toArray();
              if (list.length === 1 && !this.ignoredTokens.has(list[0])) {
                result.push(list[0]);
                pipeline.push(outgoing.target);
              }
            } else {
              pipeline.push(outgoing.target);
            }
          }
        });
      }
    }
    return result;
  }
  /**
   * Entry point for the recursive follow set collection function.
   *
   * @param start Start state.
   * @param stop Stop state.
   * @returns Follow sets.
   */
  determineFollowSets(start, stop) {
    const sets = [];
    const stateStack = [];
    const ruleStack = [];
    const isExhaustive = this.collectFollowSets(start, stop, sets, stateStack, ruleStack);
    const combined = new import_antlr4ng.IntervalSet();
    for (const set of sets) {
      combined.addSet(set.intervals);
    }
    return { sets, isExhaustive, combined };
  }
  /**
   * Collects possible tokens which could be matched following the given ATN state. This is essentially the same
   * algorithm as used in the LL1Analyzer class, but here we consider predicates also and use no parser rule context.
   *
   * @param s The state to continue from.
   * @param stopState The state which ends the collection routine.
   * @param followSets A pass through parameter to add found sets to.
   * @param stateStack A stack to avoid endless recursions.
   * @param ruleStack The current rule stack.
   * @returns true if the follow sets is exhaustive, i.e. we terminated before the rule end was reached, so no
   * subsequent rules could add tokens
   */
  collectFollowSets(s, stopState, followSets, stateStack, ruleStack) {
    if (stateStack.find((x) => {
      return x === s;
    })) {
      return true;
    }
    stateStack.push(s);
    if (s === stopState || s.constructor.stateType === import_antlr4ng.ATNState.RULE_STOP) {
      stateStack.pop();
      return false;
    }
    let isExhaustive = true;
    for (const transition of s.transitions) {
      if (transition.transitionType === import_antlr4ng.Transition.RULE) {
        const ruleTransition = transition;
        if (ruleStack.indexOf(ruleTransition.target.ruleIndex) !== -1) {
          continue;
        }
        ruleStack.push(ruleTransition.target.ruleIndex);
        const ruleFollowSetsIsExhaustive = this.collectFollowSets(
          transition.target,
          stopState,
          followSets,
          stateStack,
          ruleStack
        );
        ruleStack.pop();
        if (!ruleFollowSetsIsExhaustive) {
          const nextStateFollowSetsIsExhaustive = this.collectFollowSets(
            ruleTransition.followState,
            stopState,
            followSets,
            stateStack,
            ruleStack
          );
          isExhaustive &&= nextStateFollowSetsIsExhaustive;
        }
      } else if (transition.transitionType === import_antlr4ng.Transition.PREDICATE) {
        if (this.checkPredicate(transition)) {
          const nextStateFollowSetsIsExhaustive = this.collectFollowSets(
            transition.target,
            stopState,
            followSets,
            stateStack,
            ruleStack
          );
          isExhaustive &&= nextStateFollowSetsIsExhaustive;
        }
      } else if (transition.isEpsilon) {
        const nextStateFollowSetsIsExhaustive = this.collectFollowSets(
          transition.target,
          stopState,
          followSets,
          stateStack,
          ruleStack
        );
        isExhaustive &&= nextStateFollowSetsIsExhaustive;
      } else if (transition.transitionType === import_antlr4ng.Transition.WILDCARD) {
        const set = new FollowSetWithPath();
        set.intervals = import_antlr4ng.IntervalSet.of(import_antlr4ng.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
        set.path = ruleStack.slice();
        followSets.push(set);
      } else {
        let label = transition.label;
        if (label && label.length > 0) {
          if (transition.transitionType === import_antlr4ng.Transition.NOT_SET) {
            label = label.complement(import_antlr4ng.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
          }
          const set = new FollowSetWithPath();
          set.intervals = label ?? new import_antlr4ng.IntervalSet();
          set.path = ruleStack.slice();
          set.following = this.getFollowingTokens(transition);
          followSets.push(set);
        }
      }
    }
    stateStack.pop();
    return isExhaustive;
  }
  /**
   * Walks the ATN for a single rule only. It returns the token stream position for each path that could be matched
   * in this rule.
   * The result can be empty in case we hit only non-epsilon transitions that didn't match the current input or if we
   * hit the caret position.
   *
   * @param startState The start state.
   * @param tokenListIndex The token index we are currently at.
   * @param callStack The stack that indicates where in the ATN we are currently.
   * @param precedence The current precedence level.
   * @param indentation A value to determine the current indentation when doing debug prints.
   * @returns the set of token stream indexes (which depend on the ways that had to be taken).
   */
  processRule(startState, tokenListIndex, callStack, precedence, indentation) {
    let positionMap = this.shortcutMap.get(startState.ruleIndex);
    if (!positionMap) {
      positionMap = /* @__PURE__ */ new Map();
      this.shortcutMap.set(startState.ruleIndex, positionMap);
    } else {
      if (positionMap.has(tokenListIndex)) {
        if (this.showDebugOutput) {
          console.log("=====> shortcut");
        }
        return positionMap.get(tokenListIndex);
      }
    }
    const result = /* @__PURE__ */ new Set();
    let setsPerState = _CodeCompletionCore.followSetsByATN.get(this.parser.constructor.name);
    if (!setsPerState) {
      setsPerState = /* @__PURE__ */ new Map();
      _CodeCompletionCore.followSetsByATN.set(this.parser.constructor.name, setsPerState);
    }
    let followSets = setsPerState.get(startState.stateNumber);
    if (!followSets) {
      const stop = this.atn.ruleToStopState[startState.ruleIndex];
      followSets = this.determineFollowSets(startState, stop);
      setsPerState.set(startState.stateNumber, followSets);
    }
    const startTokenIndex = this.tokens[tokenListIndex].tokenIndex;
    callStack.push({
      startTokenIndex,
      ruleIndex: startState.ruleIndex
    });
    if (tokenListIndex >= this.tokens.length - 1) {
      if (this.preferredRules.has(startState.ruleIndex)) {
        this.translateStackToRuleIndex(callStack);
      } else {
        for (const set of followSets.sets) {
          const fullPath = callStack.slice();
          const followSetPath = set.path.map((path) => {
            return {
              startTokenIndex,
              ruleIndex: path
            };
          });
          fullPath.push(...followSetPath);
          if (!this.translateStackToRuleIndex(fullPath)) {
            for (const symbol of set.intervals.toArray()) {
              if (!this.ignoredTokens.has(symbol)) {
                if (this.showDebugOutput) {
                  console.log("=====> collected: ", this.vocabulary.getDisplayName(symbol));
                }
                if (!this.candidates.tokens.has(symbol)) {
                  this.candidates.tokens.set(symbol, set.following);
                } else {
                  if (this.candidates.tokens.get(symbol) !== set.following) {
                    this.candidates.tokens.set(symbol, []);
                  }
                }
              }
            }
          }
        }
      }
      if (!followSets.isExhaustive) {
        result.add(tokenListIndex);
      }
      callStack.pop();
      return result;
    } else {
      const currentSymbol = this.tokens[tokenListIndex].type;
      if (followSets.isExhaustive && !followSets.combined.contains(currentSymbol)) {
        callStack.pop();
        return result;
      }
    }
    if (startState.isPrecedenceRule) {
      this.precedenceStack.push(precedence);
    }
    const statePipeline = [];
    let currentEntry;
    statePipeline.push({ state: startState, tokenListIndex });
    while (statePipeline.length > 0) {
      currentEntry = statePipeline.pop();
      ++this.statesProcessed;
      const currentSymbol = this.tokens[currentEntry.tokenListIndex].type;
      const atCaret = currentEntry.tokenListIndex >= this.tokens.length - 1;
      if (this.showDebugOutput) {
        this.printDescription(
          indentation,
          currentEntry.state,
          this.generateBaseDescription(currentEntry.state),
          currentEntry.tokenListIndex
        );
        if (this.showRuleStack) {
          this.printRuleState(callStack);
        }
      }
      if (currentEntry.state.constructor.stateType === import_antlr4ng.ATNState.RULE_STOP) {
        result.add(currentEntry.tokenListIndex);
        continue;
      }
      const transitions = currentEntry.state.transitions;
      for (const transition of transitions) {
        switch (transition.transitionType) {
          case import_antlr4ng.Transition.RULE: {
            const ruleTransition = transition;
            const endStatus = this.processRule(
              transition.target,
              currentEntry.tokenListIndex,
              callStack,
              ruleTransition.precedence,
              indentation + 1
            );
            for (const position of endStatus) {
              statePipeline.push({
                state: transition.followState,
                tokenListIndex: position
              });
            }
            break;
          }
          case import_antlr4ng.Transition.PREDICATE: {
            if (this.checkPredicate(transition)) {
              statePipeline.push({
                state: transition.target,
                tokenListIndex: currentEntry.tokenListIndex
              });
            }
            break;
          }
          case import_antlr4ng.Transition.PRECEDENCE: {
            const predTransition = transition;
            if (predTransition.precedence >= this.precedenceStack[this.precedenceStack.length - 1]) {
              statePipeline.push({
                state: transition.target,
                tokenListIndex: currentEntry.tokenListIndex
              });
            }
            break;
          }
          case import_antlr4ng.Transition.WILDCARD: {
            if (atCaret) {
              if (!this.translateStackToRuleIndex(callStack)) {
                for (const token of import_antlr4ng.IntervalSet.of(import_antlr4ng.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType).toArray()) {
                  if (!this.ignoredTokens.has(token)) {
                    this.candidates.tokens.set(token, []);
                  }
                }
              }
            } else {
              statePipeline.push({
                state: transition.target,
                tokenListIndex: currentEntry.tokenListIndex + 1
              });
            }
            break;
          }
          default: {
            if (transition.isEpsilon) {
              statePipeline.push({
                state: transition.target,
                tokenListIndex: currentEntry.tokenListIndex
              });
              continue;
            }
            let set = transition.label;
            if (set && set.length > 0) {
              if (transition.transitionType === import_antlr4ng.Transition.NOT_SET) {
                set = set.complement(import_antlr4ng.Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
              }
              if (atCaret) {
                if (!this.translateStackToRuleIndex(callStack)) {
                  const list = set.toArray();
                  const hasTokenSequence = list.length === 1;
                  for (const symbol of list) {
                    if (!this.ignoredTokens.has(symbol)) {
                      if (this.showDebugOutput) {
                        console.log(
                          "=====> collected: ",
                          this.vocabulary.getDisplayName(symbol)
                        );
                      }
                      const followingTokens = hasTokenSequence ? this.getFollowingTokens(transition) : [];
                      if (!this.candidates.tokens.has(symbol)) {
                        this.candidates.tokens.set(symbol, followingTokens);
                      } else {
                        this.candidates.tokens.set(
                          symbol,
                          longestCommonPrefix(
                            followingTokens,
                            this.candidates.tokens.get(symbol)
                          )
                        );
                      }
                    }
                  }
                }
              } else {
                if (set.contains(currentSymbol)) {
                  if (this.showDebugOutput) {
                    console.log("=====> consumed: ", this.vocabulary.getDisplayName(currentSymbol));
                  }
                  statePipeline.push({
                    state: transition.target,
                    tokenListIndex: currentEntry.tokenListIndex + 1
                  });
                }
              }
            }
          }
        }
      }
    }
    callStack.pop();
    if (startState.isPrecedenceRule) {
      this.precedenceStack.pop();
    }
    positionMap.set(tokenListIndex, result);
    return result;
  }
  generateBaseDescription(state) {
    const stateValue = state.stateNumber === import_antlr4ng.ATNState.INVALID_STATE_NUMBER ? "Invalid" : state.stateNumber;
    const typeName = _CodeCompletionCore.atnStateTypeMap[state.constructor.stateType];
    return `[${stateValue} ${typeName}] in ${this.ruleNames[state.ruleIndex]}`;
  }
  printDescription(indentation, state, baseDescription, tokenIndex) {
    const indent = "  ".repeat(indentation);
    let output = indent;
    let transitionDescription = "";
    if (this.debugOutputWithTransitions) {
      for (const transition of state.transitions) {
        let labels = "";
        const symbols = transition.label ? transition.label.toArray() : [];
        if (symbols.length > 2) {
          labels = this.vocabulary.getDisplayName(symbols[0]) + " .. " + this.vocabulary.getDisplayName(symbols[symbols.length - 1]);
        } else {
          for (const symbol of symbols) {
            if (labels.length > 0) {
              labels += ", ";
            }
            labels += this.vocabulary.getDisplayName(symbol);
          }
        }
        if (labels.length === 0) {
          labels = "\u03B5";
        }
        const typeName = _CodeCompletionCore.atnStateTypeMap[transition.target.constructor.stateType];
        transitionDescription += `
${indent}	(${labels}) [${transition.target.stateNumber} ${typeName}] in ${this.ruleNames[transition.target.ruleIndex]}`;
      }
    }
    if (tokenIndex >= this.tokens.length - 1) {
      output += `<<${this.tokenStartIndex + tokenIndex}>> `;
    } else {
      output += `<${this.tokenStartIndex + tokenIndex}> `;
    }
    console.log(output + "Current state: " + baseDescription + transitionDescription);
  }
  printRuleState(stack) {
    if (stack.length === 0) {
      console.log("<empty stack>");
      return;
    }
    for (const rule of stack) {
      console.log(this.ruleNames[rule.ruleIndex]);
    }
  }
};

// src/SymbolTable.ts
var SymbolTable = class extends ScopedSymbol {
  constructor(name, options) {
    super(name);
    this.options = options;
  }
  static {
    __name(this, "SymbolTable");
  }
  /**  Other symbol information available to this instance. */
  dependencies = /* @__PURE__ */ new Set();
  get info() {
    return {
      dependencyCount: this.dependencies.size,
      symbolCount: this.children.length
    };
  }
  clear() {
    super.clear();
    this.dependencies.clear();
  }
  addDependencies(...tables) {
    tables.forEach((value) => {
      this.dependencies.add(value);
    });
  }
  removeDependency(table) {
    if (this.dependencies.has(table)) {
      this.dependencies.delete(table);
    }
  }
  addNewSymbolOfType(t, parent, ...args) {
    const result = new t(...args);
    if (!parent || parent === this) {
      this.addSymbol(result);
    } else {
      parent.addSymbol(result);
    }
    return result;
  }
  async addNewNamespaceFromPath(parent, path, delimiter = ".") {
    const parts = path.split(delimiter);
    let i = 0;
    let currentParent = parent === void 0 ? this : parent;
    while (i < parts.length - 1) {
      let namespace = await currentParent.resolve(parts[i], true);
      if (namespace === void 0) {
        namespace = this.addNewSymbolOfType(NamespaceSymbol, currentParent, parts[i]);
      }
      currentParent = namespace;
      ++i;
    }
    return this.addNewSymbolOfType(NamespaceSymbol, currentParent, parts[parts.length - 1]);
  }
  addNewNamespaceFromPathSync(parent, path, delimiter = ".") {
    const parts = path.split(delimiter);
    let i = 0;
    let currentParent = parent === void 0 ? this : parent;
    while (i < parts.length - 1) {
      let namespace = currentParent.resolveSync(parts[i], true);
      if (namespace === void 0) {
        namespace = this.addNewSymbolOfType(NamespaceSymbol, currentParent, parts[i]);
      }
      currentParent = namespace;
      ++i;
    }
    return this.addNewSymbolOfType(NamespaceSymbol, currentParent, parts[parts.length - 1]);
  }
  async getAllSymbols(t, localOnly = false) {
    const result = await super.getAllSymbols(t, localOnly);
    if (!localOnly) {
      const dependencyResults = await Promise.all([...this.dependencies].map((dependency) => {
        return dependency.getAllSymbols(t, localOnly);
      }));
      dependencyResults.forEach((value) => {
        result.push(...value);
      });
    }
    return result;
  }
  getAllSymbolsSync(t, localOnly = false) {
    const result = super.getAllSymbolsSync(t, localOnly);
    if (!localOnly) {
      this.dependencies.forEach((dependency) => {
        result.push(...dependency.getAllSymbolsSync(t, localOnly));
      });
    }
    return result;
  }
  async symbolWithContext(context) {
    const findRecursive = /* @__PURE__ */ __name((symbol) => {
      if (symbol.context === context) {
        return symbol;
      }
      if (symbol instanceof ScopedSymbol) {
        for (const child of symbol.children) {
          const result = findRecursive(child);
          if (result) {
            return result;
          }
        }
      }
      return void 0;
    }, "findRecursive");
    let symbols = await this.getAllSymbols(BaseSymbol);
    for (const symbol of symbols) {
      const result = findRecursive(symbol);
      if (result) {
        return result;
      }
    }
    for (const dependency of this.dependencies) {
      symbols = await dependency.getAllSymbols(BaseSymbol);
      for (const symbol of symbols) {
        const result = findRecursive(symbol);
        if (result) {
          return result;
        }
      }
    }
    return void 0;
  }
  symbolWithContextSync(context) {
    const findRecursive = /* @__PURE__ */ __name((symbol) => {
      if (symbol.context === context) {
        return symbol;
      }
      if (symbol instanceof ScopedSymbol) {
        for (const child of symbol.children) {
          const result = findRecursive(child);
          if (result) {
            return result;
          }
        }
      }
      return void 0;
    }, "findRecursive");
    let symbols = this.getAllSymbolsSync(BaseSymbol);
    for (const symbol of symbols) {
      const result = findRecursive(symbol);
      if (result) {
        return result;
      }
    }
    for (const dependency of this.dependencies) {
      symbols = dependency.getAllSymbolsSync(BaseSymbol);
      for (const symbol of symbols) {
        const result = findRecursive(symbol);
        if (result) {
          return result;
        }
      }
    }
    return void 0;
  }
  async resolve(name, localOnly = false) {
    let result = await super.resolve(name, localOnly);
    if (!result && !localOnly) {
      for (const dependency of this.dependencies) {
        result = await dependency.resolve(name, false);
        if (result) {
          return result;
        }
      }
    }
    return result;
  }
  resolveSync(name, localOnly = false) {
    let result = super.resolveSync(name, localOnly);
    if (!result && !localOnly) {
      for (const dependency of this.dependencies) {
        result = dependency.resolveSync(name, false);
        if (result) {
          return result;
        }
      }
    }
    return result;
  }
};