antigravity-mobile-proxy 0.1.2 → 0.1.4

package/.next/standalone/node_modules/ast-types/def/es6.js

@@ -1,210 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var core_1 = tslib_1.__importDefault(require("./core"));
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
-function default_1(fork) {
-    fork.use(core_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("Function")
-        .field("generator", Boolean, defaults["false"])
-        .field("expression", Boolean, defaults["false"])
-        .field("defaults", [or(def("Expression"), null)], defaults.emptyArray)
-        // TODO This could be represented as a RestElement in .params.
-        .field("rest", or(def("Identifier"), null), defaults["null"]);
-    // The ESTree way of representing a ...rest parameter.
-    def("RestElement")
-        .bases("Pattern")
-        .build("argument")
-        .field("argument", def("Pattern"))
-        .field("typeAnnotation", // for Babylon. Flow parser puts it on the identifier
-    or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), defaults["null"]);
-    def("SpreadElementPattern")
-        .bases("Pattern")
-        .build("argument")
-        .field("argument", def("Pattern"));
-    def("FunctionDeclaration")
-        .build("id", "params", "body", "generator", "expression");
-    def("FunctionExpression")
-        .build("id", "params", "body", "generator", "expression");
-    // The Parser API calls this ArrowExpression, but Esprima and all other
-    // actual parsers use ArrowFunctionExpression.
-    def("ArrowFunctionExpression")
-        .bases("Function", "Expression")
-        .build("params", "body", "expression")
-        // The forced null value here is compatible with the overridden
-        // definition of the "id" field in the Function interface.
-        .field("id", null, defaults["null"])
-        // Arrow function bodies are allowed to be expressions.
-        .field("body", or(def("BlockStatement"), def("Expression")))
-        // The current spec forbids arrow generators, so I have taken the
-        // liberty of enforcing that. TODO Report this.
-        .field("generator", false, defaults["false"]);
-    def("ForOfStatement")
-        .bases("Statement")
-        .build("left", "right", "body")
-        .field("left", or(def("VariableDeclaration"), def("Pattern")))
-        .field("right", def("Expression"))
-        .field("body", def("Statement"));
-    def("YieldExpression")
-        .bases("Expression")
-        .build("argument", "delegate")
-        .field("argument", or(def("Expression"), null))
-        .field("delegate", Boolean, defaults["false"]);
-    def("GeneratorExpression")
-        .bases("Expression")
-        .build("body", "blocks", "filter")
-        .field("body", def("Expression"))
-        .field("blocks", [def("ComprehensionBlock")])
-        .field("filter", or(def("Expression"), null));
-    def("ComprehensionExpression")
-        .bases("Expression")
-        .build("body", "blocks", "filter")
-        .field("body", def("Expression"))
-        .field("blocks", [def("ComprehensionBlock")])
-        .field("filter", or(def("Expression"), null));
-    def("ComprehensionBlock")
-        .bases("Node")
-        .build("left", "right", "each")
-        .field("left", def("Pattern"))
-        .field("right", def("Expression"))
-        .field("each", Boolean);
-    def("Property")
-        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-        .field("value", or(def("Expression"), def("Pattern")))
-        .field("method", Boolean, defaults["false"])
-        .field("shorthand", Boolean, defaults["false"])
-        .field("computed", Boolean, defaults["false"]);
-    def("ObjectProperty")
-        .field("shorthand", Boolean, defaults["false"]);
-    def("PropertyPattern")
-        .bases("Pattern")
-        .build("key", "pattern")
-        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-        .field("pattern", def("Pattern"))
-        .field("computed", Boolean, defaults["false"]);
-    def("ObjectPattern")
-        .bases("Pattern")
-        .build("properties")
-        .field("properties", [or(def("PropertyPattern"), def("Property"))]);
-    def("ArrayPattern")
-        .bases("Pattern")
-        .build("elements")
-        .field("elements", [or(def("Pattern"), null)]);
-    def("MethodDefinition")
-        .bases("Declaration")
-        .build("kind", "key", "value", "static")
-        .field("kind", or("constructor", "method", "get", "set"))
-        .field("key", def("Expression"))
-        .field("value", def("Function"))
-        .field("computed", Boolean, defaults["false"])
-        .field("static", Boolean, defaults["false"]);
-    def("SpreadElement")
-        .bases("Node")
-        .build("argument")
-        .field("argument", def("Expression"));
-    def("ArrayExpression")
-        .field("elements", [or(def("Expression"), def("SpreadElement"), def("RestElement"), null)]);
-    def("NewExpression")
-        .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
-    def("CallExpression")
-        .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
-    // Note: this node type is *not* an AssignmentExpression with a Pattern on
-    // the left-hand side! The existing AssignmentExpression type already
-    // supports destructuring assignments. AssignmentPattern nodes may appear
-    // wherever a Pattern is allowed, and the right-hand side represents a
-    // default value to be destructured against the left-hand side, if no
-    // value is otherwise provided. For example: default parameter values.
-    def("AssignmentPattern")
-        .bases("Pattern")
-        .build("left", "right")
-        .field("left", def("Pattern"))
-        .field("right", def("Expression"));
-    var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"));
-    def("ClassProperty")
-        .bases("Declaration")
-        .build("key")
-        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-        .field("computed", Boolean, defaults["false"]);
-    def("ClassPropertyDefinition") // static property
-        .bases("Declaration")
-        .build("definition")
-        // Yes, Virginia, circular definitions are permitted.
-        .field("definition", ClassBodyElement);
-    def("ClassBody")
-        .bases("Declaration")
-        .build("body")
-        .field("body", [ClassBodyElement]);
-    def("ClassDeclaration")
-        .bases("Declaration")
-        .build("id", "body", "superClass")
-        .field("id", or(def("Identifier"), null))
-        .field("body", def("ClassBody"))
-        .field("superClass", or(def("Expression"), null), defaults["null"]);
-    def("ClassExpression")
-        .bases("Expression")
-        .build("id", "body", "superClass")
-        .field("id", or(def("Identifier"), null), defaults["null"])
-        .field("body", def("ClassBody"))
-        .field("superClass", or(def("Expression"), null), defaults["null"]);
-    // Specifier and ModuleSpecifier are abstract non-standard types
-    // introduced for definitional convenience.
-    def("Specifier").bases("Node");
-    // This supertype is shared/abused by both def/babel.js and
-    // def/esprima.js. In the future, it will be possible to load only one set
-    // of definitions appropriate for a given parser, but until then we must
-    // rely on default functions to reconcile the conflicting AST formats.
-    def("ModuleSpecifier")
-        .bases("Specifier")
-        // This local field is used by Babel/Acorn. It should not technically
-        // be optional in the Babel/Acorn AST format, but it must be optional
-        // in the Esprima AST format.
-        .field("local", or(def("Identifier"), null), defaults["null"])
-        // The id and name fields are used by Esprima. The id field should not
-        // technically be optional in the Esprima AST format, but it must be
-        // optional in the Babel/Acorn AST format.
-        .field("id", or(def("Identifier"), null), defaults["null"])
-        .field("name", or(def("Identifier"), null), defaults["null"]);
-    // Like ModuleSpecifier, except type:"ImportSpecifier" and buildable.
-    // import {<id [as name]>} from ...;
-    def("ImportSpecifier")
-        .bases("ModuleSpecifier")
-        .build("id", "name");
-    // import <* as id> from ...;
-    def("ImportNamespaceSpecifier")
-        .bases("ModuleSpecifier")
-        .build("id");
-    // import <id> from ...;
-    def("ImportDefaultSpecifier")
-        .bases("ModuleSpecifier")
-        .build("id");
-    def("ImportDeclaration")
-        .bases("Declaration")
-        .build("specifiers", "source", "importKind")
-        .field("specifiers", [or(def("ImportSpecifier"), def("ImportNamespaceSpecifier"), def("ImportDefaultSpecifier"))], defaults.emptyArray)
-        .field("source", def("Literal"))
-        .field("importKind", or("value", "type"), function () {
-        return "value";
-    });
-    def("TaggedTemplateExpression")
-        .bases("Expression")
-        .build("tag", "quasi")
-        .field("tag", def("Expression"))
-        .field("quasi", def("TemplateLiteral"));
-    def("TemplateLiteral")
-        .bases("Expression")
-        .build("quasis", "expressions")
-        .field("quasis", [def("TemplateElement")])
-        .field("expressions", [def("Expression")]);
-    def("TemplateElement")
-        .bases("Node")
-        .build("value", "tail")
-        .field("value", { "cooked": String, "raw": String })
-        .field("tail", Boolean);
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/.next/standalone/node_modules/ast-types/def/es7.js

@@ -1,34 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var es6_1 = tslib_1.__importDefault(require("./es6"));
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
-function default_1(fork) {
-    fork.use(es6_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("Function")
-        .field("async", Boolean, defaults["false"]);
-    def("SpreadProperty")
-        .bases("Node")
-        .build("argument")
-        .field("argument", def("Expression"));
-    def("ObjectExpression")
-        .field("properties", [or(def("Property"), def("SpreadProperty"), def("SpreadElement"))]);
-    def("SpreadPropertyPattern")
-        .bases("Pattern")
-        .build("argument")
-        .field("argument", def("Pattern"));
-    def("ObjectPattern")
-        .field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"))]);
-    def("AwaitExpression")
-        .bases("Expression")
-        .build("argument", "all")
-        .field("argument", or(def("Expression"), null))
-        .field("all", Boolean, defaults["false"]);
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/.next/standalone/node_modules/ast-types/def/esprima.js

@@ -1,49 +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 defaults = fork.use(shared_1.default).defaults;
-    var def = types.Type.def;
-    var or = types.Type.or;
-    def("VariableDeclaration")
-        .field("declarations", [or(def("VariableDeclarator"), def("Identifier") // Esprima deviation.
-        )]);
-    def("Property")
-        .field("value", or(def("Expression"), def("Pattern") // Esprima deviation.
-    ));
-    def("ArrayPattern")
-        .field("elements", [or(def("Pattern"), def("SpreadElement"), null)]);
-    def("ObjectPattern")
-        .field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty") // Used by Esprima.
-        )]);
-    // Like ModuleSpecifier, except type:"ExportSpecifier" and buildable.
-    // export {<id [as name]>} [from ...];
-    def("ExportSpecifier")
-        .bases("ModuleSpecifier")
-        .build("id", "name");
-    // export <*> from ...;
-    def("ExportBatchSpecifier")
-        .bases("Specifier")
-        .build();
-    def("ExportDeclaration")
-        .bases("Declaration")
-        .build("default", "declaration", "specifiers", "source")
-        .field("default", Boolean)
-        .field("declaration", or(def("Declaration"), def("Expression"), // Implies default.
-    null))
-        .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
-        .field("source", or(def("Literal"), null), defaults["null"]);
-    def("Block")
-        .bases("Comment")
-        .build("value", /*optional:*/ "leading", "trailing");
-    def("Line")
-        .bases("Comment")
-        .build("value", /*optional:*/ "leading", "trailing");
-}
-exports.default = default_1;
-module.exports = exports["default"];

