conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/ast-types/def/jsx.js

@@ -0,0 +1,103 @@
+"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/web/.next/standalone/node_modules/ast-types/def/type-annotations.js

@@ -0,0 +1,40 @@
+"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/web/.next/standalone/node_modules/ast-types/def/typescript.js

@@ -0,0 +1,344 @@
+"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/web/.next/standalone/node_modules/ast-types/fork.js

@@ -0,0 +1,52 @@
+"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"];

package/web/.next/standalone/node_modules/ast-types/gen/namedTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namedTypes = void 0;
+var namedTypes;
+(function (namedTypes) {
+})(namedTypes = exports.namedTypes || (exports.namedTypes = {}));