@bikky/compiler 0.0.7 → 0.0.9

package/Source/ASTInterface/Class.d.ts

@@ -0,0 +1,38 @@
+import * as ts from "typescript";
+import { NamedExpression } from "../ASTHelper";
+type APICallback<T, R = T> = (obj: T | null) => R | null;
+export declare class Decorator extends NamedExpression {
+    base: ts.Decorator;
+    constructor(base: ts.Decorator | ts.Identifier | string);
+    update(): ts.Decorator;
+}
+export declare class Class extends NamedExpression {
+    base: ts.ClassDeclaration | ts.ClassExpression;
+    modifiers: ts.Modifier[];
+    decorators: Decorator[];
+    extends: ts.HeritageClause | undefined;
+    implements: ts.HeritageClause[];
+    members: (ts.ClassElement)[];
+    typeParams: ts.TypeParameterDeclaration[];
+    constructor(base: ts.ClassDeclaration | ts.ClassExpression | string | ts.Identifier);
+    hasExtends(): boolean;
+    setExtends(extend: ts.ExpressionWithTypeArguments): void;
+    unshiftDecorator(...dec: Decorator[]): this;
+    pushDecorator(...dec: Decorator[]): this;
+    decorator(identifier: string | ts.Identifier, cb: APICallback<Decorator>): this;
+    decorator(cb: APICallback<Decorator>): this;
+    unshift(...members: ts.ClassElement[]): this;
+    push(...members: ts.ClassElement[]): this;
+    property(identifier: string | ts.Identifier | ts.PropertyDeclaration, cb: APICallback<ts.PropertyDeclaration, ts.ClassElement>): this;
+    property(cb: APICallback<ts.PropertyDeclaration, ts.ClassElement>): this;
+    method(identifier: string | ts.Identifier | ts.MethodDeclaration, cb: APICallback<ts.MethodDeclaration, ts.ClassElement>): this;
+    method(cb: APICallback<ts.MethodDeclaration, ts.ClassElement>): this;
+    update(): ts.ClassDeclaration | ts.ClassExpression;
+}
+export declare module Class {
+    function getModifiers(node: ts.ClassDeclaration): ts.Modifier[];
+    function getDecorators(node: ts.ClassDeclaration): ts.Decorator[];
+    function onClass(repl: (val: Class) => (Class | ts.Node | ts.Node[])): void;
+}
+export {};
+//# sourceMappingURL=Class.d.ts.map

package/Source/ASTInterface/Class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Class.d.ts","sourceRoot":"","sources":["Class.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,KAAI,CAAC,GAAG,IAAI,CAAC;AAExD,qBAAa,SAAU,SAAQ,eAAe;IAC1C,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC;gBAEP,IAAI,EAAE,EAAE,CAAC,SAAS,GAAG,EAAE,CAAC,UAAU,GAAG,MAAM;IAqBvD,MAAM;CAUT;AAED,qBAAa,KAAM,SAAQ,eAAe;IACtC,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,eAAe,CAAC;IAE/C,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAM;IAC9B,UAAU,EAAE,SAAS,EAAE,CAAM;IAC7B,OAAO,EAAE,EAAE,CAAC,cAAc,GAAG,SAAS,CAAC;IACvC,UAAU,EAAE,EAAE,CAAC,cAAc,EAAE,CAAM;IACrC,OAAO,EAAE,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,CAAM;IAClC,UAAU,EAAE,EAAE,CAAC,wBAAwB,EAAE,CAAM;gBAEnC,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,eAAe,GAAG,MAAM,GAAG,EAAE,CAAC,UAAU;IAuBnF,UAAU;IAIV,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,2BAA2B;IAIjD,gBAAgB,CAAC,GAAG,GAAG,EAAE,SAAS,EAAE;IAKpC,aAAa,CAAC,GAAG,GAAG,EAAE,SAAS,EAAE;IAKjC,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,EAAE,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC,GAAG,IAAI;IAC/E,SAAS,CAAC,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC,GAAG,IAAI;IAoC3C,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,YAAY,EAAE;IAKrC,IAAI,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,YAAY,EAAE;IAKlC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,mBAAmB,EAAE,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,mBAAmB,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,IAAI;IACrI,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,mBAAmB,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,IAAI;IAsDxE,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,iBAAiB,EAAE,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,iBAAiB,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,IAAI;IAC/H,MAAM,CAAC,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,iBAAiB,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,IAAI;IAuCpE,MAAM;CAgBT;AAGD,sBAAc,KAAK,CAAC;IAEhB,SAAgB,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,iBAErD;IAED,SAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,kBAEtD;IAID,SAAgB,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,QAE1E;CAeJ"}