package/.next/standalone/node_modules/ast-types/def/flow.js

@@ -1,292 +0,0 @@
-"use strict";;
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var es7_1 = tslib_1.__importDefault(require("./es7"));
-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) {
-    fork.use(es7_1.default);
-    fork.use(type_annotations_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;
-    // Base types
-    def("Flow").bases("Node");
-    def("FlowType").bases("Flow");
-    // Type annotations
-    def("AnyTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("EmptyTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("MixedTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("VoidTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("NumberTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("NumberLiteralTypeAnnotation")
-        .bases("FlowType")
-        .build("value", "raw")
-        .field("value", Number)
-        .field("raw", String);
-    // Babylon 6 differs in AST from Flow
-    // same as NumberLiteralTypeAnnotation
-    def("NumericLiteralTypeAnnotation")
-        .bases("FlowType")
-        .build("value", "raw")
-        .field("value", Number)
-        .field("raw", String);
-    def("StringTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("StringLiteralTypeAnnotation")
-        .bases("FlowType")
-        .build("value", "raw")
-        .field("value", String)
-        .field("raw", String);
-    def("BooleanTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("BooleanLiteralTypeAnnotation")
-        .bases("FlowType")
-        .build("value", "raw")
-        .field("value", Boolean)
-        .field("raw", String);
-    def("TypeAnnotation")
-        .bases("Node")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("FlowType"));
-    def("NullableTypeAnnotation")
-        .bases("FlowType")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("FlowType"));
-    def("NullLiteralTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("NullTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("ThisTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("ExistsTypeAnnotation")
-        .bases("FlowType")
-        .build();
-    def("ExistentialTypeParam")
-        .bases("FlowType")
-        .build();
-    def("FunctionTypeAnnotation")
-        .bases("FlowType")
-        .build("params", "returnType", "rest", "typeParameters")
-        .field("params", [def("FunctionTypeParam")])
-        .field("returnType", def("FlowType"))
-        .field("rest", or(def("FunctionTypeParam"), null))
-        .field("typeParameters", or(def("TypeParameterDeclaration"), null));
-    def("FunctionTypeParam")
-        .bases("Node")
-        .build("name", "typeAnnotation", "optional")
-        .field("name", def("Identifier"))
-        .field("typeAnnotation", def("FlowType"))
-        .field("optional", Boolean);
-    def("ArrayTypeAnnotation")
-        .bases("FlowType")
-        .build("elementType")
-        .field("elementType", def("FlowType"));
-    def("ObjectTypeAnnotation")
-        .bases("FlowType")
-        .build("properties", "indexers", "callProperties")
-        .field("properties", [
-        or(def("ObjectTypeProperty"), def("ObjectTypeSpreadProperty"))
-    ])
-        .field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray)
-        .field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray)
-        .field("inexact", or(Boolean, void 0), defaults["undefined"])
-        .field("exact", Boolean, defaults["false"])
-        .field("internalSlots", [def("ObjectTypeInternalSlot")], defaults.emptyArray);
-    def("Variance")
-        .bases("Node")
-        .build("kind")
-        .field("kind", or("plus", "minus"));
-    var LegacyVariance = or(def("Variance"), "plus", "minus", null);
-    def("ObjectTypeProperty")
-        .bases("Node")
-        .build("key", "value", "optional")
-        .field("key", or(def("Literal"), def("Identifier")))
-        .field("value", def("FlowType"))
-        .field("optional", Boolean)
-        .field("variance", LegacyVariance, defaults["null"]);
-    def("ObjectTypeIndexer")
-        .bases("Node")
-        .build("id", "key", "value")
-        .field("id", def("Identifier"))
-        .field("key", def("FlowType"))
-        .field("value", def("FlowType"))
-        .field("variance", LegacyVariance, defaults["null"]);
-    def("ObjectTypeCallProperty")
-        .bases("Node")
-        .build("value")
-        .field("value", def("FunctionTypeAnnotation"))
-        .field("static", Boolean, defaults["false"]);
-    def("QualifiedTypeIdentifier")
-        .bases("Node")
-        .build("qualification", "id")
-        .field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier")))
-        .field("id", def("Identifier"));
-    def("GenericTypeAnnotation")
-        .bases("FlowType")
-        .build("id", "typeParameters")
-        .field("id", or(def("Identifier"), def("QualifiedTypeIdentifier")))
-        .field("typeParameters", or(def("TypeParameterInstantiation"), null));
-    def("MemberTypeAnnotation")
-        .bases("FlowType")
-        .build("object", "property")
-        .field("object", def("Identifier"))
-        .field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation")));
-    def("UnionTypeAnnotation")
-        .bases("FlowType")
-        .build("types")
-        .field("types", [def("FlowType")]);
-    def("IntersectionTypeAnnotation")
-        .bases("FlowType")
-        .build("types")
-        .field("types", [def("FlowType")]);
-    def("TypeofTypeAnnotation")
-        .bases("FlowType")
-        .build("argument")
-        .field("argument", def("FlowType"));
-    def("ObjectTypeSpreadProperty")
-        .bases("Node")
-        .build("argument")
-        .field("argument", def("FlowType"));
-    def("ObjectTypeInternalSlot")
-        .bases("Node")
-        .build("id", "value", "optional", "static", "method")
-        .field("id", def("Identifier"))
-        .field("value", def("FlowType"))
-        .field("optional", Boolean)
-        .field("static", Boolean)
-        .field("method", Boolean);
-    def("TypeParameterDeclaration")
-        .bases("Node")
-        .build("params")
-        .field("params", [def("TypeParameter")]);
-    def("TypeParameterInstantiation")
-        .bases("Node")
-        .build("params")
-        .field("params", [def("FlowType")]);
-    def("TypeParameter")
-        .bases("FlowType")
-        .build("name", "variance", "bound")
-        .field("name", String)
-        .field("variance", LegacyVariance, defaults["null"])
-        .field("bound", or(def("TypeAnnotation"), null), defaults["null"]);
-    def("ClassProperty")
-        .field("variance", LegacyVariance, defaults["null"]);
-    def("ClassImplements")
-        .bases("Node")
-        .build("id")
-        .field("id", def("Identifier"))
-        .field("superClass", or(def("Expression"), null), defaults["null"])
-        .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
-    def("InterfaceTypeAnnotation")
-        .bases("FlowType")
-        .build("body", "extends")
-        .field("body", def("ObjectTypeAnnotation"))
-        .field("extends", or([def("InterfaceExtends")], null), defaults["null"]);
-    def("InterfaceDeclaration")
-        .bases("Declaration")
-        .build("id", "body", "extends")
-        .field("id", def("Identifier"))
-        .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"])
-        .field("body", def("ObjectTypeAnnotation"))
-        .field("extends", [def("InterfaceExtends")]);
-    def("DeclareInterface")
-        .bases("InterfaceDeclaration")
-        .build("id", "body", "extends");
-    def("InterfaceExtends")
-        .bases("Node")
-        .build("id")
-        .field("id", def("Identifier"))
-        .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
-    def("TypeAlias")
-        .bases("Declaration")
-        .build("id", "typeParameters", "right")
-        .field("id", def("Identifier"))
-        .field("typeParameters", or(def("TypeParameterDeclaration"), null))
-        .field("right", def("FlowType"));
-    def("OpaqueType")
-        .bases("Declaration")
-        .build("id", "typeParameters", "impltype", "supertype")
-        .field("id", def("Identifier"))
-        .field("typeParameters", or(def("TypeParameterDeclaration"), null))
-        .field("impltype", def("FlowType"))
-        .field("supertype", def("FlowType"));
-    def("DeclareTypeAlias")
-        .bases("TypeAlias")
-        .build("id", "typeParameters", "right");
-    def("DeclareOpaqueType")
-        .bases("TypeAlias")
-        .build("id", "typeParameters", "supertype");
-    def("TypeCastExpression")
-        .bases("Expression")
-        .build("expression", "typeAnnotation")
-        .field("expression", def("Expression"))
-        .field("typeAnnotation", def("TypeAnnotation"));
-    def("TupleTypeAnnotation")
-        .bases("FlowType")
-        .build("types")
-        .field("types", [def("FlowType")]);
-    def("DeclareVariable")
-        .bases("Statement")
-        .build("id")
-        .field("id", def("Identifier"));
-    def("DeclareFunction")
-        .bases("Statement")
-        .build("id")
-        .field("id", def("Identifier"));
-    def("DeclareClass")
-        .bases("InterfaceDeclaration")
-        .build("id");
-    def("DeclareModule")
-        .bases("Statement")
-        .build("id", "body")
-        .field("id", or(def("Identifier"), def("Literal")))
-        .field("body", def("BlockStatement"));
-    def("DeclareModuleExports")
-        .bases("Statement")
-        .build("typeAnnotation")
-        .field("typeAnnotation", def("TypeAnnotation"));
-    def("DeclareExportDeclaration")
-        .bases("Declaration")
-        .build("default", "declaration", "specifiers", "source")
-        .field("default", Boolean)
-        .field("declaration", or(def("DeclareVariable"), def("DeclareFunction"), def("DeclareClass"), def("FlowType"), // Implies default.
-    null))
-        .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
-        .field("source", or(def("Literal"), null), defaults["null"]);
-    def("DeclareExportAllDeclaration")
-        .bases("Declaration")
-        .build("source")
-        .field("source", or(def("Literal"), null), defaults["null"]);
-    def("FlowPredicate").bases("Flow");
-    def("InferredPredicate")
-        .bases("FlowPredicate")
-        .build();
-    def("DeclaredPredicate")
-        .bases("FlowPredicate")
-        .build("value")
-        .field("value", def("Expression"));
-    def("CallExpression")
-        .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
-    def("NewExpression")
-        .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
-}
-exports.default = default_1;
-module.exports = exports["default"];