bitz-react-admin-ui 2.10.7-beta.1 → 2.10.7-beta.2

package/dist/node_modules/@babel/types/lib/definitions/jsx.mjs

@@ -1,151 +0,0 @@
-import { __exports as s } from "../../../../../_virtual/jsx.mjs";
-import { __require as t } from "./utils.mjs";
-var i;
-function l() {
-  if (i)
-    return s;
-  i = 1;
-  var e = t();
-  const a = (0, e.defineAliasedType)("JSX");
-  return a("JSXAttribute", {
-    visitor: ["name", "value"],
-    aliases: ["Immutable"],
-    fields: {
-      name: {
-        validate: (0, e.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
-      },
-      value: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
-      }
-    }
-  }), a("JSXClosingElement", {
-    visitor: ["name"],
-    aliases: ["Immutable"],
-    fields: {
-      name: {
-        validate: (0, e.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
-      }
-    }
-  }), a("JSXElement", {
-    builder: ["openingElement", "closingElement", "children", "selfClosing"],
-    visitor: ["openingElement", "children", "closingElement"],
-    aliases: ["Immutable", "Expression"],
-    fields: Object.assign({
-      openingElement: {
-        validate: (0, e.assertNodeType)("JSXOpeningElement")
-      },
-      closingElement: {
-        optional: !0,
-        validate: (0, e.assertNodeType)("JSXClosingElement")
-      },
-      children: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
-      }
-    }, {
-      selfClosing: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      }
-    })
-  }), a("JSXEmptyExpression", {}), a("JSXExpressionContainer", {
-    visitor: ["expression"],
-    aliases: ["Immutable"],
-    fields: {
-      expression: {
-        validate: (0, e.assertNodeType)("Expression", "JSXEmptyExpression")
-      }
-    }
-  }), a("JSXSpreadChild", {
-    visitor: ["expression"],
-    aliases: ["Immutable"],
-    fields: {
-      expression: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), a("JSXIdentifier", {
-    builder: ["name"],
-    fields: {
-      name: {
-        validate: (0, e.assertValueType)("string")
-      }
-    }
-  }), a("JSXMemberExpression", {
-    visitor: ["object", "property"],
-    fields: {
-      object: {
-        validate: (0, e.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
-      },
-      property: {
-        validate: (0, e.assertNodeType)("JSXIdentifier")
-      }
-    }
-  }), a("JSXNamespacedName", {
-    visitor: ["namespace", "name"],
-    fields: {
-      namespace: {
-        validate: (0, e.assertNodeType)("JSXIdentifier")
-      },
-      name: {
-        validate: (0, e.assertNodeType)("JSXIdentifier")
-      }
-    }
-  }), a("JSXOpeningElement", {
-    builder: ["name", "attributes", "selfClosing"],
-    visitor: ["name", "attributes"],
-    aliases: ["Immutable"],
-    fields: {
-      name: {
-        validate: (0, e.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
-      },
-      selfClosing: {
-        default: !1
-      },
-      attributes: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
-      },
-      typeParameters: {
-        validate: (0, e.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-        optional: !0
-      }
-    }
-  }), a("JSXSpreadAttribute", {
-    visitor: ["argument"],
-    fields: {
-      argument: {
-        validate: (0, e.assertNodeType)("Expression")
-      }
-    }
-  }), a("JSXText", {
-    aliases: ["Immutable"],
-    builder: ["value"],
-    fields: {
-      value: {
-        validate: (0, e.assertValueType)("string")
-      }
-    }
-  }), a("JSXFragment", {
-    builder: ["openingFragment", "closingFragment", "children"],
-    visitor: ["openingFragment", "children", "closingFragment"],
-    aliases: ["Immutable", "Expression"],
-    fields: {
-      openingFragment: {
-        validate: (0, e.assertNodeType)("JSXOpeningFragment")
-      },
-      closingFragment: {
-        validate: (0, e.assertNodeType)("JSXClosingFragment")
-      },
-      children: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
-      }
-    }
-  }), a("JSXOpeningFragment", {
-    aliases: ["Immutable"]
-  }), a("JSXClosingFragment", {
-    aliases: ["Immutable"]
-  }), s;
-}
-export {
-  l as __require
-};

package/dist/node_modules/@babel/types/lib/definitions/misc.mjs

@@ -1,35 +0,0 @@
-import { __exports as i } from "../../../../../_virtual/misc.mjs";
-import { __require as t } from "./utils.mjs";
-import { __require as d } from "./placeholders.mjs";
-var s;
-function u() {
-  if (s)
-    return i;
-  s = 1;
-  var e = t(), a = d();
-  const r = (0, e.defineAliasedType)("Miscellaneous");
-  return r("Noop", {
-    visitor: []
-  }), r("Placeholder", {
-    visitor: [],
-    builder: ["expectedNode", "name"],
-    fields: {
-      name: {
-        validate: (0, e.assertNodeType)("Identifier")
-      },
-      expectedNode: {
-        validate: (0, e.assertOneOf)(...a.PLACEHOLDERS)
-      }
-    }
-  }), r("V8IntrinsicIdentifier", {
-    builder: ["name"],
-    fields: {
-      name: {
-        validate: (0, e.assertValueType)("string")
-      }
-    }
-  }), i;
-}
-export {
-  u as __require
-};

package/dist/node_modules/@babel/types/lib/definitions/placeholders.mjs

@@ -1,28 +0,0 @@
-import { __exports as e } from "../../../../../_virtual/placeholders.mjs";
-import { __require as A } from "./utils.mjs";
-var a;
-function P() {
-  if (a)
-    return e;
-  a = 1, Object.defineProperty(e, "__esModule", {
-    value: !0
-  }), e.PLACEHOLDERS_FLIPPED_ALIAS = e.PLACEHOLDERS_ALIAS = e.PLACEHOLDERS = void 0;
-  var E = A();
-  const n = e.PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"], L = e.PLACEHOLDERS_ALIAS = {
-    Declaration: ["Statement"],
-    Pattern: ["PatternLike", "LVal"]
-  };
-  for (const t of n) {
-    const r = E.ALIAS_KEYS[t];
-    r != null && r.length && (L[t] = r);
-  }
-  const o = e.PLACEHOLDERS_FLIPPED_ALIAS = {};
-  return Object.keys(L).forEach((t) => {
-    L[t].forEach((r) => {
-      hasOwnProperty.call(o, r) || (o[r] = []), o[r].push(t);
-    });
-  }), e;
-}
-export {
-  P as __require
-};

package/dist/node_modules/@babel/types/lib/definitions/typescript.mjs

@@ -1,445 +0,0 @@
-import { __exports as v } from "../../../../../_virtual/typescript.mjs";
-import { __require as P } from "./utils.mjs";
-import { __require as E } from "./core.mjs";
-import { __require as b } from "../validators/is.mjs";
-var m;
-function L() {
-  if (m)
-    return v;
-  m = 1;
-  var e = P(), n = E(), f = b();
-  const a = (0, e.defineAliasedType)("TypeScript"), t = (0, e.assertValueType)("boolean"), p = () => ({
-    returnType: {
-      validate: (0, e.assertNodeType)("TSTypeAnnotation", "Noop"),
-      optional: !0
-    },
-    typeParameters: {
-      validate: (0, e.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
-      optional: !0
-    }
-  });
-  a("TSParameterProperty", {
-    aliases: ["LVal"],
-    visitor: ["parameter"],
-    fields: {
-      accessibility: {
-        validate: (0, e.assertOneOf)("public", "private", "protected"),
-        optional: !0
-      },
-      readonly: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      parameter: {
-        validate: (0, e.assertNodeType)("Identifier", "AssignmentPattern")
-      },
-      override: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      decorators: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("Decorator"))),
-        optional: !0
-      }
-    }
-  }), a("TSDeclareFunction", {
-    aliases: ["Statement", "Declaration"],
-    visitor: ["id", "typeParameters", "params", "returnType"],
-    fields: Object.assign({}, (0, n.functionDeclarationCommon)(), p())
-  }), a("TSDeclareMethod", {
-    visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-    fields: Object.assign({}, (0, n.classMethodOrDeclareMethodCommon)(), p())
-  }), a("TSQualifiedName", {
-    aliases: ["TSEntityName"],
-    visitor: ["left", "right"],
-    fields: {
-      left: (0, e.validateType)("TSEntityName"),
-      right: (0, e.validateType)("Identifier")
-    }
-  });
-  const r = () => ({
-    typeParameters: (0, e.validateOptionalType)("TSTypeParameterDeclaration"),
-    parameters: (0, e.validateArrayOfType)(["ArrayPattern", "Identifier", "ObjectPattern", "RestElement"]),
-    typeAnnotation: (0, e.validateOptionalType)("TSTypeAnnotation")
-  }), o = {
-    aliases: ["TSTypeElement"],
-    visitor: ["typeParameters", "parameters", "typeAnnotation"],
-    fields: r()
-  };
-  a("TSCallSignatureDeclaration", o), a("TSConstructSignatureDeclaration", o);
-  const l = () => ({
-    key: (0, e.validateType)("Expression"),
-    computed: {
-      default: !1
-    },
-    optional: (0, e.validateOptional)(t)
-  });
-  a("TSPropertySignature", {
-    aliases: ["TSTypeElement"],
-    visitor: ["key", "typeAnnotation"],
-    fields: Object.assign({}, l(), {
-      readonly: (0, e.validateOptional)(t),
-      typeAnnotation: (0, e.validateOptionalType)("TSTypeAnnotation"),
-      kind: {
-        validate: (0, e.assertOneOf)("get", "set")
-      }
-    })
-  }), a("TSMethodSignature", {
-    aliases: ["TSTypeElement"],
-    visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
-    fields: Object.assign({}, r(), l(), {
-      kind: {
-        validate: (0, e.assertOneOf)("method", "get", "set")
-      }
-    })
-  }), a("TSIndexSignature", {
-    aliases: ["TSTypeElement"],
-    visitor: ["parameters", "typeAnnotation"],
-    fields: {
-      readonly: (0, e.validateOptional)(t),
-      static: (0, e.validateOptional)(t),
-      parameters: (0, e.validateArrayOfType)("Identifier"),
-      typeAnnotation: (0, e.validateOptionalType)("TSTypeAnnotation")
-    }
-  });
-  const c = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
-  for (const s of c)
-    a(s, {
-      aliases: ["TSType", "TSBaseType"],
-      visitor: [],
-      fields: {}
-    });
-  a("TSThisType", {
-    aliases: ["TSType", "TSBaseType"],
-    visitor: [],
-    fields: {}
-  });
-  const T = {
-    aliases: ["TSType"],
-    visitor: ["typeParameters", "parameters", "typeAnnotation"]
-  };
-  a("TSFunctionType", Object.assign({}, T, {
-    fields: r()
-  })), a("TSConstructorType", Object.assign({}, T, {
-    fields: Object.assign({}, r(), {
-      abstract: (0, e.validateOptional)(t)
-    })
-  })), a("TSTypeReference", {
-    aliases: ["TSType"],
-    visitor: ["typeName", "typeParameters"],
-    fields: {
-      typeName: (0, e.validateType)("TSEntityName"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterInstantiation")
-    }
-  }), a("TSTypePredicate", {
-    aliases: ["TSType"],
-    visitor: ["parameterName", "typeAnnotation"],
-    builder: ["parameterName", "typeAnnotation", "asserts"],
-    fields: {
-      parameterName: (0, e.validateType)(["Identifier", "TSThisType"]),
-      typeAnnotation: (0, e.validateOptionalType)("TSTypeAnnotation"),
-      asserts: (0, e.validateOptional)(t)
-    }
-  }), a("TSTypeQuery", {
-    aliases: ["TSType"],
-    visitor: ["exprName", "typeParameters"],
-    fields: {
-      exprName: (0, e.validateType)(["TSEntityName", "TSImportType"]),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterInstantiation")
-    }
-  }), a("TSTypeLiteral", {
-    aliases: ["TSType"],
-    visitor: ["members"],
-    fields: {
-      members: (0, e.validateArrayOfType)("TSTypeElement")
-    }
-  }), a("TSArrayType", {
-    aliases: ["TSType"],
-    visitor: ["elementType"],
-    fields: {
-      elementType: (0, e.validateType)("TSType")
-    }
-  }), a("TSTupleType", {
-    aliases: ["TSType"],
-    visitor: ["elementTypes"],
-    fields: {
-      elementTypes: (0, e.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
-    }
-  }), a("TSOptionalType", {
-    aliases: ["TSType"],
-    visitor: ["typeAnnotation"],
-    fields: {
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  }), a("TSRestType", {
-    aliases: ["TSType"],
-    visitor: ["typeAnnotation"],
-    fields: {
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  }), a("TSNamedTupleMember", {
-    visitor: ["label", "elementType"],
-    builder: ["label", "elementType", "optional"],
-    fields: {
-      label: (0, e.validateType)("Identifier"),
-      optional: {
-        validate: t,
-        default: !1
-      },
-      elementType: (0, e.validateType)("TSType")
-    }
-  });
-  const y = {
-    aliases: ["TSType"],
-    visitor: ["types"],
-    fields: {
-      types: (0, e.validateArrayOfType)("TSType")
-    }
-  };
-  a("TSUnionType", y), a("TSIntersectionType", y), a("TSConditionalType", {
-    aliases: ["TSType"],
-    visitor: ["checkType", "extendsType", "trueType", "falseType"],
-    fields: {
-      checkType: (0, e.validateType)("TSType"),
-      extendsType: (0, e.validateType)("TSType"),
-      trueType: (0, e.validateType)("TSType"),
-      falseType: (0, e.validateType)("TSType")
-    }
-  }), a("TSInferType", {
-    aliases: ["TSType"],
-    visitor: ["typeParameter"],
-    fields: {
-      typeParameter: (0, e.validateType)("TSTypeParameter")
-    }
-  }), a("TSParenthesizedType", {
-    aliases: ["TSType"],
-    visitor: ["typeAnnotation"],
-    fields: {
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  }), a("TSTypeOperator", {
-    aliases: ["TSType"],
-    visitor: ["typeAnnotation"],
-    fields: {
-      operator: (0, e.validate)((0, e.assertValueType)("string")),
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  }), a("TSIndexedAccessType", {
-    aliases: ["TSType"],
-    visitor: ["objectType", "indexType"],
-    fields: {
-      objectType: (0, e.validateType)("TSType"),
-      indexType: (0, e.validateType)("TSType")
-    }
-  }), a("TSMappedType", {
-    aliases: ["TSType"],
-    visitor: ["typeParameter", "nameType", "typeAnnotation"],
-    builder: ["typeParameter", "typeAnnotation", "nameType"],
-    fields: Object.assign({}, {
-      typeParameter: (0, e.validateType)("TSTypeParameter")
-    }, {
-      readonly: (0, e.validateOptional)((0, e.assertOneOf)(!0, !1, "+", "-")),
-      optional: (0, e.validateOptional)((0, e.assertOneOf)(!0, !1, "+", "-")),
-      typeAnnotation: (0, e.validateOptionalType)("TSType"),
-      nameType: (0, e.validateOptionalType)("TSType")
-    })
-  }), a("TSLiteralType", {
-    aliases: ["TSType", "TSBaseType"],
-    visitor: ["literal"],
-    fields: {
-      literal: {
-        validate: function() {
-          const s = (0, e.assertNodeType)("NumericLiteral", "BigIntLiteral"), u = (0, e.assertOneOf)("-"), O = (0, e.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
-          function S(A, x, i) {
-            (0, f.default)("UnaryExpression", i) ? (u(i, "operator", i.operator), s(i, "argument", i.argument)) : O(A, x, i);
-          }
-          return S.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"], S;
-        }()
-      }
-    }
-  }), a("TSExpressionWithTypeArguments", {
-    aliases: ["TSType"],
-    visitor: ["expression", "typeParameters"],
-    fields: {
-      expression: (0, e.validateType)("TSEntityName"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterInstantiation")
-    }
-  }), a("TSInterfaceDeclaration", {
-    aliases: ["Statement", "Declaration"],
-    visitor: ["id", "typeParameters", "extends", "body"],
-    fields: {
-      declare: (0, e.validateOptional)(t),
-      id: (0, e.validateType)("Identifier"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterDeclaration"),
-      extends: (0, e.validateOptional)((0, e.arrayOfType)("TSExpressionWithTypeArguments")),
-      body: (0, e.validateType)("TSInterfaceBody")
-    }
-  }), a("TSInterfaceBody", {
-    visitor: ["body"],
-    fields: {
-      body: (0, e.validateArrayOfType)("TSTypeElement")
-    }
-  }), a("TSTypeAliasDeclaration", {
-    aliases: ["Statement", "Declaration"],
-    visitor: ["id", "typeParameters", "typeAnnotation"],
-    fields: {
-      declare: (0, e.validateOptional)(t),
-      id: (0, e.validateType)("Identifier"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterDeclaration"),
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  }), a("TSInstantiationExpression", {
-    aliases: ["Expression"],
-    visitor: ["expression", "typeParameters"],
-    fields: {
-      expression: (0, e.validateType)("Expression"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterInstantiation")
-    }
-  });
-  const d = {
-    aliases: ["Expression", "LVal", "PatternLike"],
-    visitor: ["expression", "typeAnnotation"],
-    fields: {
-      expression: (0, e.validateType)("Expression"),
-      typeAnnotation: (0, e.validateType)("TSType")
-    }
-  };
-  return a("TSAsExpression", d), a("TSSatisfiesExpression", d), a("TSTypeAssertion", {
-    aliases: ["Expression", "LVal", "PatternLike"],
-    visitor: ["typeAnnotation", "expression"],
-    fields: {
-      typeAnnotation: (0, e.validateType)("TSType"),
-      expression: (0, e.validateType)("Expression")
-    }
-  }), a("TSEnumDeclaration", {
-    aliases: ["Statement", "Declaration"],
-    visitor: ["id", "members"],
-    fields: {
-      declare: (0, e.validateOptional)(t),
-      const: (0, e.validateOptional)(t),
-      id: (0, e.validateType)("Identifier"),
-      members: (0, e.validateArrayOfType)("TSEnumMember"),
-      initializer: (0, e.validateOptionalType)("Expression")
-    }
-  }), a("TSEnumMember", {
-    visitor: ["id", "initializer"],
-    fields: {
-      id: (0, e.validateType)(["Identifier", "StringLiteral"]),
-      initializer: (0, e.validateOptionalType)("Expression")
-    }
-  }), a("TSModuleDeclaration", {
-    aliases: ["Statement", "Declaration"],
-    visitor: ["id", "body"],
-    fields: {
-      declare: (0, e.validateOptional)(t),
-      global: (0, e.validateOptional)(t),
-      id: (0, e.validateType)(["Identifier", "StringLiteral"]),
-      body: (0, e.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
-    }
-  }), a("TSModuleBlock", {
-    aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"],
-    visitor: ["body"],
-    fields: {
-      body: (0, e.validateArrayOfType)("Statement")
-    }
-  }), a("TSImportType", {
-    aliases: ["TSType"],
-    visitor: ["argument", "qualifier", "typeParameters"],
-    fields: {
-      argument: (0, e.validateType)("StringLiteral"),
-      qualifier: (0, e.validateOptionalType)("TSEntityName"),
-      typeParameters: (0, e.validateOptionalType)("TSTypeParameterInstantiation"),
-      options: {
-        validate: (0, e.assertNodeType)("Expression"),
-        optional: !0
-      }
-    }
-  }), a("TSImportEqualsDeclaration", {
-    aliases: ["Statement"],
-    visitor: ["id", "moduleReference"],
-    fields: {
-      isExport: (0, e.validate)(t),
-      id: (0, e.validateType)("Identifier"),
-      moduleReference: (0, e.validateType)(["TSEntityName", "TSExternalModuleReference"]),
-      importKind: {
-        validate: (0, e.assertOneOf)("type", "value"),
-        optional: !0
-      }
-    }
-  }), a("TSExternalModuleReference", {
-    visitor: ["expression"],
-    fields: {
-      expression: (0, e.validateType)("StringLiteral")
-    }
-  }), a("TSNonNullExpression", {
-    aliases: ["Expression", "LVal", "PatternLike"],
-    visitor: ["expression"],
-    fields: {
-      expression: (0, e.validateType)("Expression")
-    }
-  }), a("TSExportAssignment", {
-    aliases: ["Statement"],
-    visitor: ["expression"],
-    fields: {
-      expression: (0, e.validateType)("Expression")
-    }
-  }), a("TSNamespaceExportDeclaration", {
-    aliases: ["Statement"],
-    visitor: ["id"],
-    fields: {
-      id: (0, e.validateType)("Identifier")
-    }
-  }), a("TSTypeAnnotation", {
-    visitor: ["typeAnnotation"],
-    fields: {
-      typeAnnotation: {
-        validate: (0, e.assertNodeType)("TSType")
-      }
-    }
-  }), a("TSTypeParameterInstantiation", {
-    visitor: ["params"],
-    fields: {
-      params: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("TSType")))
-      }
-    }
-  }), a("TSTypeParameterDeclaration", {
-    visitor: ["params"],
-    fields: {
-      params: {
-        validate: (0, e.chain)((0, e.assertValueType)("array"), (0, e.assertEach)((0, e.assertNodeType)("TSTypeParameter")))
-      }
-    }
-  }), a("TSTypeParameter", {
-    builder: ["constraint", "default", "name"],
-    visitor: ["constraint", "default"],
-    fields: {
-      name: {
-        validate: (0, e.assertValueType)("string")
-      },
-      in: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      out: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      const: {
-        validate: (0, e.assertValueType)("boolean"),
-        optional: !0
-      },
-      constraint: {
-        validate: (0, e.assertNodeType)("TSType"),
-        optional: !0
-      },
-      default: {
-        validate: (0, e.assertNodeType)("TSType"),
-        optional: !0
-      }
-    }
-  }), v;
-}
-export {
-  L as __require
-};