package/Source/ASTInterface/Class.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Class = exports.Decorator = void 0;
+const ts = require("typescript");
+const ASTHelper_1 = require("../ASTHelper");
+const Crawler_1 = require("./Crawler");
+class Decorator extends ASTHelper_1.NamedExpression {
+    constructor(base) {
+        if (typeof base === "string")
+            base = ts.factory.createIdentifier(base);
+        let name;
+        if (ts.isDecorator(base)) {
+            if (ts.isCallExpression(base.expression)) {
+                //Call expression's expression is an identifier
+                name = base.expression.expression;
+            }
+            else {
+                //If not a call expression it's just an identifier (because no brackets)
+                name = base.expression;
+            }
+        }
+        else {
+            name = base;
+            base = ts.factory.createDecorator(base);
+        }
+        super(name);
+        this.base = base;
+    }
+    update() {
+        if (ts.isCallExpression(this.base.expression)) {
+            ts.factory.updateCallExpression(this.base.expression, this.name, this.base.expression.typeArguments, this.base.expression.arguments);
+            return this.base;
+        }
+        else {
+            ts.factory.updateDecorator(this.base, this.name);
+            return this.base;
+        }
+    }
+}
+exports.Decorator = Decorator;
+class Class extends ASTHelper_1.NamedExpression {
+    constructor(base) {
+        if (typeof base === "string")
+            base = ts.factory.createIdentifier(base);
+        super(ts.isIdentifier(base) ? base : base.name);
+        this.modifiers = [];
+        this.decorators = [];
+        this.implements = [];
+        this.members = [];
+        this.typeParams = [];
+        if (ts.isClassDeclaration(base)) {
+            this.base = base;
+            if (this.base.heritageClauses) {
+                for (var clause of this.base.heritageClauses) {
+                    if (clause.token == ts.SyntaxKind.ExtendsKeyword) {
+                        this.extends = clause;
+                    }
+                    else {
+                        this.implements.push(clause);
+                    }
+                }
+            }
+            this.members = Array.from(this.base.members);
+            this.decorators = Class.getDecorators(this.base).map((e) => new Decorator(e));
+            this.modifiers = Class.getModifiers(this.base);
+        }
+        else {
+            this.base = ts.factory.createClassDeclaration(undefined, undefined, undefined, undefined, []);
+        }
+    }
+    hasExtends() {
+        return !!this.extends;
+    }
+    setExtends(extend) {
+        this.extends = ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [extend]);
+    }
+    unshiftDecorator(...dec) {
+        this.decorators.unshift(...dec);
+        return this;
+    }
+    pushDecorator(...dec) {
+        this.decorators.push(...dec);
+        return this;
+    }
+    decorator(identifier, cb) {
+        let name;
+        if (typeof identifier === "function") {
+            cb = identifier;
+            name = null;
+        }
+        else {
+            name = (typeof identifier === "string") ? identifier : identifier.text;
+        }
+        for (let i = 0; i < this.decorators.length; i++) {
+            let decorator = this.decorators[i];
+            if (name) {
+                let decoratorName = decorator.name.text;
+                if (decoratorName != name) {
+                    continue;
+                }
+            }
+            let newDec = cb(decorator);
+            if (newDec) {
+                this.decorators.splice(i, 1, newDec);
+            }
+            else {
+                this.decorators.splice(i, 1);
+            }
+            return this;
+        }
+        if (name) {
+            let newDec = cb(null);
+            if (newDec) {
+                this.decorators.push(newDec);
+            }
+        }
+        return this;
+    }
+    unshift(...members) {
+        this.members.unshift(...members);
+        return this;
+    }
+    push(...members) {
+        this.members.push(...members);
+        return this;
+    }
+    property(identifier, cb) {
+        let name;
+        if (typeof identifier === "function") {
+            cb = identifier;
+            name = null;
+        }
+        else {
+            if (typeof identifier === "string") {
+                name = identifier;
+            }
+            else if (ts.isIdentifier(identifier)) {
+                name = identifier.text;
+            }
+            else {
+                name = identifier.name.getText();
+            }
+        }
+        for (let i = 0; i < this.members.length; i++) {
+            let property = this.members[i];
+            if (!ts.isPropertyDeclaration(property)) {
+                continue;
+            }
+            if (name) {
+                let nameTag = property.name;
+                let propertyName;
+                if (ts.isIdentifier(nameTag)) {
+                    propertyName = nameTag.text;
+                }
+                else {
+                    propertyName = nameTag.getText();
+                }
+                if (propertyName != name) {
+                    continue;
+                }
+            }
+            let newProp = cb(property);
+            if (newProp) {
+                this.members.splice(i, 1, newProp);
+            }
+            else {
+                this.members.splice(i, 1);
+            }
+            return this;
+        }
+        if (name) {
+            let newDec = cb(null);
+            if (newDec) {
+                this.members.push(newDec);
+            }
+        }
+        return this;
+    }
+    method(identifier, cb) {
+        let name;
+        if (typeof identifier === "function") {
+            cb = identifier;
+            name = null;
+        }
+        else {
+            name = (typeof identifier === "string") ? identifier : ts.isIdentifier(identifier) ? identifier.text : identifier.name.getText();
+        }
+        for (let i = 0; i < this.members.length; i++) {
+            let property = this.members[i];
+            if (!ts.isMethodDeclaration(property)) {
+                continue;
+            }
+            if (name) {
+                let propertyName = property.name.getText();
+                if (propertyName != name) {
+                    continue;
+                }
+            }
+            let newProp = cb(property);
+            if (newProp) {
+                this.members.splice(i, 1, newProp);
+            }
+            else {
+                this.members.splice(i, 1);
+            }
+            return this;
+        }
+        if (name) {
+            let newDec = cb(null);
+            if (newDec) {
+                this.members.push(newDec);
+            }
+        }
+        return this;
+    }
+    update() {
+        if (ts.isClassDeclaration(this.base)) {
+            return ts.factory.updateClassDeclaration(this.base, [...this.modifiers, ...this.decorators.map((e) => e.update())], this.name, this.typeParams, [...(this.extends ? [this.extends] : []), ...this.implements], this.members);
+        }
+        else {
+            return ts.factory.updateClassExpression(this.base, [...this.modifiers, ...this.decorators.map((e) => e.update())], this.name, this.typeParams, [...(this.extends ? [this.extends] : []), ...this.implements], this.members);
+        }
+    }
+}
+exports.Class = Class;
+(function (Class) {
+    function getModifiers(node) {
+        var _a, _b;
+        return ([...((_b = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.filter((m) => m.kind != ts.SyntaxKind.Decorator)) !== null && _b !== void 0 ? _b : [])]);
+    }
+    Class.getModifiers = getModifiers;
+    function getDecorators(node) {
+        var _a, _b;
+        return ([...((_b = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.filter((m) => m.kind == ts.SyntaxKind.Decorator)) !== null && _b !== void 0 ? _b : [])]);
+    }
+    Class.getDecorators = getDecorators;
+    let foos = [];
+    function onClass(repl) {
+        foos.push(repl);
+    }
+    Class.onClass = onClass;
+    Crawler_1.Crawler.Register((node) => {
+        return ts.isClassExpression(node) || ts.isClassDeclaration(node);
+    }, (node) => {
+        let val = new Class(node);
+        for (let foo of foos) {
+            let result = foo(val);
+            if (!(result instanceof Class)) {
+                return result;
+            }
+            val = result;
+        }
+        return val.update();
+    });
+})(Class || (exports.Class = Class = {}));
+//# sourceMappingURL=Class.js.map

