corsa-oxlint 0.8.0 → 0.10.0

package/README.md

@@ -12,6 +12,7 @@ plugins with real type information powered by `tsgo`.
 ## What It Does
 
 - exposes `OxlintUtils.RuleCreator()` and `getParserServices()` backed by `tsgo`
+- exposes compatibility namespaces such as `ESLintUtils`, `TSESLint`, `TSESTree`, and `TSUtils`
 - keeps a compact self-hosted helper surface with no extra lint-framework dependency
 - binds Rust-implemented hot paths into JS through `napi-rs`
 - lets custom Oxlint rules query types and symbols from JS or TS
@@ -114,29 +115,10 @@ export default [
 ];
 ```
 
-Current native coverage includes:
-
-- `await-thenable`
-- `no-array-delete`
-- `no-base-to-string`
-- `no-floating-promises`
-- `no-for-in-array`
-- `no-implied-eval`
-- `no-mixed-enums`
-- `no-unsafe-assignment`
-- `no-unsafe-return`
-- `no-unsafe-unary-minus`
-- `only-throw-error`
-- `prefer-find`
-- `prefer-includes`
-- `prefer-promise-reject-errors`
-- `prefer-regexp-exec`
-- `prefer-string-starts-ends-with`
-- `require-array-sort-compare`
-- `restrict-plus-operands`
-- `use-unknown-in-catch-callback-variable`
-
-The remaining upstream rules stay listed in `pendingNativeRuleNames`, and
+Current native coverage is exported from `implementedNativeRuleNames`. It now
+covers the tracked upstream `tsgolint/internal/rules` surface, including the
+unsafe, unnecessary, promise/control-flow, preference/style, and type/export
+families. `pendingNativeRuleNames` is intentionally empty, and
 `native_rules.test.ts` fails if implemented + pending drift away from the
 tracked upstream rule list.
 
@@ -151,13 +133,10 @@ as Oxlint JS plugin rules. The bridge is:
 4. Rust returns Oxlint-shaped diagnostics, suggestions, and fixes.
 5. The JS rule reports them through `context.report()`.
 
-The first rules on this path are `await-thenable`, `no-array-delete`,
-`no-for-in-array`, `no-implied-eval`, `no-mixed-enums`,
-`no-unsafe-unary-minus`, `only-throw-error`, `prefer-find`,
-`prefer-includes`, `prefer-regexp-exec`, and
-`use-unknown-in-catch-callback-variable`. Custom project-specific rules can
-still be authored in JS/TS with `OxlintUtils.RuleCreator()`, while hot,
-shared, tsgolint-parity rules can move into Rust incrementally.
+The built-in tsgolint parity rules are registered through
+`corsa::lint::RustLintRule`. Custom project-specific rules can still be
+authored in JS/TS with `OxlintUtils.RuleCreator()`, while hot, shared rules can
+continue to move deeper into compact Rust facts as the bridge grows.
 
 ## Runtime Safety Controls
 
@@ -183,6 +162,7 @@ vp check
 vp test run --config ./vite.config.ts src/bindings/nodejs/typescript_oxlint/ts/**/*.test.ts
 vp test bench --config ./vite.config.ts bench/src/typescript_oxlint.bench.ts
 vp test bench --config ./vite.config.ts bench/src/typescript_oxlint_rules.bench.ts
+vp run -w bench_tooling_compare
 ```
 
 Repository-level examples live under [`examples/`](../../examples/README.md),

package/dist/ast_utils.d.ts

@@ -1,17 +1,479 @@
 declare namespace ast_utils_d_exports {
-  export { ASTUtils, isIdentifier, isNodeOfType };
+  export { ASTUtils, LINEBREAK_MATCHER, PatternMatcher, ReferenceTracker, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isAwaitExpression, isAwaitKeyword, isClassOrTypeElement, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isConstructor, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isImportKeyword, isLogicalOrOperator, isLoop, isNodeOfType, isNodeOfTypeWithConditions, isNodeOfTypes, isNonNullAssertionPunctuator, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotNonNullAssertionPunctuator, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotOptionalChainPunctuator, isNotSemicolonToken, isNotTokenOfTypeWithConditions, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isOptionalCallExpression, isOptionalChainPunctuator, isParenthesized, isSemicolonToken, isSetter, isTSConstructorType, isTSFunctionType, isTokenOfTypeWithConditions, isTokenOnSameLine, isTypeAssertion, isTypeKeyword, isVariableDeclarator };
 }
