@psnext/slingcli 2.4.20260520-2 → 2.4.20260520-4

package/node_modules/ast-types/def/jsx.js

@@ -1,103 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var es7_1 = tslib_1.__importDefault(require("./es7"));
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
-function default_1(fork) {
-    fork.use(es7_1.default);
-    var types = fork.use(types_1.default);
-    var def = types.Type.def;
-    var or = types.Type.or;
-    var defaults = fork.use(shared_1.default).defaults;
-    def("JSXAttribute")
-        .bases("Node")
-        .build("name", "value")
-        .field("name", or(def("JSXIdentifier"), def("JSXNamespacedName")))
-        .field("value", or(def("Literal"), // attr="value"
-    def("JSXExpressionContainer"), // attr={value}
-    null // attr= or just attr
-    ), defaults["null"]);
-    def("JSXIdentifier")
-        .bases("Identifier")
-        .build("name")
-        .field("name", String);
-    def("JSXNamespacedName")
-        .bases("Node")
-        .build("namespace", "name")
-        .field("namespace", def("JSXIdentifier"))
-        .field("name", def("JSXIdentifier"));
-    def("JSXMemberExpression")
-        .bases("MemberExpression")
-        .build("object", "property")
-        .field("object", or(def("JSXIdentifier"), def("JSXMemberExpression")))
-        .field("property", def("JSXIdentifier"))
-        .field("computed", Boolean, defaults.false);
-    var JSXElementName = or(def("JSXIdentifier"), def("JSXNamespacedName"), def("JSXMemberExpression"));
-    def("JSXSpreadAttribute")
-        .bases("Node")
-        .build("argument")
-        .field("argument", def("Expression"));
-    var JSXAttributes = [or(def("JSXAttribute"), def("JSXSpreadAttribute"))];
-    def("JSXExpressionContainer")
-        .bases("Expression")
-        .build("expression")
-        .field("expression", def("Expression"));
-    def("JSXElement")
-        .bases("Expression")
-        .build("openingElement", "closingElement", "children")
-        .field("openingElement", def("JSXOpeningElement"))
-        .field("closingElement", or(def("JSXClosingElement"), null), defaults["null"])
-        .field("children", [or(def("JSXElement"), def("JSXExpressionContainer"), def("JSXFragment"), def("JSXText"), def("Literal") // TODO Esprima should return JSXText instead.
-        )], defaults.emptyArray)
-        .field("name", JSXElementName, function () {
-        // Little-known fact: the `this` object inside a default function
-        // is none other than the partially-built object itself, and any
-        // fields initialized directly from builder function arguments
-        // (like openingElement, closingElement, and children) are
-        // guaranteed to be available.
-        return this.openingElement.name;
-    }, true) // hidden from traversal
-        .field("selfClosing", Boolean, function () {
-        return this.openingElement.selfClosing;
-    }, true) // hidden from traversal
-        .field("attributes", JSXAttributes, function () {
-        return this.openingElement.attributes;
-    }, true); // hidden from traversal
-    def("JSXOpeningElement")
-        .bases("Node") // TODO Does this make sense? Can't really be an JSXElement.
-        .build("name", "attributes", "selfClosing")
-        .field("name", JSXElementName)
-        .field("attributes", JSXAttributes, defaults.emptyArray)
-        .field("selfClosing", Boolean, defaults["false"]);
-    def("JSXClosingElement")
-        .bases("Node") // TODO Same concern.
-        .build("name")
-        .field("name", JSXElementName);
-    def("JSXFragment")
-        .bases("Expression")
-        .build("openingElement", "closingElement", "children")
-        .field("openingElement", def("JSXOpeningFragment"))
-        .field("closingElement", def("JSXClosingFragment"))
-        .field("children", [or(def("JSXElement"), def("JSXExpressionContainer"), def("JSXFragment"), def("JSXText"), def("Literal") // TODO Esprima should return JSXText instead.
-        )], defaults.emptyArray);
-    def("JSXOpeningFragment")
-        .bases("Node") // TODO Same concern.
-        .build();
-    def("JSXClosingFragment")
-        .bases("Node") // TODO Same concern.
-        .build();
-    def("JSXText")
-        .bases("Literal")
-        .build("value")
-        .field("value", String);
-    def("JSXEmptyExpression").bases("Expression").build();
-    // This PR has caused many people issues, but supporting it seems like a
-    // good idea anyway: https://github.com/babel/babel/pull/4988
-    def("JSXSpreadChild")
-        .bases("Expression")
-        .build("expression")
-        .field("expression", def("Expression"));
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/node_modules/ast-types/def/type-annotations.d.ts

@@ -1,7 +0,0 @@
-/**
- * Type annotation defs shared between Flow and TypeScript.
- * These defs could not be defined in ./flow.ts or ./typescript.ts directly
- * because they use the same name.
- */
-import { Fork } from "../types";
-export default function (fork: Fork): void;

package/node_modules/ast-types/def/type-annotations.js

@@ -1,40 +0,0 @@
-"use strict";;
-/**
- * Type annotation defs shared between Flow and TypeScript.
- * These defs could not be defined in ./flow.ts or ./typescript.ts directly
- * because they use the same name.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
-function default_1(fork) {
-    var types = fork.use(types_1.default);
-    var def = types.Type.def;
-    var or = types.Type.or;
-    var defaults = fork.use(shared_1.default).defaults;
-    var TypeAnnotation = or(def("TypeAnnotation"), def("TSTypeAnnotation"), null);
-    var TypeParamDecl = or(def("TypeParameterDeclaration"), def("TSTypeParameterDeclaration"), null);
-    def("Identifier")
-        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
-    def("ObjectPattern")
-        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
-    def("Function")
-        .field("returnType", TypeAnnotation, defaults["null"])
-        .field("typeParameters", TypeParamDecl, defaults["null"]);
-    def("ClassProperty")
-        .build("key", "value", "typeAnnotation", "static")
-        .field("value", or(def("Expression"), null))
-        .field("static", Boolean, defaults["false"])
-        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
-    ["ClassDeclaration",
-        "ClassExpression",
-    ].forEach(function (typeName) {
-        def(typeName)
-            .field("typeParameters", TypeParamDecl, defaults["null"])
-            .field("superTypeParameters", or(def("TypeParameterInstantiation"), def("TSTypeParameterInstantiation"), null), defaults["null"])
-            .field("implements", or([def("ClassImplements")], [def("TSExpressionWithTypeArguments")]), defaults.emptyArray);
-    });
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/node_modules/ast-types/def/typescript.d.ts

@@ -1,2 +0,0 @@
-import { Fork } from "../types";
-export default function (fork: Fork): void;

package/node_modules/ast-types/def/typescript.js

@@ -1,344 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var babel_core_1 = tslib_1.__importDefault(require("./babel-core"));
-var type_annotations_1 = tslib_1.__importDefault(require("./type-annotations"));
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
-function default_1(fork) {
-    // Since TypeScript is parsed by Babylon, include the core Babylon types
-    // but omit the Flow-related types.
-    fork.use(babel_core_1.default);
-    fork.use(type_annotations_1.default);
-    var types = fork.use(types_1.default);
-    var n = types.namedTypes;
-    var def = types.Type.def;
-    var or = types.Type.or;
-    var defaults = fork.use(shared_1.default).defaults;
-    var StringLiteral = types.Type.from(function (value, deep) {
-        if (n.StringLiteral &&
-            n.StringLiteral.check(value, deep)) {
-            return true;
-        }
-        if (n.Literal &&
-            n.Literal.check(value, deep) &&
-            typeof value.value === "string") {
-            return true;
-        }
-        return false;
-    }, "StringLiteral");
-    def("TSType")
-        .bases("Node");
-    var TSEntityName = or(def("Identifier"), def("TSQualifiedName"));
-    def("TSTypeReference")
-        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
-        .build("typeName", "typeParameters")
-        .field("typeName", TSEntityName);
-    // An abstract (non-buildable) base type that provide a commonly-needed
-    // optional .typeParameters field.
-    def("TSHasOptionalTypeParameterInstantiation")
-        .field("typeParameters", or(def("TSTypeParameterInstantiation"), null), defaults["null"]);
-    // An abstract (non-buildable) base type that provide a commonly-needed
-    // optional .typeParameters field.
-    def("TSHasOptionalTypeParameters")
-        .field("typeParameters", or(def("TSTypeParameterDeclaration"), null, void 0), defaults["null"]);
-    // An abstract (non-buildable) base type that provide a commonly-needed
-    // optional .typeAnnotation field.
-    def("TSHasOptionalTypeAnnotation")
-        .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"]);
-    def("TSQualifiedName")
-        .bases("Node")
-        .build("left", "right")
-        .field("left", TSEntityName)
-        .field("right", TSEntityName);
-    def("TSAsExpression")
-        .bases("Expression", "Pattern")
-        .build("expression", "typeAnnotation")
-        .field("expression", def("Expression"))
-        .field("typeAnnotation", def("TSType"))
-        .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
-    def("TSNonNullExpression")
-        .bases("Expression", "Pattern")
-        .build("expression")
-        .field("expression", def("Expression"));
-    [
-        "TSAnyKeyword",
-        "TSBigIntKeyword",
-        "TSBooleanKeyword",
-        "TSNeverKeyword",
-        "TSNullKeyword",
-        "TSNumberKeyword",
-        "TSObjectKeyword",
-        "TSStringKeyword",
-        "TSSymbolKeyword",
-        "TSUndefinedKeyword",
-        "TSUnknownKeyword",
-        "TSVoidKeyword",
-        "TSThisType",
-    ].forEach(function (keywordType) {
-        def(keywordType)
-            .bases("TSType")
-            .build();
-    });
-    def("TSArrayType")
-        .bases("TSType")
-        .build("elementType")
-        .field("elementType", def("TSType"));
-    def("TSLiteralType")
-        .bases("TSType")
-        .build("literal")
-        .field("literal", or(def("NumericLiteral"), def("StringLiteral"), def("BooleanLiteral"), def("TemplateLiteral"), def("UnaryExpression")));
-    ["TSUnionType",
-        "TSIntersectionType",
-    ].forEach(function (typeName) {
-        def(typeName)
-            .bases("TSType")
-            .build("types")
-            .field("types", [def("TSType")]);
-    });
-    def("TSConditionalType")
-        .bases("TSType")
-        .build("checkType", "extendsType", "trueType", "falseType")
-        .field("checkType", def("TSType"))
-        .field("extendsType", def("TSType"))
-        .field("trueType", def("TSType"))
-        .field("falseType", def("TSType"));
-    def("TSInferType")
-        .bases("TSType")
-        .build("typeParameter")
-        .field("typeParameter", def("TSTypeParameter"));
-    def("TSParenthesizedType")
-        .bases("TSType")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("TSType"));
-    var ParametersType = [or(def("Identifier"), def("RestElement"), def("ArrayPattern"), def("ObjectPattern"))];
-    ["TSFunctionType",
-        "TSConstructorType",
-    ].forEach(function (typeName) {
-        def(typeName)
-            .bases("TSType", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
-            .build("parameters")
-            .field("parameters", ParametersType);
-    });
-    def("TSDeclareFunction")
-        .bases("Declaration", "TSHasOptionalTypeParameters")
-        .build("id", "params", "returnType")
-        .field("declare", Boolean, defaults["false"])
-        .field("async", Boolean, defaults["false"])
-        .field("generator", Boolean, defaults["false"])
-        .field("id", or(def("Identifier"), null), defaults["null"])
-        .field("params", [def("Pattern")])
-        // tSFunctionTypeAnnotationCommon
-        .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
-    null), defaults["null"]);
-    def("TSDeclareMethod")
-        .bases("Declaration", "TSHasOptionalTypeParameters")
-        .build("key", "params", "returnType")
-        .field("async", Boolean, defaults["false"])
-        .field("generator", Boolean, defaults["false"])
-        .field("params", [def("Pattern")])
-        // classMethodOrPropertyCommon
-        .field("abstract", Boolean, defaults["false"])
-        .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
-        .field("static", Boolean, defaults["false"])
-        .field("computed", Boolean, defaults["false"])
-        .field("optional", Boolean, defaults["false"])
-        .field("key", or(def("Identifier"), def("StringLiteral"), def("NumericLiteral"), 
-    // Only allowed if .computed is true.
-    def("Expression")))
-        // classMethodOrDeclareMethodCommon
-        .field("kind", or("get", "set", "method", "constructor"), function getDefault() { return "method"; })
-        .field("access", // Not "accessibility"?
-    or("public", "private", "protected", void 0), defaults["undefined"])
-        .field("decorators", or([def("Decorator")], null), defaults["null"])
-        // tSFunctionTypeAnnotationCommon
-        .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
-    null), defaults["null"]);
-    def("TSMappedType")
-        .bases("TSType")
-        .build("typeParameter", "typeAnnotation")
-        .field("readonly", or(Boolean, "+", "-"), defaults["false"])
-        .field("typeParameter", def("TSTypeParameter"))
-        .field("optional", or(Boolean, "+", "-"), defaults["false"])
-        .field("typeAnnotation", or(def("TSType"), null), defaults["null"]);
-    def("TSTupleType")
-        .bases("TSType")
-        .build("elementTypes")
-        .field("elementTypes", [or(def("TSType"), def("TSNamedTupleMember"))]);
-    def("TSNamedTupleMember")
-        .bases("TSType")
-        .build("label", "elementType", "optional")
-        .field("label", def("Identifier"))
-        .field("optional", Boolean, defaults["false"])
-        .field("elementType", def("TSType"));
-    def("TSRestType")
-        .bases("TSType")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("TSType"));
-    def("TSOptionalType")
-        .bases("TSType")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("TSType"));
-    def("TSIndexedAccessType")
-        .bases("TSType")
-        .build("objectType", "indexType")
-        .field("objectType", def("TSType"))
-        .field("indexType", def("TSType"));
-    def("TSTypeOperator")
-        .bases("TSType")
-        .build("operator")
-        .field("operator", String)
-        .field("typeAnnotation", def("TSType"));
-    def("TSTypeAnnotation")
-        .bases("Node")
-        .build("typeAnnotation")
-        .field("typeAnnotation", or(def("TSType"), def("TSTypeAnnotation")));
-    def("TSIndexSignature")
-        .bases("Declaration", "TSHasOptionalTypeAnnotation")
-        .build("parameters", "typeAnnotation")
-        .field("parameters", [def("Identifier")]) // Length === 1
-        .field("readonly", Boolean, defaults["false"]);
-    def("TSPropertySignature")
-        .bases("Declaration", "TSHasOptionalTypeAnnotation")
-        .build("key", "typeAnnotation", "optional")
-        .field("key", def("Expression"))
-        .field("computed", Boolean, defaults["false"])
-        .field("readonly", Boolean, defaults["false"])
-        .field("optional", Boolean, defaults["false"])
-        .field("initializer", or(def("Expression"), null), defaults["null"]);
-    def("TSMethodSignature")
-        .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
-        .build("key", "parameters", "typeAnnotation")
-        .field("key", def("Expression"))
-        .field("computed", Boolean, defaults["false"])
-        .field("optional", Boolean, defaults["false"])
-        .field("parameters", ParametersType);
-    def("TSTypePredicate")
-        .bases("TSTypeAnnotation", "TSType")
-        .build("parameterName", "typeAnnotation", "asserts")
-        .field("parameterName", or(def("Identifier"), def("TSThisType")))
-        .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"])
-        .field("asserts", Boolean, defaults["false"]);
-    ["TSCallSignatureDeclaration",
-        "TSConstructSignatureDeclaration",
-    ].forEach(function (typeName) {
-        def(typeName)
-            .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
-            .build("parameters", "typeAnnotation")
-            .field("parameters", ParametersType);
-    });
-    def("TSEnumMember")
-        .bases("Node")
-        .build("id", "initializer")
-        .field("id", or(def("Identifier"), StringLiteral))
-        .field("initializer", or(def("Expression"), null), defaults["null"]);
-    def("TSTypeQuery")
-        .bases("TSType")
-        .build("exprName")
-        .field("exprName", or(TSEntityName, def("TSImportType")));
-    // Inferred from Babylon's tsParseTypeMember method.
-    var TSTypeMember = or(def("TSCallSignatureDeclaration"), def("TSConstructSignatureDeclaration"), def("TSIndexSignature"), def("TSMethodSignature"), def("TSPropertySignature"));
-    def("TSTypeLiteral")
-        .bases("TSType")
-        .build("members")
-        .field("members", [TSTypeMember]);
-    def("TSTypeParameter")
-        .bases("Identifier")
-        .build("name", "constraint", "default")
-        .field("name", String)
-        .field("constraint", or(def("TSType"), void 0), defaults["undefined"])
-        .field("default", or(def("TSType"), void 0), defaults["undefined"]);
-    def("TSTypeAssertion")
-        .bases("Expression", "Pattern")
-        .build("typeAnnotation", "expression")
-        .field("typeAnnotation", def("TSType"))
-        .field("expression", def("Expression"))
-        .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
-    def("TSTypeParameterDeclaration")
-        .bases("Declaration")
-        .build("params")
-        .field("params", [def("TSTypeParameter")]);
-    def("TSTypeParameterInstantiation")
-        .bases("Node")
-        .build("params")
-        .field("params", [def("TSType")]);
-    def("TSEnumDeclaration")
-        .bases("Declaration")
-        .build("id", "members")
-        .field("id", def("Identifier"))
-        .field("const", Boolean, defaults["false"])
-        .field("declare", Boolean, defaults["false"])
-        .field("members", [def("TSEnumMember")])
-        .field("initializer", or(def("Expression"), null), defaults["null"]);
-    def("TSTypeAliasDeclaration")
-        .bases("Declaration", "TSHasOptionalTypeParameters")
-        .build("id", "typeAnnotation")
-        .field("id", def("Identifier"))
-        .field("declare", Boolean, defaults["false"])
-        .field("typeAnnotation", def("TSType"));
-    def("TSModuleBlock")
-        .bases("Node")
-        .build("body")
-        .field("body", [def("Statement")]);
-    def("TSModuleDeclaration")
-        .bases("Declaration")
-        .build("id", "body")
-        .field("id", or(StringLiteral, TSEntityName))
-        .field("declare", Boolean, defaults["false"])
-        .field("global", Boolean, defaults["false"])
-        .field("body", or(def("TSModuleBlock"), def("TSModuleDeclaration"), null), defaults["null"]);
-    def("TSImportType")
-        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
-        .build("argument", "qualifier", "typeParameters")
-        .field("argument", StringLiteral)
-        .field("qualifier", or(TSEntityName, void 0), defaults["undefined"]);
-    def("TSImportEqualsDeclaration")
-        .bases("Declaration")
-        .build("id", "moduleReference")
-        .field("id", def("Identifier"))
-        .field("isExport", Boolean, defaults["false"])
-        .field("moduleReference", or(TSEntityName, def("TSExternalModuleReference")));
-    def("TSExternalModuleReference")
-        .bases("Declaration")
-        .build("expression")
-        .field("expression", StringLiteral);
-    def("TSExportAssignment")
-        .bases("Statement")
-        .build("expression")
-        .field("expression", def("Expression"));
-    def("TSNamespaceExportDeclaration")
-        .bases("Declaration")
-        .build("id")
-        .field("id", def("Identifier"));
-    def("TSInterfaceBody")
-        .bases("Node")
-        .build("body")
-        .field("body", [TSTypeMember]);
-    def("TSExpressionWithTypeArguments")
-        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
-        .build("expression", "typeParameters")
-        .field("expression", TSEntityName);
-    def("TSInterfaceDeclaration")
-        .bases("Declaration", "TSHasOptionalTypeParameters")
-        .build("id", "body")
-        .field("id", TSEntityName)
-        .field("declare", Boolean, defaults["false"])
-        .field("extends", or([def("TSExpressionWithTypeArguments")], null), defaults["null"])
-        .field("body", def("TSInterfaceBody"));
-    def("TSParameterProperty")
-        .bases("Pattern")
-        .build("parameter")
-        .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
-        .field("readonly", Boolean, defaults["false"])
-        .field("parameter", or(def("Identifier"), def("AssignmentPattern")));
-    def("ClassProperty")
-        .field("access", // Not "accessibility"?
-    or("public", "private", "protected", void 0), defaults["undefined"]);
-    // Defined already in es6 and babel-core.
-    def("ClassBody")
-        .field("body", [or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"), 
-        // Just need to add these types:
-        def("TSDeclareMethod"), TSTypeMember)]);
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/node_modules/ast-types/fork.d.ts

@@ -1,42 +0,0 @@
-import { Def, Plugin } from "./types";
-export default function (defs: Def[]): {
-    Type: {
-        or(...types: any[]): import("./lib/types").Type<any>;
-        from<T>(value: any, name?: string | undefined): import("./lib/types").Type<T>;
-        def(typeName: string): import("./lib/types").Def<any>;
-        hasDef(typeName: string): boolean;
-    };
-    builtInTypes: {
-        string: import("./lib/types").Type<string>;
-        function: import("./lib/types").Type<Function>;
-        array: import("./lib/types").Type<any[]>;
-        object: import("./lib/types").Type<{
-            [key: string]: any;
-        }>;
-        RegExp: import("./lib/types").Type<RegExp>;
-        Date: import("./lib/types").Type<Date>;
-        number: import("./lib/types").Type<number>;
-        boolean: import("./lib/types").Type<boolean>;
-        null: import("./lib/types").Type<null>;
-        undefined: import("./lib/types").Type<undefined>;
-    };
-    namedTypes: import("./gen/namedTypes").NamedTypes;
-    builders: import("./gen/builders").builders;
-    defineMethod: (name: any, func?: Function | undefined) => Function;
-    getFieldNames: (object: any) => string[];
-    getFieldValue: (object: any, fieldName: any) => any;
-    eachField: (object: any, callback: (name: any, value: any) => any, context?: any) => void;
-    someField: (object: any, callback: (name: any, value: any) => any, context?: any) => boolean;
-    getSupertypeNames: (typeName: string) => string[];
-    getBuilderName: (typeName: any) => any;
-    astNodesAreEquivalent: {
-        (a: any, b: any, problemPath?: any): boolean;
-        assert(a: any, b: any): void;
-    };
-    finalize: () => void;
-    Path: import("./lib/path").PathConstructor;
-    NodePath: import("./lib/node-path").NodePathConstructor;
-    PathVisitor: import("./lib/path-visitor").PathVisitorConstructor;
-    use: <T_1>(plugin: Plugin<T_1>) => T_1;
-    visit: <M = {}>(node: import("./lib/types").ASTNode, methods?: import("./main").Visitor<M> | undefined) => any;
-};

package/node_modules/ast-types/fork.js

@@ -1,52 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./lib/types"));
-var path_visitor_1 = tslib_1.__importDefault(require("./lib/path-visitor"));
-var equiv_1 = tslib_1.__importDefault(require("./lib/equiv"));
-var path_1 = tslib_1.__importDefault(require("./lib/path"));
-var node_path_1 = tslib_1.__importDefault(require("./lib/node-path"));
-function default_1(defs) {
-    var fork = createFork();
-    var types = fork.use(types_1.default);
-    defs.forEach(fork.use);
-    types.finalize();
-    var PathVisitor = fork.use(path_visitor_1.default);
-    return {
-        Type: types.Type,
-        builtInTypes: types.builtInTypes,
-        namedTypes: types.namedTypes,
-        builders: types.builders,
-        defineMethod: types.defineMethod,
-        getFieldNames: types.getFieldNames,
-        getFieldValue: types.getFieldValue,
-        eachField: types.eachField,
-        someField: types.someField,
-        getSupertypeNames: types.getSupertypeNames,
-        getBuilderName: types.getBuilderName,
-        astNodesAreEquivalent: fork.use(equiv_1.default),
-        finalize: types.finalize,
-        Path: fork.use(path_1.default),
-        NodePath: fork.use(node_path_1.default),
-        PathVisitor: PathVisitor,
-        use: fork.use,
-        visit: PathVisitor.visit,
-    };
-}
-exports.default = default_1;
-function createFork() {
-    var used = [];
-    var usedResult = [];
-    function use(plugin) {
-        var idx = used.indexOf(plugin);
-        if (idx === -1) {
-            idx = used.length;
-            used.push(plugin);
-            usedResult[idx] = plugin(fork);
-        }
-        return usedResult[idx];
-    }
-    var fork = { use: use };
-    return fork;
-}
-module.exports = exports["default"];