package/Source/ASTInterface/Crawler.d.ts

@@ -0,0 +1,8 @@
+import * as ts from "typescript";
+export declare module Crawler {
+    function Register(checker: (node: ts.Node) => boolean, replacer: (node: ts.Node) => (ts.Node | ts.Node[])): void;
+    function setContext(newContext: ts.TransformationContext): void;
+    function getContext(): ts.TransformationContext;
+    function Crawl(start: ts.Node, callback?: (node: ts.Node) => (ts.Node | ts.Node[])): ts.Node;
+}
+//# sourceMappingURL=Crawler.d.ts.map

package/Source/ASTInterface/Crawler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Crawler.d.ts","sourceRoot":"","sources":["Crawler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC,sBAAc,OAAO,CAAC;IAGlB,SAAgB,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAG,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,QAE3G;IAED,SAAgB,UAAU,CAAC,UAAU,EAAE,EAAE,CAAC,qBAAqB,QAG9D;IAED,SAAgB,UAAU,6BAEzB;IAED,SAAgB,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAI,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,WA4BvF;CAEJ"}

package/Source/ASTInterface/Crawler.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crawler = void 0;
+const ts = require("typescript");
+const ASTHelper_js_1 = require("../ASTHelper.js");
+var Crawler;
+(function (Crawler) {
+    let foos = new Map();
+    let context;
+    function Register(checker, replacer) {
+        foos.set(checker, replacer);
+    }
+    Crawler.Register = Register;
+    function setContext(newContext) {
+        context = newContext;
+        (0, ASTHelper_js_1.setContext)(context);
+    }
+    Crawler.setContext = setContext;
+    function getContext() {
+        return context;
+    }
+    Crawler.getContext = getContext;
+    function Crawl(start, callback) {
+        let crawlArray = (array) => {
+            for (let i = 0; i < array.length; i++) {
+                array[i] = ts.visitEachChild(array[i], crawl, context);
+            }
+            array = array.flat(1);
+            return array;
+        };
+        let crawl = (node) => {
+            for (let [check, value] of foos.entries()) {
+                let result = node;
+                if (check(node))
+                    result = value(node);
+                //If we get given a bunch of nodes, we should visit each one individually and return.
+                if (Array.isArray(result)) {
+                    return crawlArray(result);
+                }
+                node = result;
+            }
+            let result = node;
+            if (callback) {
+                result = callback(node);
+            }
+            if (Array.isArray(result)) {
+                return crawlArray(result);
+            }
+            return ts.visitEachChild(result, crawl, context);
+        };
+        return ts.visitEachChild(start, crawl, context);
+    }
+    Crawler.Crawl = Crawl;
+})(Crawler || (exports.Crawler = Crawler = {}));
+//# sourceMappingURL=Crawler.js.map

