@dagger.io/dagger 0.10.0 → 0.10.2

package/dist/introspector/scanner/abtractions/method.d.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+import { Arguments } from "./argument.js";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { FunctionTypedef, TypeDef } from "../typeDefs.js";
+export type Methods = {
+    [name: string]: Method;
+};
+/**
+ * Method is an abstraction of a function or method.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Method {
+    private checker;
+    private method;
+    private symbol;
+    private signature;
+    private decorator;
+    /**
+     * Create a new Method instance.
+     *
+     * @param checker Checker to use to introspect the method.
+     * @param method The method to introspect.
+     *
+     * @throws UnknownDaggerError If the method doesn't have any symbol.
+     * @throws UnknownDaggerError If the method doesn't have any signature.
+     */
+    constructor(checker: ts.TypeChecker, method: ts.MethodDeclaration);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the alias of the method if it has one.
+     */
+    get alias(): string | undefined;
+    get arguments(): Arguments;
+    /**
+     * Return the type of the return value in a Dagger TypeDef format.
+     */
+    get returnType(): TypeDef<TypeDefKind>;
+    get typeDef(): FunctionTypedef;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        arguments: Arguments;
+        returnType: TypeDef<TypeDefKind>;
+    };
+    getArgOrder(): string[];
+}
+//# sourceMappingURL=method.d.ts.map

package/dist/introspector/scanner/abtractions/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/method.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AAGnD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAsB,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAI7E,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAEhD;;;;;GAKG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,SAAS,CAA0B;IAE3C;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC,iBAAiB;IAiCjE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAa9B;IAED,IAAI,SAAS,IAAI,SAAS,CAQzB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAIrC;IAED,IAAI,OAAO,IAAI,eAAe,CAe7B;IAED,MAAM;;;;;;;IAUN,WAAW,IAAI,MAAM,EAAE;CAGxB"}

package/dist/introspector/scanner/abtractions/method.js

@@ -0,0 +1,105 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { Argument } from "./argument.js";
+import { serializeType } from "../serialize.js";
+import { typeNameToTypedef } from "../utils.js";
+const METHOD_DECORATOR = "func";
+/**
+ * Method is an abstraction of a function or method.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Method {
+    checker;
+    method;
+    symbol;
+    signature;
+    decorator;
+    /**
+     * Create a new Method instance.
+     *
+     * @param checker Checker to use to introspect the method.
+     * @param method The method to introspect.
+     *
+     * @throws UnknownDaggerError If the method doesn't have any symbol.
+     * @throws UnknownDaggerError If the method doesn't have any signature.
+     */
+    constructor(checker, method) {
+        this.checker = checker;
+        this.method = method;
+        const methodSymbol = checker.getSymbolAtLocation(method.name);
+        if (!methodSymbol) {
+            throw new UnknownDaggerError(`could not get method symbol: ${method.name.getText()}`, {});
+        }
+        this.symbol = methodSymbol;
+        const signature = checker.getSignatureFromDeclaration(method);
+        if (!signature) {
+            throw new UnknownDaggerError(`could not get method signature: ${method.name.getText()}`, {});
+        }
+        this.signature = signature;
+        this.decorator = ts.getDecorators(method)?.find((d) => {
+            if (ts.isCallExpression(d.expression)) {
+                return d.expression.expression.getText() === METHOD_DECORATOR;
+            }
+            return false;
+        });
+    }
+    get name() {
+        return this.symbol.getName();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    /**
+     * Return the alias of the method if it has one.
+     */
+    get alias() {
+        if (!this.decorator) {
+            return undefined;
+        }
+        const expression = this.decorator.expression;
+        const aliasArg = expression.arguments[0];
+        if (!aliasArg) {
+            return undefined;
+        }
+        return JSON.parse(aliasArg.getText().replace(/'/g, '"'));
+    }
+    get arguments() {
+        return this.signature.parameters.reduce((acc, param) => {
+            const argument = new Argument(this.checker, param);
+            acc[argument.name] = argument;
+            return acc;
+        }, {});
+    }
+    /**
+     * Return the type of the return value in a Dagger TypeDef format.
+     */
+    get returnType() {
+        return typeNameToTypedef(serializeType(this.checker, this.signature.getReturnType()));
+    }
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            args: Object.entries(this.arguments).reduce((acc, [name, arg]) => {
+                acc[name] = arg.typeDef;
+                return acc;
+            }, {}),
+            returnType: this.returnType,
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            arguments: this.arguments,
+            returnType: this.returnType,
+        };
+    }
+    getArgOrder() {
+        return Object.keys(this.arguments);
+    }
+}