-declare function isNodeOfType(node: {
+type TypedValue = {
   readonly type?: string;
-} | null | undefined, type: string): boolean;
+};
+type ValueToken = {
+  readonly type?: string;
+  readonly value?: string;
+};
+type Predicate<T> = (value: T | null | undefined) => boolean;
+type AstNode = Record<string, unknown> & {
+  readonly name?: string;
+  readonly range?: readonly [number, number];
+  readonly type?: string;
+};
+type StaticValue = {
+  readonly value: unknown;
+} | null;
+type Position = {
+  readonly line: number;
+  readonly column: number;
+};
+type SourceLocation = {
+  readonly start: Position;
+  readonly end: Position;
+};
+type TokenLike = {
+  readonly type?: string;
+  readonly value?: string;
+  readonly loc?: SourceLocation;
+};
+type SourceCodeLike = {
+  readonly visitorKeys?: Readonly<Record<string, readonly string[]>>;
+  getFirstToken?: (node: unknown, predicate?: (token: TokenLike) => boolean) => TokenLike | null;
+  getText?: (node: unknown) => string;
+  getTokenAfter?: (node: unknown, predicate?: (token: TokenLike) => boolean) => TokenLike | null;
+  getTokenBefore?: (node: unknown, predicate?: (token: TokenLike) => boolean) => TokenLike | null;
+};
+type ScopeLike = {
+  readonly block?: AstNode & {
+    readonly range?: readonly [number, number];
+  };
+  readonly childScopes?: readonly ScopeLike[];
+  readonly set?: ReadonlyMap<string, VariableLike>;
+  readonly upper?: ScopeLike | null;
+};
+type HasSideEffectOptions = {
+  readonly considerGetters?: boolean;
+  readonly considerImplicitTypeConversion?: boolean;
+};
+type ReferenceLike = {
+  readonly identifier?: AstNode;
+  isRead?: () => boolean;
+  isWrite?: () => boolean;
+};
+type VariableLike = {
+  readonly defs?: readonly unknown[];
+  readonly references?: readonly ReferenceLike[];
+};
+type TraceMapValue<T> = TraceMapElement<T> | T | true | undefined;
+interface TraceMapElement<T = never> {
+  readonly [key: string]: TraceMapValue<T>;
+  readonly [key: number]: TraceMapValue<T>;
+  [ReferenceTracker.READ]?: T;
+  [ReferenceTracker.CALL]?: T;
+  [ReferenceTracker.CONSTRUCT]?: T;
+  [ReferenceTracker.ESM]?: true;
+}
+type FoundReference<T = unknown> = {
+  info: T;
+  node: AstNode;
+  path: string[];
+  type: ReferenceTracker.ReferenceType;
+};
+declare function isNodeOfType(type: string): Predicate<TypedValue>;
+declare function isNodeOfType(node: TypedValue | null | undefined, type: string): boolean;
+declare function isNodeOfTypes(types: readonly string[]): Predicate<TypedValue>;
+declare function isNodeOfTypes(node: TypedValue | null | undefined, types: readonly string[]): boolean;
+declare function isNodeOfTypeWithConditions(type: string, conditions: Readonly<Record<string, unknown>>): Predicate<TypedValue>;
+declare function isNodeOfTypeWithConditions(node: TypedValue | null | undefined, type: string, conditions: Readonly<Record<string, unknown>>): boolean;
 declare function isIdentifier(node: {
   readonly type?: string;
   readonly name?: string;
 } | null | undefined, name?: string): boolean;