package/Source/ASTInterface/Tokens.d.ts

@@ -0,0 +1,78 @@
+import * as ts from "typescript";
+export declare const ArithmeticSymbols: {
+    "+": ts.SyntaxKind;
+    "\u2013": ts.SyntaxKind;
+    "*": ts.SyntaxKind;
+    "/": ts.SyntaxKind;
+    "%": ts.SyntaxKind;
+    "++": ts.SyntaxKind;
+};
+export declare const ComparisonOperators: {
+    "==": ts.SyntaxKind;
+    "===": ts.SyntaxKind;
+    "!=": ts.SyntaxKind;
+    "!==": ts.SyntaxKind;
+    ">": ts.SyntaxKind;
+    ">=": ts.SyntaxKind;
+    "<": ts.SyntaxKind;
+    "<=": ts.SyntaxKind;
+};
+export declare const BitwiseOperators: {
+    "&": ts.SyntaxKind;
+    "|": ts.SyntaxKind;
+    "^": ts.SyntaxKind;
+    "~": ts.SyntaxKind;
+    "<<": ts.SyntaxKind;
+    ">>": ts.SyntaxKind;
+    ">>>": ts.SyntaxKind;
+};
+export declare const LogicalOperators: {
+    "&&": ts.SyntaxKind;
+    "||": ts.SyntaxKind;
+    "!": ts.SyntaxKind;
+};
+export declare const AssignmentSymbols: {
+    "=": ts.SyntaxKind;
+    "+=": ts.SyntaxKind;
+    "-=": ts.SyntaxKind;
+    "*=": ts.SyntaxKind;
+    "/=": ts.SyntaxKind;
+    "%=": ts.SyntaxKind;
+};
+export declare const OtherSymbols: {
+    ",": ts.SyntaxKind;
+};
+export declare const AnyBinarySymbols: {
+    ",": ts.SyntaxKind;
+    "=": ts.SyntaxKind;
+    "+=": ts.SyntaxKind;
+    "-=": ts.SyntaxKind;
+    "*=": ts.SyntaxKind;
+    "/=": ts.SyntaxKind;
+    "%=": ts.SyntaxKind;
+    "&&": ts.SyntaxKind;
+    "||": ts.SyntaxKind;
+    "!": ts.SyntaxKind;
+    "&": ts.SyntaxKind;
+    "|": ts.SyntaxKind;
+    "^": ts.SyntaxKind;
+    "~": ts.SyntaxKind;
+    "<<": ts.SyntaxKind;
+    ">>": ts.SyntaxKind;
+    ">>>": ts.SyntaxKind;
+    "==": ts.SyntaxKind;
+    "===": ts.SyntaxKind;
+    "!=": ts.SyntaxKind;
+    "!==": ts.SyntaxKind;
+    ">": ts.SyntaxKind;
+    ">=": ts.SyntaxKind;
+    "<": ts.SyntaxKind;
+    "<=": ts.SyntaxKind;
+    "+": ts.SyntaxKind;
+    "\u2013": ts.SyntaxKind;
+    "*": ts.SyntaxKind;
+    "/": ts.SyntaxKind;
+    "%": ts.SyntaxKind;
+    "++": ts.SyntaxKind;
+};
+//# sourceMappingURL=Tokens.d.ts.map