package/dist/introspector/scanner/abtractions/module.d.ts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { DaggerObject, DaggerObjects } from "./object.js";
+export declare class DaggerModule {
+    private checker;
+    private readonly files;
+    name: string;
+    constructor(checker: ts.TypeChecker, name: string | undefined, files: readonly ts.SourceFile[]);
+    get objects(): DaggerObjects;
+    get description(): string | undefined;
+    toJSON(): {
+        name: string;
+        description: string | undefined;
+        objects: {
+            [name: string]: DaggerObject;
+        };
+    };
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/introspector/scanner/abtractions/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGzD,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IAEhC,IAAI,EAAE,MAAM,CAAA;gBAGjB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,oBAAK,EACT,KAAK,EAAE,SAAS,EAAE,CAAC,UAAU,EAAE;IAOjC,IAAI,OAAO,IAAI,aAAa,CAc3B;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAgCpC;IAED,MAAM;;;;;;;CAcP"}

package/dist/introspector/scanner/abtractions/module.js

@@ -0,0 +1,59 @@
+import ts from "typescript";
+import { DaggerObject } from "./object.js";
+import { isObject, toPascalCase } from "../utils.js";
+export class DaggerModule {
+    checker;
+    files;
+    name;
+    constructor(checker, name = "", files) {
+        this.checker = checker;
+        this.files = files.filter((file) => !file.isDeclarationFile);
+        this.name = toPascalCase(name);
+    }
+    get objects() {
+        const objects = {};
+        for (const file of this.files) {
+            ts.forEachChild(file, (node) => {
+                if (ts.isClassDeclaration(node) && isObject(node)) {
+                    const object = new DaggerObject(this.checker, file, node);
+                    objects[object.name] = object;
+                }
+            });
+        }
+        return objects;
+    }
+    get description() {
+        const mainObject = Object.values(this.objects).find((object) => object.name === this.name);
+        if (!mainObject) {
+            return undefined;
+        }
+        const file = mainObject.file;
+        const topLevelStatement = file.statements[0];
+        if (!topLevelStatement) {
+            return undefined;
+        }
+        // Get the range of the top level comment
+        const topLevelCommentRanges = ts.getLeadingCommentRanges(file.getFullText(), topLevelStatement.pos);
+        if (!topLevelCommentRanges || topLevelCommentRanges.length === 0) {
+            return undefined;
+        }
+        const topLevelCommentRange = topLevelCommentRanges[0];
+        return file
+            .getFullText()
+            .substring(topLevelCommentRange.pos, topLevelCommentRange.end)
+            .split("\n")
+            .slice(1, -1) // Remove start and ending comments characters `/** */`
+            .map((line) => line.replace("*", "").trim()) // Remove leading * and spaces
+            .join("\n");
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            objects: Object.entries(this.objects).reduce((acc, [name, object]) => {
+                acc[name] = object;
+                return acc;
+            }, {}),
+        };
+    }
+}

package/dist/introspector/scanner/abtractions/object.d.ts

@@ -0,0 +1,37 @@
+import ts from "typescript";
+import { Constructor } from "./constructor.js";
+import { Methods } from "./method.js";
+import { Properties } from "./property.js";
+import { ClassTypeDef } from "../typeDefs.js";
+export type DaggerObjects = {
+    [name: string]: DaggerObject;
+};
+export declare class DaggerObject {
+    private checker;
+    private class;
+    private symbol;
+    file: ts.SourceFile;
+    /**
+     *
+     * @param checker The checker to use to introspect the class.
+     * @param classDeclaration The class to introspect.
+     *
+     * @throws UnknownDaggerError If the class doesn't have a name.
+     * @throws UnknownDaggerError If the class doesn't have a symbol.
+     */
+    constructor(checker: ts.TypeChecker, file: ts.SourceFile, classDeclaration: ts.ClassDeclaration);
+    get name(): string;
+    get description(): string;
+    get _constructor(): Constructor | undefined;
+    get methods(): Methods;
+    get properties(): Properties;
+    get typeDef(): ClassTypeDef;
+    toJSON(): {
+        name: string;
+        description: string;
+        constructor: Constructor | undefined;
+        methods: Methods;
+        properties: Properties;
+    };
+}
+//# sourceMappingURL=object.d.ts.map

