@vencord-companion/ast-parser 1.1.3 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vencord-companion/ast-parser",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "description": "",
   "main": "index.js",
   "keywords": [],
@@ -11,7 +11,7 @@
   "license": "LGPL-3.0-or-later",
   "dependencies": {
     "@sadan4/devtools-pretty-printer": "^1.0.4",
-    "@vencord-companion/shared": "1.1.3"
+    "@vencord-companion/shared": "1.2.1"
   },
   "exports": {
     "./*": "./dist/*.js",

package/src/AstParser.ts

@@ -0,0 +1,450 @@
+import { Format } from "@sadan4/devtools-pretty-printer";
+import { collectVariableUsage, type VariableInfo } from "ts-api-utils";
+import {
+    createSourceFile,
+    type Expression,
+    type Identifier,
+    isFunctionLike,
+    isLeftHandSideExpression,
+    isPropertyAccessExpression,
+    isVariableDeclaration,
+    isVariableDeclarationList,
+    type LeftHandSideExpression,
+    type MemberName,
+    type Node,
+    type PropertyAccessExpression,
+    type ReadonlyTextRange,
+    ScriptKind,
+    ScriptTarget,
+    type SourceFile,
+    SyntaxKind,
+} from "typescript";
+
+import { Cache, CacheGetter } from "@vencord-companion/shared/decorators";
+import { type Logger, NoopLogger } from "@vencord-companion/shared/Logger";
+import { type IPosition, Position } from "@vencord-companion/shared/Position";
+import { Range } from "@vencord-companion/shared/Range";
+
+import type { StringifiedModule } from "./StringifiedModule";
+import type { Functionish } from "./types";
+import { CharCode, findParent, getTokenAtPosition, isAssignmentExpression, isEOL } from "./util";
+
+let logger: Logger = NoopLogger;
+
+export function setLogger(newLogger: Logger): void {
+    logger = newLogger;
+}
+
+export class AstParser {
+    public static withFormattedText(text: string): AstParser {
+        return new this(Format(text));
+    }
+
+    public readonly text: string;
+
+    /**
+     * @CacheGetter
+     */
+    @CacheGetter()
+    public get sourceFile(): SourceFile {
+        return this.createSourceFile();
+    }
+
+    /**
+     * All the variables in the source file
+     * @CacheGetter
+     */
+    @CacheGetter()
+    public get vars(): Map<Identifier, VariableInfo> {
+        return collectVariableUsage(this.sourceFile);
+    }
+
+    /**
+     * @CacheGetter
+     */
+    @CacheGetter()
+    public get usesToVars(): Map<Identifier, VariableInfo> {
+        const map = new Map<Identifier, VariableInfo>();
+
+        for (const [, info] of this.vars) {
+            for (const { location } of info.uses) {
+                map.set(location, info);
+            }
+            // for (const decl of info.declarations) {
+            //     map.set(decl, info);
+            // }
+        }
+
+        return map;
+    }
+
+    public getVarInfoFromUse(ident: Identifier): VariableInfo | undefined {
+        return this.usesToVars.get(ident);
+    }
+
+    // FIXME: add tests for this
+    /**
+     * @param use a use of a variable
+     * @param decl a declaration of a variable
+     * @returns true of the use is a use of the declaration, false otherwise
+     */
+    public isUseOf(use: Identifier | undefined, decl: Identifier | undefined): boolean {
+        if (!decl || !use)
+            return false;
+
+        const varInfo = this.vars.get(decl);
+
+        if (!varInfo)
+            return false;
+
+        const varInfoFromUse = this.usesToVars.get(use);
+
+        return varInfoFromUse === varInfo;
+    }
+
+    public constructor(text: string) {
+        this.text = text;
+    }
+
+    /**
+     * given something like this
+     * ```js
+     * const bar = "foo";
+     * const baz = bar;
+     * const qux = baz;
+     * ```
+     * if given `qux` it will return `[bar, baz]`;
+     *
+     * fails on something where a variable is reassigned
+     */
+    public unwrapVariableDeclaration(ident: Identifier): Identifier[] | undefined {
+        const arr: Identifier[] = [];
+        let last = ident;
+
+        while (true) {
+            const [varDec, ...rest] = this.getVarInfoFromUse(last)?.declarations ?? [];
+
+            if (!varDec)
+                break;
+            if (rest.length) {
+                arr.length = 0;
+                break;
+            }
+            arr.push(last = varDec);
+        }
+        if (arr.length !== 0)
+            return arr;
+        logger.debug("[AstParser] Failed finding variable declaration");
+    }
+
+    /**
+     * Used for interop with other systems
+     */
+    // FIXME: PACKAGE -
+    public serialize(): StringifiedModule {
+        return {
+            content: this.text,
+        } satisfies StringifiedModule;
+    }
+
+    /**
+     * given the `x` of
+     * ```js
+     * const x = {
+     * foo: bar
+     * }
+     * ```
+     * NOTE: this must be the exact x, not a use of it
+     * @returns the expression {foo: bar}
+     */
+    public getVariableInitializer(ident: Identifier): Expression | undefined {
+        const dec = ident.parent;
+
+        if (!isVariableDeclaration(dec))
+            return;
+        return dec.initializer;
+    }
+
+    /**
+     * TODO: document this
+     */
+    public isConstDeclared(info: VariableInfo): [Identifier] | false {
+        const len = info.declarations.length;
+
+        if (len !== 1) {
+            if (len > 1) {
+                logger.warn("[AstParser] isConstDeclared: ?????");
+            }
+            return false;
+        }
+
+        const [decl] = info.declarations;
+        const varDecl = findParent(decl, isVariableDeclarationList);
+
+        return ((varDecl?.flags ?? 0) & SyntaxKind.ConstKeyword) !== 0 ? [decl] : false;
+    }
+
+    // TODO: add tests for this
+    /**
+     * @param expr the property access expression to flatten
+     *
+     * given a property access expression like `foo.bar.baz.qux`
+     * 
+     * @returns the identifiers [`foo`, `bar`, `baz`, `qux`]
+     * 
+     * given another property access expression like `foo.bar.baz[0].qux.abc`
+     * 
+     * @returns the elementAccessExpression, followed by the identifiers [`foo.bar.baz[0]`, `qux`, `abc`]
+     */
+    public flattenPropertyAccessExpression(expr: PropertyAccessExpression | undefined):
+      | readonly [LeftHandSideExpression, ...MemberName[]]
+      | undefined {
+        if (!expr)
+            return undefined;
+
+        const toRet = [] as any as [LeftHandSideExpression, ...MemberName[]];
+        let cur = expr;
+
+        do {
+            toRet.unshift(cur.name);
+            if (isLeftHandSideExpression(cur.expression) && !isPropertyAccessExpression(cur.expression)) {
+                toRet.unshift(cur.expression);
+                return toRet;
+            }
+            if (!isPropertyAccessExpression(cur.expression)) {
+                toRet.unshift(cur.expression);
+                return;
+            }
+        } while ((cur = cur.expression));
+    }
+
+    /**
+     * given a variable, if it has a single assignment in this file, return the expression assigned to it
+     * 
+     * returns undefined if there are multiple assignments, or if the variable is assigned more than once
+     */
+    public findSingleAssignment(info: VariableInfo): Expression | undefined {
+        const { declarations, uses } = info;
+
+        if (declarations.length !== 1) {
+            logger.warn("[AstParser] findSingleAssignment: multiple declarations");
+            return;
+        }
+
+        const [decl] = declarations;
+
+        if (this.isConstDeclared(info)) {
+            const init = this.getVariableInitializer(decl);
+
+            if (!init) {
+                logger.warn("[AstParser] findSingleAssignment: const variable without initializer");
+            }
+            return init;
+        }
+
+        let init: Expression | undefined;
+
+        for (const { location } of uses) {
+            if (isAssignmentExpression(location.parent)) {
+                // filter out cases like `<some other thing> = location`
+                if (location.parent.left !== location) {
+                    continue;
+                }
+                if (init || location.parent.operatorToken.kind !== SyntaxKind.EqualsToken) {
+                    return;
+                }
+                init = location.parent.right;
+            }
+        }
+
+        return init;
+    }
+
+    /**
+     * Create the source file for this parser
+     *
+     * MUST SET PARENT NODES
+     * @Cache
+     */
+    @Cache()
+    protected createSourceFile(): SourceFile {
+        return createSourceFile(
+            "file.tsx",
+            this.text,
+            ScriptTarget.ESNext,
+            true,
+            ScriptKind.TSX,
+        );
+    }
+
+    /** Returns the token at or following the specified position or undefined if none is found inside `parent`. */
+    public getTokenAtOffset(pos: number): Node | undefined {
+        return getTokenAtPosition(this.sourceFile, pos, this.sourceFile, false);
+    }
+
+    public getTokenAtPosition(pos: IPosition): Node | undefined {
+        return this.getTokenAtOffset(this.offsetAt(pos));
+    }
+
+    /**
+     * convert two offsets to a range
+     * 
+     * **DO NOT USE WITH AN AST NODE, IT WILL LEAD TO INCORRECT LOCATIONS**
+     * @see makeRangeFromAstNode
+     */
+    public makeRange({ pos, end }: ReadonlyTextRange): Range {
+        return new Range(this.positionAt(pos), this.positionAt(end));
+    }
+
+    public makeRangeFromAstNode(node: Node): Range {
+        return new Range(this.positionAt(node.getStart(this.sourceFile)), this.positionAt(node.end));
+    }
+
+    public makeRangeFromAnonFunction(func: Functionish): Range {
+        const { pos } = func.body ?? { pos: func.getEnd() };
+
+        return this.makeRange({
+            pos: func.getStart(),
+            end: pos,
+        });
+    }
+
+    public makeRangeFromFunctionDef(ident: Identifier): Range | undefined {
+        const { declarations } = this.getVarInfoFromUse(ident) ?? {};
+
+        if (!declarations) {
+            logger.debug("makeRangeFromFunctionDef: no declarations found for identifier");
+            return undefined;
+        }
+        if (declarations.length !== 1) {
+            logger.debug("makeRangeFromFunctionDef: zero or multiple declarations found for identifier");
+            return undefined;
+        }
+        if (declarations[0].parent && !isFunctionLike(declarations[0].parent)) {
+            logger.debug("makeRangeFromFunctionDef: dec. parent is not a function");
+            return undefined;
+        }
+        return this.makeRangeFromAstNode(declarations[0]);
+    }
+
+
+    /**
+     * Converts the position to a zero-based offset.
+     * Invalid positions are adjusted as described in {@link Position.line}
+     * and {@link Position.character}.
+     *
+     * @param position A position.
+     * @return A valid zero-based offset.
+     */
+    // copied from vscode-languageserver-node
+    public offsetAt(position: IPosition): number {
+        const { lineOffsets } = this;
+
+        if (position.line >= lineOffsets.length) {
+            return this.text.length;
+        } else if (position.line < 0) {
+            return 0;
+        }
+
+        const lineOffset = lineOffsets[position.line];
+
+        if (position.character <= 0) {
+            return lineOffset;
+        }
+
+        const nextLineOffset
+            = position.line + 1 < lineOffsets.length
+                ? lineOffsets[position.line + 1]
+                : this.text.length;
+
+        const offset = Math.min(lineOffset + position.character, nextLineOffset);
+
+        return this.ensureBeforeEOL(offset, lineOffset);
+    }
+
+    // methods copied from vscode-languageserver-node
+    /**
+     * @CacheGetter
+     */
+    @CacheGetter()
+    private get lineOffsets() {
+        return this.computeLineOffsets(true);
+    }
+
+    @CacheGetter()
+    /**
+     * @CacheGetter
+     */
+    public get lineCount(): number {
+        return this.lineOffsets.length;
+    }
+
+    private ensureBeforeEOL(offset: number, lineOffset: number): number {
+        while (offset > lineOffset && isEOL(this.text.charCodeAt(offset - 1))) {
+            offset--;
+        }
+        return offset;
+    }
+
+    private computeLineOffsets(isAtLineStart: boolean, textOffset = 0): number[] {
+        const { text } = this;
+        const result: number[] = isAtLineStart ? [textOffset] : [];
+
+        for (let i = 0; i < text.length; i++) {
+            const ch = text.charCodeAt(i);
+
+            if (isEOL(ch)) {
+                if (
+                    ch === CharCode.CarriageReturn
+                    && i + 1 < text.length
+                    && text.charCodeAt(i + 1) === CharCode.LineFeed
+                ) {
+                    i++;
+                }
+                result.push(textOffset + i + 1);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Converts a zero-based offset to a position.
+     *
+     * @param offset A zero-based offset.
+     * @return A valid {@link Position position}.
+     * @example The text document "ab\ncd" produces:
+     * position { line: 0, character: 0 } for `offset` 0.
+     * position { line: 0, character: 1 } for `offset` 1.
+     * position { line: 0, character: 2 } for `offset` 2.
+     * position { line: 1, character: 0 } for `offset` 3.
+     * position { line: 1, character: 1 } for `offset` 4.
+     */
+    public positionAt(offset: number): Position {
+        offset = Math.max(Math.min(offset, this.text.length), 0);
+
+        const { lineOffsets } = this;
+
+        let low = 0,
+            high = lineOffsets.length;
+
+        if (high === 0) {
+            return new Position(0, offset);
+        }
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+
+            if (lineOffsets[mid] > offset) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        // low is the least x for which the line offset is larger than the current offset
+        // or array.length if no line offset is larger than the current offset
+        const line = low - 1;
+
+        offset = this.ensureBeforeEOL(offset, lineOffsets[line]);
+        return new Position(line, offset - lineOffsets[line]);
+    }
+}

package/src/StringifiedModule.ts

@@ -0,0 +1,3 @@
+export interface StringifiedModule {
+    content: string;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./AstParser";
+export type * from "./types";
+export * from "./util";

package/src/types.ts

@@ -0,0 +1,31 @@
+import type { ArrowFunction, FunctionExpression, FunctionLikeDeclaration, Identifier, ModuleExportName, Node } from "typescript";
+
+export type Functionish = FunctionLikeDeclaration | ArrowFunction | FunctionExpression;
+export type AnyFunction = FunctionExpression | ArrowFunction;
+
+export type AssertedType<
+    T extends Function,
+    E = any,
+>
+    = T extends (a: any) => a is infer R ? R extends E ? R : never : never;
+
+export type CBAssertion<U = undefined, N = never> = <
+    F extends (n: Node) => n is Node,
+    R extends Node = AssertedType<F, Node>,
+>(
+    node: Node | N,
+    func: F extends (n: Node) => n is R ? F : never
+) => R | U;
+
+export type Import = {
+    default: boolean;
+    source: string;
+    namespace: boolean;
+    orig?: ModuleExportName;
+    as: Identifier;
+};
+
+export type WithParent<N, P> = Omit<N, "parent"> & {
+    parent: P;
+};
+

package/src/util.ts

@@ -0,0 +1,571 @@
+import { isStaticKeyword } from "ts-api-utils";
+import {
+    type AssignmentExpression,
+    type AssignmentOperatorToken,
+    type BinaryExpression,
+    type Block,
+    type DefaultKeyword,
+    forEachChild,
+    type Identifier,
+    type ImportClause,
+    isArrowFunction,
+    isBigIntLiteral,
+    isBinaryExpression,
+    isBlock,
+    isConstructorDeclaration,
+    isExpressionStatement,
+    isFunctionDeclaration,
+    isFunctionExpression,
+    isGetAccessorDeclaration,
+    isIdentifier,
+    isImportClause,
+    isImportDeclaration,
+    isImportSpecifier,
+    isJsxText,
+    isMethodDeclaration,
+    isNamespaceImport as _TS_isNamespaceImport,
+    isNumericLiteral,
+    isObjectLiteralExpression,
+    isPropertyAccessExpression,
+    isRegularExpressionLiteral,
+    isReturnStatement,
+    isSetAccessorDeclaration,
+    isStringLiteral,
+    isStringLiteralLike,
+    isTokenKind,
+    isVariableDeclaration,
+    type LiteralToken,
+    type NamespaceImport,
+    type Node,
+    type ObjectLiteralElementLike,
+    type ObjectLiteralExpression,
+    type PlusToken,
+    type PropertyAccessExpression,
+    type PropertyDeclaration,
+    type SourceFile,
+    SyntaxKind,
+    type SyntaxList,
+    type Token,
+    type VariableDeclaration,
+} from "typescript";
+
+import type { AnyFunction, AssertedType, CBAssertion, Functionish, Import, WithParent } from "./types";
+
+export const enum CharCode {
+    /**
+     * The `\n` character.
+     */
+    LineFeed = 10,
+    /**
+     * The `\r` character.
+     */
+    CarriageReturn = 13,
+}
+
+export function isEOL(char: number): boolean {
+    return char === CharCode.CarriageReturn || char === CharCode.LineFeed;
+}
+
+/**
+ * given a function like this, returns the identifier for x
+ * @example function(){
+ * // any code here
+ * return x;
+ * }
+ * @param func a function to get the return value of
+ * @returns the return identifier, if any
+ */
+export function findReturnIdentifier(func: Functionish): Identifier | undefined {
+    if (!func.body)
+        return undefined;
+    if (isBlock(func.body))
+        return _findReturnIdentifier(func.body);
+    if (isIdentifier(func.body))
+        return func.body;
+}
+
+function _findReturnIdentifier(func: Block): Identifier | undefined {
+    const lastStatement = func.statements.at(-1);
+
+    if (
+        !lastStatement
+        || !isReturnStatement(lastStatement)
+        || !lastStatement.expression
+        || !isIdentifier(lastStatement.expression)
+    )
+        return undefined;
+
+    return lastStatement.expression;
+}
+
+/**
+ * given an object literal, returns the property assignment for `prop` if it exists
+ *
+ * if prop is defined more than once, returns the first
+ * @example
+ * {
+ *  exProp: "examplePropValue"
+ * }
+ * @param prop exProp
+ */
+export function findObjectLiteralByKey(
+    object: ObjectLiteralExpression,
+    prop: string,
+): ObjectLiteralElementLike | undefined {
+    return object.properties.find((x) => x.name?.getText() === prop);
+}
+
+/**
+ * first parent
+ */
+export const findParent: CBAssertion<undefined, undefined> = (node, func) => {
+    if (!node)
+        return undefined;
+    while (!func(node)) {
+        if (!node.parent)
+            return undefined;
+        node = node.parent;
+    }
+    return node;
+};
+
+export function findParentLimited<
+    F extends (n: Node) => n is Node,
+    R extends Node = AssertedType<F, Node>,
+>(
+    node: Node,
+    func: F extends (n: Node) => n is R ? F : never,
+    limit: number,
+): R | undefined {
+    if (!node)
+        return undefined;
+    limit += 1;
+    while (limit-- && !func(node)) {
+        if (!node.parent)
+            return undefined;
+        node = node.parent;
+    }
+    if (limit < 0) {
+        return undefined;
+    }
+    return node as R;
+}
+
+// FIXME: try simplifying this
+/**
+ * @param node the node to start from
+ * @param func a function to check if the parent matches
+ */
+export const lastParent: CBAssertion<undefined, undefined> = (node, func) => {
+    if (!node)
+        return undefined;
+    if (!node.parent)
+        return undefined;
+    while (func(node.parent)) {
+        if (!node.parent)
+            break;
+        node = node.parent;
+    }
+    return func(node) ? node : undefined;
+};
+
+export const lastChild: CBAssertion<undefined> = (node, func) => {
+    if (!node)
+        return undefined;
+
+    const c = node.getChildren();
+
+    if (c.length === 0) {
+        if (func(node))
+            return node;
+        return undefined;
+    }
+    if (c.length === 1) {
+        if (func(c[0]))
+            return lastChild(c[0], func);
+        if (func(node))
+            return node;
+        return undefined;
+    }
+
+    const x = one(c, func);
+
+    if (x) {
+        return lastChild(x, func);
+    }
+    if (func(node))
+        return node;
+    return undefined;
+};
+
+// FIXME: this seems really stupid
+export function one<
+    T,
+    F extends (t: T) => t is T,
+    R extends T = AssertedType<F, T>,
+>(
+    arr: readonly T[],
+    func: F extends (t: T) => t is R ? F : never,
+): R | undefined {
+    const filter = arr.filter<R>(func);
+
+    return filter.length === 1 ? filter[0] : undefined;
+}
+
+export function isDefaultImport(x: Identifier): x is WithParent<typeof x, ImportClause> {
+    return isImportClause(x.parent);
+}
+
+/**
+ * @param node any identifier in an import statment
+ */
+export function getImportName(node: Identifier): Pick<Import, "orig" | "as"> {
+    // default or namespace
+    if (isDefaultImport(node) || isNamespaceImport(node))
+        return { as: node };
+
+    const specifier = findParent(node, isImportSpecifier);
+
+    if (!specifier)
+        throw new Error("x is not in an import statment");
+    return {
+        orig: specifier.propertyName,
+        as: specifier.name,
+    };
+}
+
+// i fucking hate jsdoc
+/**
+ * given an access chain like `one.b.three.d` \@*returns* — `[one?, b?]`
+ *
+ * if b is returned, one is gaurenteed to be defined
+ * @param node any node in the property access chain
+ */
+export function getLeadingIdentifier(node: Node | undefined):
+  readonly [Identifier, undefined]
+  | readonly [Identifier, Identifier]
+  | readonly [undefined, undefined] {
+    if (!node)
+        return [node, undefined];
+
+    const { expression: module, name: wpExport } = (() => {
+        const lastP = lastParent(node, isPropertyAccessExpression);
+
+        return lastP && lastChild(lastP, isPropertyAccessExpression);
+    })() ?? {};
+
+    if (!module || !isIdentifier(module))
+        return [undefined, undefined];
+    return [
+        module,
+        wpExport ? isIdentifier(wpExport) ? wpExport : undefined : undefined,
+    ];
+}
+
+export function isInImportStatment(x: Node): boolean {
+    return findParent(x, isImportDeclaration) != null;
+}
+
+/**
+ * @param x an identifier in the import statment, not just any imported identifier
+ * @returns the source of the import statment
+ * @example
+ * ```
+ * import { x } from "source"
+ * ```
+ * @returns "source"
+ */
+export function getImportSource(x: Identifier): string {
+    const clause = findParent(x, isImportDeclaration);
+
+    if (!clause)
+        throw new Error("x is not in an import statment");
+    // getText returns with quotes, but the prop text does not have them ????
+    return clause.moduleSpecifier.getText()
+        .slice(1, -1);
+}
+
+export function isNamespaceImport(x: Identifier): x is WithParent<typeof x, NamespaceImport> {
+    return _TS_isNamespaceImport(x.parent);
+}
+
+export function isDefaultKeyword(n: Node): n is DefaultKeyword {
+    return n.kind === SyntaxKind.DefaultKeyword;
+}
+
+
+export function isSyntaxList(node: Node): node is SyntaxList {
+    return node.kind === SyntaxKind.SyntaxList;
+}
+
+/**
+ * given a function like
+ * ```ts
+ * function myFunc() {
+ * // any code here
+ * return a.b; // can be anything else, eg a.b.c a.b[anything]
+ * }
+ * ```
+ * @returns the returned property access expression, if any
+ **/
+export function findReturnPropertyAccessExpression(func: AnyFunction): PropertyAccessExpression | undefined {
+    if (isBlock(func.body))
+        return _findReturnPropertyAccessExpression(func.body);
+    if (isPropertyAccessExpression(func.body))
+        return func.body;
+}
+
+function _findReturnPropertyAccessExpression(func: Block): PropertyAccessExpression | undefined {
+    const lastStatment = func.statements.at(-1);
+
+    if (
+        !lastStatment
+        || !isReturnStatement(lastStatment)
+        || !lastStatment.expression
+        || !isPropertyAccessExpression(lastStatment.expression)
+    )
+        return undefined;
+
+    return lastStatment.expression;
+}
+
+export function tryParseStringOrNumberLiteral(node: Node | undefined): string | undefined {
+    if (!node)
+        return;
+    if (isStringLiteralLike(node) || isNumericLiteral(node)) {
+        return node.text;
+    }
+}
+
+export function isLiteralish(node: Node): node is LiteralToken {
+    return isStringLiteralLike(node)
+      || isNumericLiteral(node)
+      || isBigIntLiteral(node)
+      || isJsxText(node)
+      || isRegularExpressionLiteral(node);
+}
+
+export function isFunctionish(node: Node): node is Functionish {
+    return (
+        isFunctionDeclaration(node)
+        || isMethodDeclaration(node)
+        || isGetAccessorDeclaration(node)
+        || isSetAccessorDeclaration(node)
+        || isConstructorDeclaration(node)
+        || isFunctionExpression(node)
+        || isArrowFunction(node)
+
+    );
+}
+
+const DIRECTIVE_PREFIX = "use ";
+
+/**
+ * returns if the node is a directive
+ * ```ts
+ * "use strict"; // true
+ * "use something"; // true
+ * "not a directive"; // false
+ * 42; // false
+ * ```
+ */
+export function isDirective(node: Node): boolean {
+    if (!isExpressionStatement(node)) {
+        return false;
+    }
+
+    const { expression } = node;
+
+    if (!isStringLiteral(expression)) {
+        return false;
+    }
+
+    const { text } = expression;
+
+    if (text.length <= DIRECTIVE_PREFIX.length) {
+        return false;
+    }
+
+    return text.startsWith(DIRECTIVE_PREFIX);
+}
+
+const ASSIGNMENT_TOKENS: Partial<Record<SyntaxKind, true>> = {
+    [SyntaxKind.EqualsToken]: true,
+    [SyntaxKind.PlusEqualsToken]: true,
+    [SyntaxKind.MinusEqualsToken]: true,
+    [SyntaxKind.AsteriskAsteriskEqualsToken]: true,
+    [SyntaxKind.AsteriskEqualsToken]: true,
+    [SyntaxKind.SlashEqualsToken]: true,
+    [SyntaxKind.PercentEqualsToken]: true,
+    [SyntaxKind.AmpersandEqualsToken]: true,
+    [SyntaxKind.BarEqualsToken]: true,
+    [SyntaxKind.CaretEqualsToken]: true,
+    [SyntaxKind.LessThanLessThanEqualsToken]: true,
+    [SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: true,
+    [SyntaxKind.GreaterThanGreaterThanEqualsToken]: true,
+    [SyntaxKind.BarBarEqualsToken]: true,
+    [SyntaxKind.AmpersandAmpersandEqualsToken]: true,
+    [SyntaxKind.QuestionQuestionEqualsToken]: true,
+};
+
+export function isAssignmentExpression(node: Node | undefined):
+    node is AssignmentExpression<AssignmentOperatorToken> {
+    if (!node || !isBinaryExpression(node))
+        return false;
+
+    return ASSIGNMENT_TOKENS[node.operatorToken.kind] === true;
+}
+
+export function isVariableAssignmentLike(node: Node | undefined):
+    node is
+    | (
+      & Omit<VariableDeclaration, "name" | "initializer">
+      & {
+          name: Identifier;
+          initializer: Exclude<VariableDeclaration["initializer"], undefined>;
+      }
+    )
+    | (Omit<AssignmentExpression<AssignmentOperatorToken>, "left"> & { left: Identifier; }) {
+    if (!node)
+        return false;
+
+    if (isVariableDeclaration(node)) {
+        return isIdentifier(node.name) && !!node.initializer;
+    } else if (isBinaryExpression(node)) {
+        return isAssignmentExpression(node);
+    }
+    return false;
+}
+
+export function isBinaryPlusExpression(node: Node):
+    node is
+    & BinaryExpression
+    & {
+        readonly operatorToken: PlusToken;
+    } {
+    if (!isBinaryExpression(node)) {
+        return false;
+    }
+    if (node.operatorToken.kind !== SyntaxKind.PlusToken) {
+        return false;
+    }
+    return true;
+}
+
+
+/**
+ * @license MIT
+ * taken from tsutils, license below
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2017 Klaus Meinhardt
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+// empty comment so the license doesn't become the doc comment for this func
+
+/***/
+export function getTokenAtPosition(
+    parent: Node,
+    pos: number,
+    sourceFile?: SourceFile,
+    allowJsDoc?: boolean,
+): Node | undefined {
+    if (pos < parent.pos || pos >= parent.end) {
+        return;
+    }
+    if (isTokenKind(parent.kind)) {
+        return parent;
+    }
+    return _getTokenAtPosition(parent, pos, sourceFile ?? parent.getSourceFile(), allowJsDoc === true);
+}
+
+function _getTokenAtPosition(node: Node, pos: number, sourceFile: SourceFile, allowJsDoc: boolean): Node | undefined {
+    if (!allowJsDoc) {
+        // if we are not interested in JSDoc, we can skip to the deepest AST node at the given position
+        node = getAstNodeAtPosition(node, pos)!;
+        if (isTokenKind(node.kind)) {
+            return node;
+        }
+    }
+    outer: while (true) {
+        for (const child of node.getChildren()) {
+            if (child.end > pos && (allowJsDoc || child.kind !== SyntaxKind.JSDoc)) {
+                if (isTokenKind(child.kind)) {
+                    return child;
+                }
+                node = child;
+                continue outer;
+            }
+        }
+        return;
+    }
+}
+
+/** Returns the deepest AST Node at `pos`. Returns undefined if `pos` is outside of the range of `node` */
+export function getAstNodeAtPosition(node: Node, pos: number): Node | undefined {
+    if (node.pos > pos || node.end <= pos) {
+        return;
+    }
+    while (isNodeKind(node.kind)) {
+        const nested = forEachChild(node, (child) => (child.pos <= pos && child.end > pos ? child : undefined));
+
+        if (nested === undefined) {
+            break;
+        }
+        node = nested;
+    }
+    return node;
+}
+
+/**
+ * stolen form tsutils, seems sketchy
+ */
+function isNodeKind(kind: SyntaxKind) {
+    return kind >= SyntaxKind.FirstNode;
+}
+
+export function nonNull<T>(x: T | null | undefined): x is T {
+    return x != null;
+}
+
+export function isEmptyObjectLiteral(node: Node): node is ObjectLiteralExpression {
+    return isObjectLiteralExpression(node) && node.properties.length === 0;
+}
+
+export function isCommaExpression(node: Node): node is
+  & BinaryExpression
+  & {
+      readonly operatorToken: Token<SyntaxKind.CommaToken>;
+  } {
+    return isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.CommaToken;
+}
+
+export function isInExpression(node: Node): node is
+  & BinaryExpression
+  & {
+      readonly operatorToken: Token<SyntaxKind.InKeyword>;
+  } {
+    return isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.InKeyword;
+}
+
+export function isStatic(item: PropertyDeclaration): boolean {
+    return item.modifiers?.some((mod) => isStaticKeyword(mod)) ?? false;
+}