package/Source/ASTInterface/Tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tokens.d.ts","sourceRoot":"","sources":["Tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,eAAO,MAAM,iBAAiB;;;;;;;CAO7B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;CAS/B,CAAC;AAGF,eAAO,MAAM,gBAAgB;;;;;;;;CAQ5B,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;CAI5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;CAO7B,CAAC;AAEF,eAAO,MAAM,YAAY;;CAExB,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkI,CAAC"}

package/Source/ASTInterface/Tokens.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyBinarySymbols = exports.OtherSymbols = exports.AssignmentSymbols = exports.LogicalOperators = exports.BitwiseOperators = exports.ComparisonOperators = exports.ArithmeticSymbols = void 0;
+const ts = require("typescript");
+exports.ArithmeticSymbols = {
+    "+": ts.SyntaxKind.PlusToken,
+    "–": ts.SyntaxKind.MinusToken,
+    "*": ts.SyntaxKind.AsteriskToken,
+    "/": ts.SyntaxKind.SlashToken,
+    "%": ts.SyntaxKind.PercentToken,
+    "++": ts.SyntaxKind.PlusPlusToken,
+};
+exports.ComparisonOperators = {
+    "==": ts.SyntaxKind.EqualsEqualsToken,
+    "===": ts.SyntaxKind.EqualsEqualsToken,
+    "!=": ts.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    ">": ts.SyntaxKind.GreaterThanToken,
+    ">=": ts.SyntaxKind.GreaterThanEqualsToken,
+    "<": ts.SyntaxKind.LessThanToken,
+    "<=": ts.SyntaxKind.LessThanEqualsToken,
+};
+exports.BitwiseOperators = {
+    "&": ts.SyntaxKind.AmpersandToken,
+    "|": ts.SyntaxKind.BarToken,
+    "^": ts.SyntaxKind.CaretToken,
+    "~": ts.SyntaxKind.TildeToken,
+    "<<": ts.SyntaxKind.LessThanLessThanToken,
+    ">>": ts.SyntaxKind.GreaterThanGreaterThanToken,
+    ">>>": ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken,
+};
+exports.LogicalOperators = {
+    "&&": ts.SyntaxKind.AmpersandAmpersandToken,
+    "||": ts.SyntaxKind.BarBarToken,
+    "!": ts.SyntaxKind.ExclamationToken
+};
+exports.AssignmentSymbols = {
+    "=": ts.SyntaxKind.EqualsToken,
+    "+=": ts.SyntaxKind.PlusEqualsToken,
+    "-=": ts.SyntaxKind.MinusEqualsToken,
+    "*=": ts.SyntaxKind.AsteriskEqualsToken,
+    "/=": ts.SyntaxKind.SlashEqualsToken,
+    "%=": ts.SyntaxKind.PercentEqualsToken
+};
+exports.OtherSymbols = {
+    ",": ts.SyntaxKind.CommaToken
+};
+exports.AnyBinarySymbols = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, exports.ArithmeticSymbols), exports.ComparisonOperators), exports.BitwiseOperators), exports.LogicalOperators), exports.AssignmentSymbols), exports.OtherSymbols);
+//# sourceMappingURL=Tokens.js.map