package/dist/introspector/scanner/abtractions/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,EAAU,OAAO,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,YAAY,EAAiC,MAAM,gBAAgB,CAAA;AAG5E,MAAM,MAAM,aAAa,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAA;AAE5D,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,MAAM,CAAW;IAElB,IAAI,EAAE,EAAE,CAAC,UAAU,CAAA;IAE1B;;;;;;;OAOG;gBAED,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,gBAAgB,EAAE,EAAE,CAAC,gBAAgB;IAwBvC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED,IAAI,YAAY,IAAI,WAAW,GAAG,SAAS,CAe1C;IAED,IAAI,OAAO,IAAI,OAAO,CAUrB;IAED,IAAI,UAAU,IAAI,UAAU,CAY3B;IAID,IAAI,OAAO,IAAI,YAAY,CAoB1B;IAED,MAAM;;;;;;;CASP"}

package/dist/introspector/scanner/abtractions/object.js

@@ -0,0 +1,94 @@
+import ts from "typescript";
+import { Constructor } from "./constructor.js";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { Method } from "./method.js";
+import { Property } from "./property.js";
+import { isFunction } from "../utils.js";
+export class DaggerObject {
+    checker;
+    class;
+    symbol;
+    file;
+    /**
+     *
+     * @param checker The checker to use to introspect the class.
+     * @param classDeclaration The class to introspect.
+     *
+     * @throws UnknownDaggerError If the class doesn't have a name.
+     * @throws UnknownDaggerError If the class doesn't have a symbol.
+     */
+    constructor(checker, file, classDeclaration) {
+        this.checker = checker;
+        this.class = classDeclaration;
+        this.file = file;
+        if (!classDeclaration.name) {
+            throw new UnknownDaggerError(`could not introspect class: ${classDeclaration}`, {});
+        }
+        const classSymbol = checker.getSymbolAtLocation(classDeclaration.name);
+        if (!classSymbol) {
+            throw new UnknownDaggerError(`could not get class symbol: ${classDeclaration.name.getText()}`, {});
+        }
+        this.symbol = classSymbol;
+    }
+    get name() {
+        return this.symbol.getName();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    get _constructor() {
+        const constructor = this.class.members.find((member) => {
+            if (ts.isConstructorDeclaration(member)) {
+                return true;
+            }
+        });
+        if (!constructor) {
+            return undefined;
+        }
+        return new Constructor(this.checker, constructor);
+    }
+    get methods() {
+        return this.class.members
+            .filter((member) => ts.isMethodDeclaration(member) && isFunction(member))
+            .reduce((acc, member) => {
+            const method = new Method(this.checker, member);
+            acc[method.alias ?? method.name] = method;
+            return acc;
+        }, {});
+    }
+    get properties() {
+        return this.class.members
+            .filter((member) => ts.isPropertyDeclaration(member))
+            .reduce((acc, member) => {
+            const property = new Property(this.checker, member);
+            acc[property.alias ?? property.name] = property;
+            return acc;
+        }, {});
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            constructor: this._constructor?.typeDef,
+            methods: Object.entries(this.methods).reduce((acc, [name, method]) => {
+                acc[name] = method.typeDef;
+                return acc;
+            }, {}),
+            fields: Object.entries(this.properties).reduce((acc, [name, property]) => {
+                acc[name] = property.typeDef;
+                return acc;
+            }, {}),
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            constructor: this._constructor,
+            methods: this.methods,
+            properties: this.properties,
+        };
+    }
+}