+declare function isTokenOfTypeWithConditions(type: string, conditions: Readonly<Record<string, unknown>>): Predicate<ValueToken>;
+declare function isTokenOfTypeWithConditions(token: ValueToken | null | undefined, type: string, conditions: Readonly<Record<string, unknown>>): boolean;
+declare function isNotTokenOfTypeWithConditions(type: string, conditions: Readonly<Record<string, unknown>>): Predicate<ValueToken>;
+declare function isNotTokenOfTypeWithConditions(token: ValueToken | null | undefined, type: string, conditions: Readonly<Record<string, unknown>>): boolean;
+declare function isFunction(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isFunctionType(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isFunctionOrFunctionType(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isTSFunctionType(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isTSConstructorType(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isAwaitExpression(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isVariableDeclarator(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isLoop(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isTypeAssertion(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isClassOrTypeElement(node: {
+  readonly type?: string;
+} | null | undefined): boolean;
+declare function isOptionalCallExpression(node: {
+  readonly type?: string;
+  readonly optional?: boolean;
+} | null | undefined): boolean;
+declare function isConstructor(node: {
+  readonly type?: string;
+  readonly kind?: string;
+} | null | undefined): boolean;
+declare function isSetter(node: {
+  readonly type?: string;
+  readonly kind?: string;
+} | null | undefined): boolean;
+declare const LINEBREAK_MATCHER: RegExp;
+declare const isArrowToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotArrowToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isAwaitKeyword: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isClosingBraceToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotClosingBraceToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isClosingBracketToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotClosingBracketToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isClosingParenToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotClosingParenToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isColonToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotColonToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isCommaToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotCommaToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isCommentToken: (token: {
+  readonly type?: string;
+} | null | undefined) => boolean;
+declare const isNotCommentToken: (token: {
+  readonly type?: string;
+} | null | undefined) => boolean;
+declare const isImportKeyword: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isLogicalOrOperator: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNonNullAssertionPunctuator: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotNonNullAssertionPunctuator: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isOpeningBraceToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotOpeningBraceToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isOpeningBracketToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotOpeningBracketToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isOpeningParenToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotOpeningParenToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isOptionalChainPunctuator: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotOptionalChainPunctuator: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isSemicolonToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isNotSemicolonToken: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare const isTypeKeyword: (token: {
+  readonly type?: string;
+  readonly value?: string;
+} | null | undefined) => boolean;
+declare function isTokenOnSameLine(left: {
+  readonly loc?: {
+    readonly end?: {
+      readonly line?: number;
+    };
+  };
+}, right: {
+  readonly loc?: {
+    readonly start?: {
+      readonly line?: number;
+    };
+  };
+}): boolean;
+declare function isParenthesized(node: {
+  readonly range?: readonly [number, number];
+}, sourceCode?: {
+  getTokenBefore?: (node: unknown) => {
+    readonly value?: string;
+  } | null;
+  getTokenAfter?: (node: unknown) => {
+    readonly value?: string;
+  } | null;
+}): boolean;
+declare function getInnermostScope(initialScope: ScopeLike | null | undefined, node: {
+  readonly range?: readonly [number, number];
+} | null | undefined): ScopeLike | null;
+declare function findVariable(initialScope: ScopeLike | null | undefined, nameOrNode: string | ({
+  readonly name?: string;
+} & {
+  readonly range?: readonly [number, number];
+})): VariableLike | null;
+declare function getFunctionHeadLocation(node: AstNode | null | undefined, sourceCode?: SourceCodeLike): SourceLocation | null;
+declare function getFunctionNameWithKind(node: AstNode | null | undefined, sourceCode?: SourceCodeLike): string;
+declare function getPropertyName(node: AstNode | null | undefined): string | null;
+declare function getStaticValue(node: AstNode | null | undefined): StaticValue;
+declare function getStringIfConstant(node: AstNode | null | undefined): string | null;
+declare function hasSideEffect(node: AstNode | null | undefined, sourceCode?: SourceCodeLike, options?: HasSideEffectOptions): boolean;
+declare class PatternMatcher {
+  constructor(pattern: RegExp, options?: {
+    readonly escaped?: boolean;
+  });
+  execAll(str: string): IterableIterator<RegExpExecArray>;
+  test(str: string): boolean;
+  [Symbol.replace](str: string, replacer: string | ((substring: string, ...args: unknown[]) => string)): string;
+}
+declare class ReferenceTracker {
+  #private;
+  static readonly READ: unique symbol;
+  static readonly CALL: unique symbol;
+  static readonly CONSTRUCT: unique symbol;
+  static readonly ESM: unique symbol;
+  constructor(globalScope: ScopeLike, options?: {
+    readonly globalObjectNames?: readonly string[];
+    readonly mode?: "legacy" | "strict";
+  });
+  iterateGlobalReferences<T>(traceMap: TraceMapElement<T>): IterableIterator<FoundReference<T>>;
+  iterateCjsReferences<T>(traceMap: TraceMapElement<T>): IterableIterator<FoundReference<T>>;
+  iterateEsmReferences<T>(traceMap: TraceMapElement<T>): IterableIterator<FoundReference<T>>;
+  iteratePropertyReferences<T>(node: AstNode, traceMap: TraceMapElement<T>): IterableIterator<FoundReference<T>>;
+}
+declare namespace ReferenceTracker {
+  type READ = typeof ReferenceTracker.READ;
+  type CALL = typeof ReferenceTracker.CALL;
+  type CONSTRUCT = typeof ReferenceTracker.CONSTRUCT;
+  type ESM = typeof ReferenceTracker.ESM;
+  type ReferenceType = READ | CALL | CONSTRUCT;
+  type TraceMap<T = unknown> = TraceMapElement<T>;
+  type FoundReference<T = unknown> = {
+    info: T;
+    node: AstNode;
+    path: readonly string[];
+    type: ReferenceType;
+  };
+}
 declare const ASTUtils: Readonly<{
+  LINEBREAK_MATCHER: RegExp;
+  PatternMatcher: typeof PatternMatcher;
+  ReferenceTracker: typeof ReferenceTracker;
+  findVariable: typeof findVariable;
+  getFunctionHeadLocation: typeof getFunctionHeadLocation;
+  getFunctionNameWithKind: typeof getFunctionNameWithKind;
+  getInnermostScope: typeof getInnermostScope;
+  getPropertyName: typeof getPropertyName;
+  getStaticValue: typeof getStaticValue;
+  getStringIfConstant: typeof getStringIfConstant;
+  hasSideEffect: typeof hasSideEffect;
   isIdentifier: typeof isIdentifier;
+  isArrowToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isAwaitExpression: typeof isAwaitExpression;
+  isAwaitKeyword: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isClosingBraceToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isClosingBracketToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isClosingParenToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isClassOrTypeElement: typeof isClassOrTypeElement;
+  isColonToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isCommaToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isCommentToken: (token: {
+    readonly type?: string;
+  } | null | undefined) => boolean;
+  isConstructor: typeof isConstructor;
+  isFunction: typeof isFunction;
+  isFunctionOrFunctionType: typeof isFunctionOrFunctionType;
+  isFunctionType: typeof isFunctionType;
+  isImportKeyword: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isLogicalOrOperator: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isLoop: typeof isLoop;
   isNodeOfType: typeof isNodeOfType;
+  isNodeOfTypes: typeof isNodeOfTypes;
+  isNodeOfTypeWithConditions: typeof isNodeOfTypeWithConditions;
+  isNonNullAssertionPunctuator: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotArrowToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotClosingBraceToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotClosingBracketToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotClosingParenToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotColonToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotCommaToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotCommentToken: (token: {
+    readonly type?: string;
+  } | null | undefined) => boolean;
+  isNotNonNullAssertionPunctuator: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotOpeningBraceToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotOpeningBracketToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotOpeningParenToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotOptionalChainPunctuator: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotSemicolonToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isNotTokenOfTypeWithConditions: typeof isNotTokenOfTypeWithConditions;
+  isOpeningBraceToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isOpeningBracketToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isOpeningParenToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isOptionalCallExpression: typeof isOptionalCallExpression;
+  isOptionalChainPunctuator: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isParenthesized: typeof isParenthesized;
+  isSemicolonToken: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isSetter: typeof isSetter;
+  isTokenOfTypeWithConditions: typeof isTokenOfTypeWithConditions;
+  isTokenOnSameLine: typeof isTokenOnSameLine;
+  isTSConstructorType: typeof isTSConstructorType;
+  isTSFunctionType: typeof isTSFunctionType;
+  isTypeAssertion: typeof isTypeAssertion;
+  isTypeKeyword: (token: {
+    readonly type?: string;
+    readonly value?: string;
+  } | null | undefined) => boolean;
+  isVariableDeclarator: typeof isVariableDeclarator;
 }>;
 //#endregion
-export { ASTUtils, ast_utils_d_exports, isIdentifier, isNodeOfType };
+export { ASTUtils, LINEBREAK_MATCHER, PatternMatcher, ReferenceTracker, ast_utils_d_exports, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isAwaitExpression, isAwaitKeyword, isClassOrTypeElement, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isConstructor, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isImportKeyword, isLogicalOrOperator, isLoop, isNodeOfType, isNodeOfTypeWithConditions, isNodeOfTypes, isNonNullAssertionPunctuator, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotNonNullAssertionPunctuator, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotOptionalChainPunctuator, isNotSemicolonToken, isNotTokenOfTypeWithConditions, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isOptionalCallExpression, isOptionalChainPunctuator, isParenthesized, isSemicolonToken, isSetter, isTSConstructorType, isTSFunctionType, isTokenOfTypeWithConditions, isTokenOnSameLine, isTypeAssertion, isTypeKeyword, isVariableDeclarator };
 //# sourceMappingURL=ast_utils.d.ts.map