package/Source/ASTSearcher.d.ts

@@ -0,0 +1,20 @@
+import * as ts from "typescript";
+declare class Searcher<NodeType extends ts.Node = ts.Expression> {
+    exp: Expression<NodeType>;
+    constructor(exp: Expression<NodeType>);
+    BINARY(lhs: ((node: ts.Node) => boolean) | undefined, op: string | undefined | ((node: ts.Node) => boolean), rhs: ((node: ts.Node) => boolean) | undefined): boolean;
+}
+declare class Expression<NodeType extends ts.Node = ts.Expression> {
+    ast: NodeType;
+    MATCH: Searcher<NodeType>;
+    constructor(ast: NodeType);
+}
+export declare function FROM<NodeType extends ts.Node>(node: NodeType): Expression<NodeType>;
+export declare function HAS_IN_STATEMENT(node: ts.Node, cb: ((node: ts.Node) => boolean)): boolean;
+export declare function HAS_IN_STATEMENT(cb: ((node: ts.Node) => boolean)): (arg: ts.Node) => boolean;
+export declare function FIND_IN_STATEMENT<NodeType = ts.Node>(node: ts.Node, cb: ((node: ts.Node) => boolean)): NodeType | null;
+export declare function FIND_IN_STATEMENT<NodeType = ts.Node>(cb: ((node: ts.Node) => boolean)): (arg: ts.Node) => NodeType | null;
+export declare function HAS_ID_IN_STATEMENT(node: ts.Node, id: string | ts.Identifier): boolean;
+export declare function HAS_ID_IN_STATEMENT(id: string | ts.Identifier): (node: ts.Node) => boolean;
+export {};
+//# sourceMappingURL=ASTSearcher.d.ts.map

package/Source/ASTSearcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ASTSearcher.d.ts","sourceRoot":"","sources":["ASTSearcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAMjC,cAAM,QAAQ,CAAC,QAAQ,SAAS,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU;IACnD,GAAG,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;gBAEd,GAAG,EAAE,UAAU,CAAC,QAAQ,CAAC;IAIrC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,SAAS;CAoB7J;AAED,cAAM,UAAU,CAAC,QAAQ,SAAS,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU;IACrD,GAAG,EAAG,QAAQ,CAAC;IAEf,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAEd,GAAG,EAAE,QAAQ;CAI5B;AAED,wBAAgB,IAAI,CAAC,QAAQ,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,wBAE5D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,OAAO,CAAC;AAC3F,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC;AA2B9F,wBAAgB,iBAAiB,CAAC,QAAQ,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,QAAQ,GAAG,IAAI,CAAC;AACxH,wBAAgB,iBAAiB,CAAC,QAAQ,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,KAAK,QAAQ,GAAG,IAAI,CAAC;AA6B3H,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,OAAO,CAAC;AACxF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAAC"}

