tungsten 0.4.12 → 0.4.13

package/vendor/babel-preset-react.js

@@ -0,0 +1,872 @@
+import { createRequire as __tungstenCreateRequire } from 'node:module';
+const require = __tungstenCreateRequire(import.meta.url);
+import { r as requireLib$6 } from './chunk-B_NeooyV.js';
+import { a as requireLib$5, r as requireLib$7, b as requireLib$8, c as requireLib$9, d as requireLib$a } from './chunk-C3fcZDjl.js';
+import require$$0 from 'path';
+import './chunk-C9FSKeSx.js';
+import './chunk-CPArXGxa.js';
+import './chunk-C12hSZn7.js';
+import './chunk-1TN2rK3j.js';
+import 'tty';
+import 'util';
+import 'os';
+import './chunk-C3YkUGz5.js';
+import './chunk-1UuLTU0U.js';
+import 'assert';
+import 'fs';
+import 'url';
+import 'module';
+import 'process';
+import 'v8';
+
+var lib$4 = {};
+
+var lib$3 = {};
+
+var createPlugin = {};
+
+var hasRequiredCreatePlugin;
+
+function requireCreatePlugin () {
+	if (hasRequiredCreatePlugin) return createPlugin;
+	hasRequiredCreatePlugin = 1;
+
+	Object.defineProperty(createPlugin, "__esModule", {
+	  value: true
+	});
+	createPlugin.default = createPlugin$1;
+	var _pluginSyntaxJsx = requireLib$5();
+	var _helperPluginUtils = requireLib$6();
+	var _core = requireLib$7();
+	var _helperModuleImports = requireLib$8();
+	var _helperAnnotateAsPure = requireLib$9();
+	const DEFAULT = {
+	  importSource: "react",
+	  pragma: "React.createElement",
+	  pragmaFrag: "React.Fragment"
+	};
+	const JSX_SOURCE_ANNOTATION_REGEX = /^\s*(?:\*\s*)?@jsxImportSource\s+(\S+)\s*$/m;
+	const JSX_RUNTIME_ANNOTATION_REGEX = /^\s*(?:\*\s*)?@jsxRuntime\s+(\S+)\s*$/m;
+	const JSX_ANNOTATION_REGEX = /^\s*(?:\*\s*)?@jsx\s+(\S+)\s*$/m;
+	const JSX_FRAG_ANNOTATION_REGEX = /^\s*(?:\*\s*)?@jsxFrag\s+(\S+)\s*$/m;
+	const get = (pass, name) => pass.get(`@babel/plugin-react-jsx/${name}`);
+	const set = (pass, name, v) => pass.set(`@babel/plugin-react-jsx/${name}`, v);
+	function hasProto(node) {
+	  return node.properties.some(value => _core.types.isObjectProperty(value, {
+	    computed: false,
+	    shorthand: false
+	  }) && (_core.types.isIdentifier(value.key, {
+	    name: "__proto__"
+	  }) || _core.types.isStringLiteral(value.key, {
+	    value: "__proto__"
+	  })));
+	}
+	function createPlugin$1({
+	  name,
+	  development
+	}) {
+	  return (0, _helperPluginUtils.declare)((_, options) => {
+	    const {
+	      pure: PURE_ANNOTATION,
+	      throwIfNamespace = true,
+	      filter,
+	      runtime: RUNTIME_DEFAULT = development ? "automatic" : "classic",
+	      importSource: IMPORT_SOURCE_DEFAULT = DEFAULT.importSource,
+	      pragma: PRAGMA_DEFAULT = DEFAULT.pragma,
+	      pragmaFrag: PRAGMA_FRAG_DEFAULT = DEFAULT.pragmaFrag
+	    } = options;
+	    var {
+	      useSpread = false,
+	      useBuiltIns = false
+	    } = options;
+	    if (RUNTIME_DEFAULT === "classic") {
+	      if (typeof useSpread !== "boolean") {
+	        throw new Error("transform-react-jsx currently only accepts a boolean option for " + "useSpread (defaults to false)");
+	      }
+	      if (typeof useBuiltIns !== "boolean") {
+	        throw new Error("transform-react-jsx currently only accepts a boolean option for " + "useBuiltIns (defaults to false)");
+	      }
+	      if (useSpread && useBuiltIns) {
+	        throw new Error("transform-react-jsx currently only accepts useBuiltIns or useSpread " + "but not both");
+	      }
+	    }
+	    let commentsNode = null;
+	    return {
+	      name,
+	      inherits: _pluginSyntaxJsx.default,
+	      visitor: {
+	        JSXNamespacedName(path) {
+	          if (throwIfNamespace) {
+	            throw path.buildCodeFrameError(`Namespace tags are not supported by default. React's JSX doesn't support namespace tags. \
+You can set \`throwIfNamespace: false\` to bypass this warning.`);
+	          }
+	        },
+	        JSXSpreadChild(path) {
+	          throw path.buildCodeFrameError("Spread children are not supported in React.");
+	        },
+	        Program: {
+	          enter(path, state) {
+	            const {
+	              file
+	            } = state;
+	            let runtime = RUNTIME_DEFAULT;
+	            let source = IMPORT_SOURCE_DEFAULT;
+	            let pragma = PRAGMA_DEFAULT;
+	            let pragmaFrag = PRAGMA_FRAG_DEFAULT;
+	            let sourceSet = !!options.importSource;
+	            let pragmaSet = !!options.pragma;
+	            let pragmaFragSet = !!options.pragmaFrag;
+	            if (file.ast.comments) {
+	              for (const comment of file.ast.comments) {
+	                const sourceMatches = JSX_SOURCE_ANNOTATION_REGEX.exec(comment.value);
+	                if (sourceMatches) {
+	                  source = sourceMatches[1];
+	                  sourceSet = true;
+	                }
+	                const runtimeMatches = JSX_RUNTIME_ANNOTATION_REGEX.exec(comment.value);
+	                if (runtimeMatches) {
+	                  runtime = runtimeMatches[1];
+	                }
+	                const jsxMatches = JSX_ANNOTATION_REGEX.exec(comment.value);
+	                if (jsxMatches) {
+	                  pragma = jsxMatches[1];
+	                  pragmaSet = true;
+	                }
+	                const jsxFragMatches = JSX_FRAG_ANNOTATION_REGEX.exec(comment.value);
+	                if (jsxFragMatches) {
+	                  pragmaFrag = jsxFragMatches[1];
+	                  pragmaFragSet = true;
+	                }
+	              }
+	            }
+	            set(state, "runtime", runtime);
+	            if (runtime === "classic") {
+	              if (sourceSet) {
+	                throw path.buildCodeFrameError(`importSource cannot be set when runtime is classic.`);
+	              }
+	              const createElement = toMemberExpression(pragma);
+	              const fragment = toMemberExpression(pragmaFrag);
+	              set(state, "id/createElement", () => _core.types.cloneNode(createElement));
+	              set(state, "id/fragment", () => _core.types.cloneNode(fragment));
+	              set(state, "defaultPure", pragma === DEFAULT.pragma);
+	            } else if (runtime === "automatic") {
+	              if (pragmaSet || pragmaFragSet) {
+	                throw path.buildCodeFrameError(`pragma and pragmaFrag cannot be set when runtime is automatic.`);
+	              }
+	              const define = (name, id) => set(state, name, createImportLazily(state, path, id, source));
+	              define("id/jsx", development ? "jsxDEV" : "jsx");
+	              define("id/jsxs", development ? "jsxDEV" : "jsxs");
+	              define("id/createElement", "createElement");
+	              define("id/fragment", "Fragment");
+	              set(state, "defaultPure", source === DEFAULT.importSource);
+	            } else {
+	              throw path.buildCodeFrameError(`Runtime must be either "classic" or "automatic".`);
+	            }
+	            if (development) {
+	              function isDerivedClass(classNode) {
+	                return classNode.superClass !== null;
+	              }
+	              function isThisAllowed(parents) {
+	                let i = parents.length - 1;
+	                do {
+	                  const {
+	                    node
+	                  } = parents[i];
+	                  if (_core.types.isFunctionParent(node) && !_core.types.isArrowFunctionExpression(node)) {
+	                    if (!_core.types.isMethod(node)) {
+	                      return true;
+	                    }
+	                    if (node.kind !== "constructor") {
+	                      return true;
+	                    }
+	                    return !isDerivedClass(parents[i - 2].node);
+	                  }
+	                  if (_core.types.isTSModuleBlock(node)) {
+	                    return false;
+	                  }
+	                } while (i-- > 0);
+	                return true;
+	              }
+	              let fileNameIdentifier;
+	              function makeSource(node) {
+	                const location = node.loc;
+	                if (!location) {
+	                  return path.scope.buildUndefinedNode();
+	                }
+	                if (!fileNameIdentifier) {
+	                  fileNameIdentifier = path.scope.generateUidIdentifier("_jsxFileName");
+	                }
+	                return makeTrace(_core.types.cloneNode(fileNameIdentifier), location.start.line, location.start.column);
+	              }
+	              function makeTrace(fileNameIdentifier, lineNumber, column0Based) {
+	                const fileLineLiteral = lineNumber != null ? _core.types.numericLiteral(lineNumber) : _core.types.nullLiteral();
+	                const fileColumnLiteral = column0Based != null ? _core.types.numericLiteral(column0Based + 1) : _core.types.nullLiteral();
+	                return _core.template.expression.ast`{
+                    fileName: ${fileNameIdentifier},
+                    lineNumber: ${fileLineLiteral},
+                    columnNumber: ${fileColumnLiteral},
+                  }`;
+	              }
+	              _core.types.traverse(path.node, {
+	                enter(node, parents) {
+	                  if (!_core.types.isJSXOpeningElement(node)) {
+	                    return;
+	                  }
+	                  const attributes = node.attributes;
+	                  if (isThisAllowed(parents)) {
+	                    attributes.push(_core.types.jsxAttribute(_core.types.jsxIdentifier("__self"), _core.types.jsxExpressionContainer(_core.types.thisExpression())));
+	                  }
+	                  attributes.push(_core.types.jsxAttribute(_core.types.jsxIdentifier("__source"), _core.types.jsxExpressionContainer(makeSource(node))));
+	                }
+	              });
+	              if (fileNameIdentifier) {
+	                const {
+	                  filename = ""
+	                } = state;
+	                path.scope.push({
+	                  id: fileNameIdentifier,
+	                  init: _core.types.stringLiteral(filename)
+	                });
+	              }
+	            }
+	          }
+	        },
+	        JSXFragment: {
+	          exit(path, file) {
+	            let callExpr;
+	            if (get(file, "runtime") === "classic") {
+	              callExpr = buildCreateElementFragmentCall(path, file);
+	            } else {
+	              callExpr = buildJSXFragmentCall(path, file);
+	            }
+	            path.replaceWith(_core.types.inherits(callExpr, path.node));
+	          }
+	        },
+	        JSXElement: {
+	          exit(path, file) {
+	            let callExpr;
+	            if (get(file, "runtime") === "classic" || shouldUseCreateElement(path)) {
+	              callExpr = buildCreateElementCall(path, file);
+	            } else {
+	              callExpr = buildJSXElementCall(path, file);
+	            }
+	            path.replaceWith(_core.types.inherits(callExpr, path.node));
+	          }
+	        },
+	        JSXAttribute(path) {
+	          if (_core.types.isJSXElement(path.node.value)) {
+	            path.node.value = _core.types.jsxExpressionContainer(path.node.value);
+	          }
+	        }
+	      }
+	    };
+	    function call(pass, name, args) {
+	      const node = _core.types.callExpression(get(pass, `id/${name}`)(), args);
+	      if (PURE_ANNOTATION != null ? PURE_ANNOTATION : get(pass, "defaultPure")) (0, _helperAnnotateAsPure.default)(node);
+	      return node;
+	    }
+	    function shouldUseCreateElement(path) {
+	      const openingPath = path.get("openingElement");
+	      const attributes = openingPath.node.attributes;
+	      let seenPropsSpread = false;
+	      for (let i = 0; i < attributes.length; i++) {
+	        const attr = attributes[i];
+	        if (seenPropsSpread && _core.types.isJSXAttribute(attr) && attr.name.name === "key") {
+	          return true;
+	        } else if (_core.types.isJSXSpreadAttribute(attr)) {
+	          seenPropsSpread = true;
+	        }
+	      }
+	      return false;
+	    }
+	    function convertJSXIdentifier(node, parent) {
+	      if (_core.types.isJSXIdentifier(node)) {
+	        if (node.name === "this" && _core.types.isReferenced(node, parent)) {
+	          return _core.types.thisExpression();
+	        } else if (_core.types.isValidIdentifier(node.name, false)) {
+	          node.type = "Identifier";
+	          return node;
+	        } else {
+	          return _core.types.stringLiteral(node.name);
+	        }
+	      } else if (_core.types.isJSXMemberExpression(node)) {
+	        return _core.types.memberExpression(convertJSXIdentifier(node.object, node), convertJSXIdentifier(node.property, node));
+	      } else if (_core.types.isJSXNamespacedName(node)) {
+	        return _core.types.stringLiteral(`${node.namespace.name}:${node.name.name}`);
+	      }
+	      return node;
+	    }
+	    function convertAttributeValue(node) {
+	      if (_core.types.isJSXExpressionContainer(node)) {
+	        return node.expression;
+	      } else {
+	        return node;
+	      }
+	    }
+	    function processComments(attribs) {
+	      commentsNode = null;
+	      if (attribs.length && attribs[0].isJSXSpreadAttribute()) {
+	        const node = attribs[0].node.argument;
+	        if (node.leadingComments || node.trailingComments) {
+	          commentsNode = _core.types.cloneNode(node);
+	        }
+	      }
+	    }
+	    function accumulateAttribute(array, attribute) {
+	      if (_core.types.isJSXSpreadAttribute(attribute.node)) {
+	        const arg = attribute.node.argument;
+	        if (_core.types.isObjectExpression(arg) && !hasProto(arg)) {
+	          array.push(...arg.properties);
+	        } else {
+	          array.push(_core.types.spreadElement(arg));
+	        }
+	        return array;
+	      }
+	      const value = convertAttributeValue(attribute.node.name.name !== "key" ? attribute.node.value || _core.types.booleanLiteral(true) : attribute.node.value);
+	      if (attribute.node.name.name === "key" && value === null) {
+	        throw attribute.buildCodeFrameError('Please provide an explicit key value. Using "key" as a shorthand for "key={true}" is not allowed.');
+	      }
+	      if (_core.types.isStringLiteral(value) && !_core.types.isJSXExpressionContainer(attribute.node.value)) {
+	        var _value$extra;
+	        value.value = value.value.replace(/\n\s+/g, " ");
+	        (_value$extra = value.extra) == null || delete _value$extra.raw;
+	      }
+	      if (_core.types.isJSXNamespacedName(attribute.node.name)) {
+	        attribute.node.name = _core.types.stringLiteral(attribute.node.name.namespace.name + ":" + attribute.node.name.name.name);
+	      } else if (_core.types.isValidIdentifier(attribute.node.name.name, false)) {
+	        attribute.node.name.type = "Identifier";
+	      } else {
+	        attribute.node.name = _core.types.stringLiteral(attribute.node.name.name);
+	      }
+	      array.push(_core.types.inherits(_core.types.objectProperty(attribute.node.name, value), attribute.node));
+	      return array;
+	    }
+	    function buildChildrenProperty(children) {
+	      let childrenNode;
+	      if (children.length === 1) {
+	        childrenNode = children[0];
+	      } else if (children.length > 1) {
+	        childrenNode = _core.types.arrayExpression(children);
+	      } else {
+	        return undefined;
+	      }
+	      return _core.types.objectProperty(_core.types.identifier("children"), childrenNode);
+	    }
+	    function buildJSXElementCall(path, file) {
+	      const openingPath = path.get("openingElement");
+	      const args = [getTag(openingPath)];
+	      const attribsArray = [];
+	      const extracted = Object.create(null);
+	      for (const attr of openingPath.get("attributes")) {
+	        if (attr.isJSXAttribute() && _core.types.isJSXIdentifier(attr.node.name)) {
+	          const {
+	            name
+	          } = attr.node.name;
+	          switch (name) {
+	            case "__source":
+	            case "__self":
+	              if (extracted[name]) throw sourceSelfError(path, name);
+	            case "key":
+	              {
+	                const keyValue = convertAttributeValue(attr.node.value);
+	                if (keyValue === null) {
+	                  throw attr.buildCodeFrameError('Please provide an explicit key value. Using "key" as a shorthand for "key={true}" is not allowed.');
+	                }
+	                extracted[name] = keyValue;
+	                break;
+	              }
+	            default:
+	              attribsArray.push(attr);
+	          }
+	        } else {
+	          attribsArray.push(attr);
+	        }
+	      }
+	      const children = _core.types.react.buildChildren(path.node);
+	      let attribs;
+	      if (attribsArray.length || children.length) {
+	        attribs = buildJSXOpeningElementAttributes(attribsArray, children);
+	        if (commentsNode) {
+	          _core.types.inheritsComments(attribs, commentsNode);
+	        }
+	      } else {
+	        attribs = _core.types.objectExpression([]);
+	      }
+	      args.push(attribs);
+	      if (development) {
+	        var _extracted$key;
+	        args.push((_extracted$key = extracted.key) != null ? _extracted$key : path.scope.buildUndefinedNode(), _core.types.booleanLiteral(children.length > 1));
+	        if (extracted.__source) {
+	          args.push(extracted.__source);
+	          if (extracted.__self) args.push(extracted.__self);
+	        } else if (extracted.__self) {
+	          args.push(path.scope.buildUndefinedNode(), extracted.__self);
+	        }
+	      } else if (extracted.key !== undefined) {
+	        args.push(extracted.key);
+	      }
+	      return call(file, children.length > 1 ? "jsxs" : "jsx", args);
+	    }
+	    function buildJSXOpeningElementAttributes(attribs, children) {
+	      processComments(attribs);
+	      const props = attribs.reduce(accumulateAttribute, []);
+	      if ((children == null ? void 0 : children.length) > 0) {
+	        props.push(buildChildrenProperty(children));
+	      }
+	      return _core.types.objectExpression(props);
+	    }
+	    function buildJSXFragmentCall(path, file) {
+	      const args = [get(file, "id/fragment")()];
+	      const children = _core.types.react.buildChildren(path.node);
+	      args.push(_core.types.objectExpression(children.length > 0 ? [buildChildrenProperty(children)] : []));
+	      if (development) {
+	        args.push(path.scope.buildUndefinedNode(), _core.types.booleanLiteral(children.length > 1));
+	      }
+	      return call(file, children.length > 1 ? "jsxs" : "jsx", args);
+	    }
+	    function buildCreateElementFragmentCall(path, file) {
+	      if (filter && !filter(path.node, file)) return;
+	      return call(file, "createElement", [get(file, "id/fragment")(), _core.types.nullLiteral(), ..._core.types.react.buildChildren(path.node)]);
+	    }
+	    function buildCreateElementCall(path, file) {
+	      const openingPath = path.get("openingElement");
+	      return call(file, "createElement", [getTag(openingPath), buildCreateElementOpeningElementAttributes(file, path, openingPath.get("attributes")), ..._core.types.react.buildChildren(path.node)]);
+	    }
+	    function getTag(openingPath) {
+	      const tagExpr = convertJSXIdentifier(openingPath.node.name, openingPath.node);
+	      let tagName;
+	      if (_core.types.isIdentifier(tagExpr)) {
+	        tagName = tagExpr.name;
+	      } else if (_core.types.isStringLiteral(tagExpr)) {
+	        tagName = tagExpr.value;
+	      }
+	      if (_core.types.react.isCompatTag(tagName)) {
+	        return _core.types.stringLiteral(tagName);
+	      } else {
+	        return tagExpr;
+	      }
+	    }
+	    function buildCreateElementOpeningElementAttributes(file, path, attribs) {
+	      const runtime = get(file, "runtime");
+	      if (runtime !== "automatic") {
+	        const objs = [];
+	        processComments(attribs);
+	        const props = attribs.reduce(accumulateAttribute, []);
+	        if (!useSpread) {
+	          let start = 0;
+	          props.forEach((prop, i) => {
+	            if (_core.types.isSpreadElement(prop)) {
+	              if (i > start) {
+	                objs.push(_core.types.objectExpression(props.slice(start, i)));
+	              }
+	              objs.push(prop.argument);
+	              start = i + 1;
+	            }
+	          });
+	          if (props.length > start) {
+	            objs.push(_core.types.objectExpression(props.slice(start)));
+	          }
+	        } else if (props.length) {
+	          objs.push(_core.types.objectExpression(props));
+	        }
+	        if (!objs.length) {
+	          return _core.types.nullLiteral();
+	        }
+	        if (commentsNode) {
+	          _core.types.inheritsComments(objs[0], commentsNode);
+	        }
+	        if (objs.length === 1) {
+	          if (!(_core.types.isSpreadElement(props[0]) && _core.types.isObjectExpression(props[0].argument))) {
+	            return objs[0];
+	          }
+	        }
+	        if (!_core.types.isObjectExpression(objs[0])) {
+	          objs.unshift(_core.types.objectExpression([]));
+	        }
+	        const helper = useBuiltIns ? _core.types.memberExpression(_core.types.identifier("Object"), _core.types.identifier("assign")) : file.addHelper("extends");
+	        return _core.types.callExpression(helper, objs);
+	      }
+	      const props = [];
+	      const found = Object.create(null);
+	      processComments(attribs);
+	      for (const attr of attribs) {
+	        const {
+	          node
+	        } = attr;
+	        const name = _core.types.isJSXAttribute(node) && _core.types.isJSXIdentifier(node.name) && node.name.name;
+	        if (runtime === "automatic" && (name === "__source" || name === "__self")) {
+	          if (found[name]) throw sourceSelfError(path, name);
+	          found[name] = true;
+	        }
+	        accumulateAttribute(props, attr);
+	      }
+	      const ret = props.length === 1 && _core.types.isSpreadElement(props[0]) && !_core.types.isObjectExpression(props[0].argument) ? props[0].argument : props.length > 0 ? _core.types.objectExpression(props) : _core.types.nullLiteral();
+	      if (commentsNode) {
+	        _core.types.inheritsComments(ret, commentsNode);
+	      }
+	      return ret;
+	    }
+	  });
+	  function getSource(source, importName) {
+	    switch (importName) {
+	      case "Fragment":
+	        return `${source}/${development ? "jsx-dev-runtime" : "jsx-runtime"}`;
+	      case "jsxDEV":
+	        return `${source}/jsx-dev-runtime`;
+	      case "jsx":
+	      case "jsxs":
+	        return `${source}/jsx-runtime`;
+	      case "createElement":
+	        return source;
+	    }
+	  }
+	  function createImportLazily(pass, path, importName, source) {
+	    return () => {
+	      const actualSource = getSource(source, importName);
+	      if ((0, _helperModuleImports.isModule)(path)) {
+	        let reference = get(pass, `imports/${importName}`);
+	        if (reference) return _core.types.cloneNode(reference);
+	        reference = (0, _helperModuleImports.addNamed)(path, importName, actualSource, {
+	          importedInterop: "uncompiled",
+	          importPosition: "after"
+	        });
+	        set(pass, `imports/${importName}`, reference);
+	        return reference;
+	      } else {
+	        let reference = get(pass, `requires/${actualSource}`);
+	        if (reference) {
+	          reference = _core.types.cloneNode(reference);
+	        } else {
+	          reference = (0, _helperModuleImports.addNamespace)(path, actualSource, {
+	            importedInterop: "uncompiled"
+	          });
+	          set(pass, `requires/${actualSource}`, reference);
+	        }
+	        return _core.types.memberExpression(reference, _core.types.identifier(importName));
+	      }
+	    };
+	  }
+	}
+	function toMemberExpression(id) {
+	  return id.split(".").map(name => _core.types.identifier(name)).reduce((object, property) => _core.types.memberExpression(object, property));
+	}
+	function sourceSelfError(path, name) {
+	  const pluginName = `transform-react-jsx-${name.slice(2)}`;
+	  return path.buildCodeFrameError(`Duplicate ${name} prop found. You are most likely using the deprecated ${pluginName} Babel plugin. Both __source and __self are automatically set when using the automatic runtime. Please remove transform-react-jsx-source and transform-react-jsx-self from your Babel config.`);
+	}
+
+	
+	return createPlugin;
+}
+
+var hasRequiredLib$4;
+
+function requireLib$4 () {
+	if (hasRequiredLib$4) return lib$3;
+	hasRequiredLib$4 = 1;
+
+	Object.defineProperty(lib$3, "__esModule", {
+	  value: true
+	});
+	lib$3.default = void 0;
+	var _createPlugin = requireCreatePlugin();
+	lib$3.default = (0, _createPlugin.default)({
+	  name: "transform-react-jsx",
+	  development: false
+	});
+
+	
+	return lib$3;
+}
+
+var lib$2 = {};
+
+var development = {};
+
+var hasRequiredDevelopment;
+
+function requireDevelopment () {
+	if (hasRequiredDevelopment) return development;
+	hasRequiredDevelopment = 1;
+
+	Object.defineProperty(development, "__esModule", {
+	  value: true
+	});
+	development.default = void 0;
+	var _createPlugin = requireCreatePlugin();
+	development.default = (0, _createPlugin.default)({
+	  name: "transform-react-jsx/development",
+	  development: true
+	});
+
+	
+	return development;
+}
+
+var hasRequiredLib$3;
+
+function requireLib$3 () {
+	if (hasRequiredLib$3) return lib$2;
+	hasRequiredLib$3 = 1;
+
+	Object.defineProperty(lib$2, "__esModule", {
+	  value: true
+	});
+	lib$2.default = void 0;
+	var _development = requireDevelopment();
+	lib$2.default = _development.default;
+
+	
+	return lib$2;
+}
+
+var lib$1 = {};
+
+var hasRequiredLib$2;
+
+function requireLib$2 () {
+	if (hasRequiredLib$2) return lib$1;
+	hasRequiredLib$2 = 1;
+
+	Object.defineProperty(lib$1, "__esModule", {
+	  value: true
+	});
+	lib$1.default = void 0;
+	var _helperPluginUtils = requireLib$6();
+	var _path = require$$0;
+	var _core = requireLib$7();
+	lib$1.default = (0, _helperPluginUtils.declare)(api => {
+	  api.assertVersion(7);
+	  function addDisplayName(id, call) {
+	    const props = call.arguments[0].properties;
+	    let safe = true;
+	    for (let i = 0; i < props.length; i++) {
+	      const prop = props[i];
+	      if (_core.types.isSpreadElement(prop)) {
+	        continue;
+	      }
+	      const key = _core.types.toComputedKey(prop);
+	      if (_core.types.isStringLiteral(key, {
+	        value: "displayName"
+	      })) {
+	        safe = false;
+	        break;
+	      }
+	    }
+	    if (safe) {
+	      props.unshift(_core.types.objectProperty(_core.types.identifier("displayName"), _core.types.stringLiteral(id)));
+	    }
+	  }
+	  const isCreateClassCallExpression = _core.types.buildMatchMemberExpression("React.createClass");
+	  const isCreateClassAddon = callee => _core.types.isIdentifier(callee, {
+	    name: "createReactClass"
+	  });
+	  function isCreateClass(node) {
+	    if (!node || !_core.types.isCallExpression(node)) return false;
+	    if (!isCreateClassCallExpression(node.callee) && !isCreateClassAddon(node.callee)) {
+	      return false;
+	    }
+	    const args = node.arguments;
+	    if (args.length !== 1) return false;
+	    const first = args[0];
+	    if (!_core.types.isObjectExpression(first)) return false;
+	    return true;
+	  }
+	  return {
+	    name: "transform-react-display-name",
+	    visitor: {
+	      ExportDefaultDeclaration({
+	        node
+	      }, state) {
+	        if (isCreateClass(node.declaration)) {
+	          const filename = state.filename || "unknown";
+	          let displayName = _path.basename(filename, _path.extname(filename));
+	          if (displayName === "index") {
+	            displayName = _path.basename(_path.dirname(filename));
+	          }
+	          addDisplayName(displayName, node.declaration);
+	        }
+	      },
+	      CallExpression(path) {
+	        const {
+	          node
+	        } = path;
+	        if (!isCreateClass(node)) return;
+	        let id;
+	        path.find(function (path) {
+	          if (path.isAssignmentExpression()) {
+	            id = path.node.left;
+	          } else if (path.isObjectProperty()) {
+	            id = path.node.key;
+	          } else if (path.isVariableDeclarator()) {
+	            id = path.node.id;
+	          } else if (path.isStatement()) {
+	            return true;
+	          }
+	          if (id) return true;
+	        });
+	        if (!id) return;
+	        if (_core.types.isMemberExpression(id)) {
+	          id = id.property;
+	        }
+	        if (_core.types.isIdentifier(id)) {
+	          addDisplayName(id.name, node);
+	        }
+	      }
+	    }
+	  };
+	});
+
+	
+	return lib$1;
+}
+
+var lib = {};
+
+var hasRequiredLib$1;
+
+function requireLib$1 () {
+	if (hasRequiredLib$1) return lib;
+	hasRequiredLib$1 = 1;
+
+	Object.defineProperty(lib, "__esModule", {
+	  value: true
+	});
+	lib.default = void 0;
+	var _helperPluginUtils = requireLib$6();
+	var _helperAnnotateAsPure = requireLib$9();
+	var _core = requireLib$7();
+	const PURE_CALLS = [["react", new Set(["cloneElement", "createContext", "createElement", "createFactory", "createRef", "forwardRef", "isValidElement", "memo", "lazy"])], ["react-dom", new Set(["createPortal"])]];
+	lib.default = (0, _helperPluginUtils.declare)(api => {
+	  api.assertVersion(7);
+	  return {
+	    name: "transform-react-pure-annotations",
+	    visitor: {
+	      CallExpression(path) {
+	        if (isReactCall(path)) {
+	          (0, _helperAnnotateAsPure.default)(path);
+	        }
+	      }
+	    }
+	  };
+	});
+	function isReactCall(path) {
+	  const calleePath = path.get("callee");
+	  if (!calleePath.isMemberExpression()) {
+	    for (const [module, methods] of PURE_CALLS) {
+	      for (const method of methods) {
+	        if (calleePath.referencesImport(module, method)) {
+	          return true;
+	        }
+	      }
+	    }
+	    return false;
+	  }
+	  const object = calleePath.get("object");
+	  const callee = calleePath.node;
+	  if (!callee.computed && _core.types.isIdentifier(callee.property)) {
+	    const propertyName = callee.property.name;
+	    for (const [module, methods] of PURE_CALLS) {
+	      if (object.referencesImport(module, "default") || object.referencesImport(module, "*")) {
+	        return methods.has(propertyName);
+	      }
+	    }
+	  }
+	  return false;
+	}
+
+	
+	return lib;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib$4;
+	hasRequiredLib = 1;
+
+	Object.defineProperty(lib$4, '__esModule', { value: true });
+
+	var helperPluginUtils = requireLib$6();
+	var transformReactJSX = requireLib$4();
+	var transformReactJSXDevelopment = requireLib$3();
+	var transformReactDisplayName = requireLib$2();
+	var transformReactPure = requireLib$1();
+	var helperValidatorOption = requireLib$a();
+
+	function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+	var transformReactJSX__default = /*#__PURE__*/_interopDefault(transformReactJSX);
+	var transformReactJSXDevelopment__default = /*#__PURE__*/_interopDefault(transformReactJSXDevelopment);
+	var transformReactDisplayName__default = /*#__PURE__*/_interopDefault(transformReactDisplayName);
+	var transformReactPure__default = /*#__PURE__*/_interopDefault(transformReactPure);
+
+	new helperValidatorOption.OptionValidator("@babel/preset-react");
+	function normalizeOptions(options = {}) {
+	  {
+	    let {
+	      pragma,
+	      pragmaFrag
+	    } = options;
+	    const {
+	      pure,
+	      throwIfNamespace = true,
+	      runtime = "classic",
+	      importSource,
+	      useBuiltIns,
+	      useSpread
+	    } = options;
+	    if (runtime === "classic") {
+	      pragma = pragma || "React.createElement";
+	      pragmaFrag = pragmaFrag || "React.Fragment";
+	    }
+	    const development = options.development == null ? undefined : !!options.development;
+	    return {
+	      development,
+	      importSource,
+	      pragma,
+	      pragmaFrag,
+	      pure,
+	      runtime,
+	      throwIfNamespace,
+	      useBuiltIns,
+	      useSpread
+	    };
+	  }
+	}
+
+	var index = helperPluginUtils.declarePreset((api, opts) => {
+	  api.assertVersion(7);
+	  const {
+	    development = false,
+	    importSource,
+	    pragma,
+	    pragmaFrag,
+	    pure,
+	    runtime,
+	    throwIfNamespace
+	  } = normalizeOptions(opts);
+	  return {
+	    plugins: [[development ? transformReactJSXDevelopment__default.default : transformReactJSX__default.default, {
+	      importSource,
+	      pragma,
+	      pragmaFrag,
+	      runtime,
+	      throwIfNamespace,
+	      pure,
+	      useBuiltIns: !!opts.useBuiltIns,
+	      useSpread: opts.useSpread
+	    }], transformReactDisplayName__default.default, pure !== false && transformReactPure__default.default].filter(Boolean)
+	  };
+	});
+
+	lib$4.default = index;
+	
+	return lib$4;
+}
+
+var libExports = requireLib();
+
+const __v0 = libExports["__esModule"];
+
+export { __v0 as __esModule, libExports as default };