package/dist/introspector/scanner/abtractions/property.d.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+import { FieldTypeDef, TypeDef } from "../typeDefs.js";
+import { TypeDefKind } from "../../../api/client.gen.js";
+export type Properties = {
+    [name: string]: Property;
+};
+/**
+ * Property is an abstraction of a class property.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Property {
+    private symbol;
+    private checker;
+    private property;
+    private decorator;
+    /**
+     *
+     * @param checker Checker to use to introspect the property.
+     * @param property The property to introspect.
+     *
+     * @throws UnknownDaggerError If the property doesn't have any symbol.
+     */
+    constructor(checker: ts.TypeChecker, property: ts.PropertyDeclaration);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the alias of the property if it has one.
+     */
+    get alias(): string | undefined;
+    /**
+     * Return the type of the property in a Dagger TypeDef format.
+     */
+    get type(): TypeDef<TypeDefKind>;
+    get isExposed(): boolean;
+    get typeDef(): FieldTypeDef;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        type: TypeDef<TypeDefKind>;
+        isExposed: boolean;
+    };
+}
+//# sourceMappingURL=property.d.ts.map

package/dist/introspector/scanner/abtractions/property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/property.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAK3B,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAIxD,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AAErD;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAwB;IAExC,OAAO,CAAC,SAAS,CAA0B;IAE3C;;;;;;OAMG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC,mBAAmB;IAuBrE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAa9B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAgB/B;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAID,IAAI,OAAO,IAAI,YAAY,CAQ1B;IAED,MAAM;;;;;;;CASP"}

package/dist/introspector/scanner/abtractions/property.js

@@ -0,0 +1,93 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { serializeType } from "../serialize.js";
+import { typeNameToTypedef } from "../utils.js";
+const PROPERTY_DECORATOR = "field";
+/**
+ * Property is an abstraction of a class property.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Property {
+    symbol;
+    checker;
+    property;
+    decorator;
+    /**
+     *
+     * @param checker Checker to use to introspect the property.
+     * @param property The property to introspect.
+     *
+     * @throws UnknownDaggerError If the property doesn't have any symbol.
+     */
+    constructor(checker, property) {
+        this.checker = checker;
+        this.property = property;
+        const propertySymbol = checker.getSymbolAtLocation(property.name);
+        if (!propertySymbol) {
+            throw new UnknownDaggerError(`could not get property symbol: ${property.name.getText()}`, {});
+        }
+        this.symbol = propertySymbol;
+        this.decorator = ts.getDecorators(property)?.find((d) => {
+            if (ts.isCallExpression(d.expression)) {
+                return d.expression.expression.getText() === PROPERTY_DECORATOR;
+            }
+            return false;
+        });
+    }
+    get name() {
+        return this.property.name.getText();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    /**
+     * Return the alias of the property if it has one.
+     */
+    get alias() {
+        if (!this.decorator) {
+            return undefined;
+        }
+        const expression = this.decorator.expression;
+        const aliasArg = expression.arguments[0];
+        if (!aliasArg) {
+            return undefined;
+        }
+        return JSON.parse(aliasArg.getText().replace(/'/g, '"'));
+    }
+    /**
+     * Return the type of the property in a Dagger TypeDef format.
+     */
+    get type() {
+        if (!this.symbol.valueDeclaration) {
+            throw new UnknownDaggerError("could not find symbol value declaration", {});
+        }
+        const type = this.checker.getTypeOfSymbolAtLocation(this.symbol, this.symbol.valueDeclaration);
+        const typeName = serializeType(this.checker, type);
+        return typeNameToTypedef(typeName);
+    }
+    get isExposed() {
+        return this.decorator !== undefined;
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            typeDef: this.type,
+            isExposed: this.isExposed,
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            type: this.type,
+            isExposed: this.isExposed,
+        };
+    }
+}

package/dist/introspector/scanner/scan.d.ts

@@ -1,4 +1,5 @@
 import { ClassTypeDef, FunctionTypedef } from "./typeDefs.js";
+import { DaggerModule } from "./abtractions/module.js";
 export type ScanResult = {
     module: {
         description?: string;
@@ -21,5 +22,5 @@ export type ScanResult = {
  * @param files List of TypeScript files to introspect.
  * @param moduleName The name of the module to introspect.
  */
-export declare function scan(files: string[], moduleName?: string): ScanResult;
+export declare function scan(files: string[], moduleName?: string): DaggerModule;
 //# sourceMappingURL=scan.d.ts.map

package/dist/introspector/scanner/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAIZ,eAAe,EAChB,MAAM,eAAe,CAAA;AAWtB,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAA;IACzC,SAAS,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE,CAAA;CAC/C,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,SAAK,GAAG,UAAU,CAoCjE"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAA;IACzC,SAAS,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE,CAAA;CAC/C,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,SAAK,GAAG,YAAY,CAUnE"}