package/Source/ASTSearcher.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HAS_ID_IN_STATEMENT = exports.FIND_IN_STATEMENT = exports.HAS_IN_STATEMENT = exports.FROM = void 0;
+const ts = require("typescript");
+const Tokens_1 = require("./ASTInterface/Tokens");
+const Crawler_1 = require("./ASTInterface/Crawler");
+class Searcher {
+    constructor(exp) {
+        this.exp = exp;
+    }
+    BINARY(lhs, op, rhs) {
+        if (!ts.isBinaryExpression(this.exp.ast)) {
+            return false;
+        }
+        let bin = this.exp.ast;
+        if (lhs) {
+            if (!lhs(bin.left))
+                return false;
+        }
+        if (typeof op === "string") {
+            let kind = Tokens_1.AnyBinarySymbols[op];
+            if (!kind)
+                throw new Error(`Symbol ${op} doesn't exist in typescript`);
+            if (bin.operatorToken.kind != kind)
+                return false;
+        }
+        else if (op) {
+            if (!op(bin.operatorToken))
+                return false;
+        }
+        if (rhs) {
+            if (!rhs(bin.right))
+                return false;
+        }
+        return true;
+    }
+}
+class Expression {
+    constructor(ast) {
+        this.ast = ast;
+        this.MATCH = new Searcher(this);
+    }
+}
+function FROM(node) {
+    return new Expression(node);
+}
+exports.FROM = FROM;
+function HAS_IN_STATEMENT(node, cb) {
+    if (typeof node === "function") {
+        cb = node;
+        node = undefined;
+    }
+    if (node) {
+        let result = false;
+        let context = Crawler_1.Crawler.getContext();
+        let search = (node) => {
+            if (cb(node)) {
+                result = true;
+                return node;
+            }
+            if (ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassExpression(node)
+                || ts.isFunctionExpression(node)) {
+                return node;
+            }
+            return ts.visitEachChild(node, search, context);
+        };
+        ts.visitEachChild(node, search, context);
+        return result;
+    }
+    else {
+        return (arg) => HAS_IN_STATEMENT(arg, cb);
+    }
+}
+exports.HAS_IN_STATEMENT = HAS_IN_STATEMENT;
+function FIND_IN_STATEMENT(node, cb) {
+    if (typeof node === "function") {
+        cb = node;
+        node = undefined;
+    }
+    if (node) {
+        let result = null;
+        let context = Crawler_1.Crawler.getContext();
+        let search = (node) => {
+            if (cb(node)) {
+                result = node;
+                return node;
+            }
+            if (ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassExpression(node)
+                || ts.isFunctionExpression(node)) {
+                return node;
+            }
+            return ts.visitEachChild(node, search, context);
+        };
+        ts.visitEachChild(node, search, context);
+        return result;
+    }
+    else {
+        return (arg) => FIND_IN_STATEMENT(arg, cb);
+    }
+}
+exports.FIND_IN_STATEMENT = FIND_IN_STATEMENT;
+function HAS_ID_IN_STATEMENT(node, id) {
+    if (typeof node === "string" || ts.isIdentifier(node)) {
+        id = typeof node === "string" ? node : node.text;
+        node = undefined;
+    }
+    let search = (node) => {
+        return ts.isIdentifier(node) && node.text == id;
+    };
+    if (node) {
+        return HAS_IN_STATEMENT(node, search);
+    }
+    return HAS_IN_STATEMENT(search);
+}
+exports.HAS_ID_IN_STATEMENT = HAS_ID_IN_STATEMENT;
+//# sourceMappingURL=ASTSearcher.js.map

package/Source/ASTTraverser.d.ts

@@ -0,0 +1,10 @@
+import * as ts from "typescript";
+export declare function ENTER(node: ts.Node): () => Generator<undefined, void, unknown>;
+export declare function EXIT(): void;
+export declare function SKIP(): void;
+export declare function ITER_PROPERTIES(): void;
+export declare function ITER_BLOCKS(): void;
+export declare function ITER_EXPRESSIONS(): void;
+export declare function REPLACE(): void;
+export declare function NEXT(): void;
+//# sourceMappingURL=ASTTraverser.d.ts.map

package/Source/ASTTraverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ASTTraverser.d.ts","sourceRoot":"","sources":["ASTTraverser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,wBAAgB,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,6CAKlC;AAED,wBAAgB,IAAI,SAEnB;AAED,wBAAgB,IAAI,SAEnB;AAED,wBAAgB,eAAe,SAE9B;AAED,wBAAgB,WAAW,SAE1B;AAED,wBAAgB,gBAAgB,SAE/B;AAED,wBAAgB,OAAO,SAEtB;AAED,wBAAgB,IAAI,SAEnB"}