mcarman
/
React_Client_App_Access
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 0 Вики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Комити
1 Грана
84 MiB
 
 
 
 
Грана: master
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
React_Client_App_Access/node_modules/babel-plugin-emotion/dist/babel-plugin-emotion.cjs.pr...

547 lines
29 KiB
Датотека Пермалинк Blame Историја 

  1. "use strict";

  2. 

  3. function _interopDefault(ex) {

  4.   return ex && "object" == typeof ex && "default" in ex ? ex.default : ex;

  5. }

  6. 

  7. Object.defineProperty(exports, "__esModule", {

  8.   value: !0

  9. });

  10. 

  11. var nodePath = _interopDefault(require("path")), sourceMap = require("source-map"), convert = _interopDefault(require("convert-source-map")), findRoot = _interopDefault(require("find-root")), memoize = _interopDefault(require("@emotion/memoize")), hashString = _interopDefault(require("@emotion/hash")), escapeRegexp = _interopDefault(require("escape-string-regexp")), serialize = require("@emotion/serialize"), helperModuleImports = require("@babel/helper-module-imports"), babelPluginMacros = require("babel-plugin-macros"), multilineCommentRegex = /\/\*[^!](.|[\r\n])*?\*\//g, lineCommentStart = /\/\//g, symbolRegex = /(\s*[;:{},]\s*)/g, countOccurences = function(str, substr) {

  12.   return str.split(substr).length - 1;

  13. }, reduceSubstr = function(substrs, join, predicate) {

  14.   var length = substrs.length, res = substrs[0];

  15.   if (1 === length) return res;

  16.   for (var i = 1; i < length && !predicate(res); i++) res += join + substrs[i];

  17.   return res;

  18. }, stripLineComment = function(line) {

  19.   return reduceSubstr(line.split(lineCommentStart), "//", function(str) {

  20.     return !str.endsWith(":") && countOccurences(str, "'") % 2 == 0 && countOccurences(str, '"') % 2 == 0 && countOccurences(str, "(") === countOccurences(str, ")");

  21.   });

  22. }, compressSymbols = function(code) {

  23.   return code.split(symbolRegex).reduce(function(str, fragment, index) {

  24.     return index % 2 == 0 ? str + fragment : countOccurences(str, "'") % 2 == 0 && countOccurences(str, '"') % 2 == 0 ? str + fragment.trim() : str + fragment;

  25.   }, "");

  26. }, isLineComment = function(line) {

  27.   return line.trim().startsWith("//");

  28. }, linebreakRegex = /[\r\n]\s*/g, spacesAndLinebreakRegex = /\s+|\n+/g;

  29. 

  30. function multilineReplacer(match) {

  31.   return match.indexOf("@") > -1 ? match.replace(spacesAndLinebreakRegex, " ").trim() : "\n";

  32. }

  33. 

  34. var minify = function(code) {

  35.   var newCode = code.replace(multilineCommentRegex, multilineReplacer).split(linebreakRegex).filter(function(line) {

  36.     return line.length > 0 && !isLineComment(line);

  37.   }).map(stripLineComment).join(" ");

  38.   return compressSymbols(newCode);

  39. };

  40. 

  41. function getExpressionsFromTemplateLiteral(node, t) {

  42.   var raw = createRawStringFromTemplateLiteral(node);

  43.   return replacePlaceholdersWithExpressions(minify(raw), node.expressions || [], t);

  44. }

  45. 

  46. var interleave = function(strings, interpolations) {

  47.   return interpolations.reduce(function(array, interp, i) {

  48.     return array.concat([ interp ], strings[i + 1]);

  49.   }, [ strings[0] ]);

  50. };

  51. 

  52. function getDynamicMatches(str) {

  53.   for (var match, re = /xxx(\d+)xxx/gm, matches = []; null !== (match = re.exec(str)); ) null !== match && matches.push({

  54.     value: match[0],

  55.     p1: parseInt(match[1], 10),

  56.     index: match.index

  57.   });

  58.   return matches;

  59. }

  60. 

  61. function replacePlaceholdersWithExpressions(str, expressions, t) {

  62.   var matches = getDynamicMatches(str);

  63.   if (0 === matches.length) return "" === str ? [] : [ t.stringLiteral(str) ];

  64.   var strings = [], finalExpressions = [], cursor = 0;

  65.   return matches.forEach(function(_ref, i) {

  66.     var value = _ref.value, p1 = _ref.p1, index = _ref.index, preMatch = str.substring(cursor, index);

  67.     cursor = cursor + preMatch.length + value.length, preMatch ? strings.push(t.stringLiteral(preMatch)) : 0 === i && strings.push(t.stringLiteral("")), 

  68.     finalExpressions.push(expressions[p1]), i === matches.length - 1 && strings.push(t.stringLiteral(str.substring(index + value.length)));

  69.   }), interleave(strings, finalExpressions).filter(function(node) {

  70.     return "" !== node.value;

  71.   });

  72. }

  73. 

  74. function createRawStringFromTemplateLiteral(quasi) {

  75.   var strs = quasi.quasis.map(function(x) {

  76.     return x.value.cooked;

  77.   });

  78.   return strs.reduce(function(arr, str, i) {

  79.     return arr.push(str), i !== strs.length - 1 && arr.push("xxx" + i + "xxx"), arr;

  80.   }, []).join("").trim();

  81. }

  82. 

  83. var invalidClassNameCharacters = /[!"#$%&'()*+,.\/:;<=>?@[\]^`|}~{]/g, sanitizeLabelPart = function(labelPart) {

  84.   return labelPart.trim().replace(invalidClassNameCharacters, "-");

  85. };

  86. 

  87. function getLabel(identifierName, autoLabel, labelFormat, filename) {

  88.   if (!identifierName || !autoLabel) return null;

  89.   if (!labelFormat) return sanitizeLabelPart(identifierName);

  90.   var parsedPath = nodePath.parse(filename), localDirname = nodePath.basename(parsedPath.dir), localFilename = parsedPath.name;

  91.   return "index" === localFilename && (localFilename = localDirname), labelFormat.replace(/\[local\]/gi, sanitizeLabelPart(identifierName)).replace(/\[filename\]/gi, sanitizeLabelPart(localFilename)).replace(/\[dirname\]/gi, sanitizeLabelPart(localDirname));

  92. }

  93. 

  94. function getLabelFromPath(path, state, t) {

  95.   return getLabel(getIdentifierName(path, t), void 0 !== state.opts.autoLabel && state.opts.autoLabel, state.opts.labelFormat, state.file.opts.filename);

  96. }

  97. 

  98. var pascalCaseRegex = /^[A-Z][A-Za-z]+/;

  99. 

  100. function getDeclaratorName(path, t) {

  101.   var parent = path.findParent(function(p) {

  102.     return p.isVariableDeclarator() || p.isFunctionDeclaration() || p.isFunctionExpression() || p.isArrowFunctionExpression() || p.isObjectProperty();

  103.   });

  104.   if (!parent) return "";

  105.   if (parent.isVariableDeclarator()) return t.isIdentifier(parent.node.id) ? parent.node.id.name : "";

  106.   if (parent.isFunctionDeclaration()) {

  107.     var _name = parent.node.id.name;

  108.     return pascalCaseRegex.test(_name) ? _name : "";

  109.   }

  110.   if (parent.isObjectProperty() && !parent.node.computed) return parent.node.key.name;

  111.   var variableDeclarator = path.findParent(function(p) {

  112.     return p.isVariableDeclarator();

  113.   });

  114.   if (!variableDeclarator) return "";

  115.   var name = variableDeclarator.node.id.name;

  116.   return pascalCaseRegex.test(name) ? name : "";

  117. }

  118. 

  119. function getIdentifierName(path, t) {

  120.   var classOrClassPropertyParent;

  121.   if (t.isObjectProperty(path.parentPath) && !1 === path.parentPath.node.computed && (t.isIdentifier(path.parentPath.node.key) || t.isStringLiteral(path.parentPath.node.key))) return path.parentPath.node.key.name || path.parentPath.node.key.value;

  122.   if (path && (classOrClassPropertyParent = path.findParent(function(p) {

  123.     return t.isClassProperty(p) || t.isClass(p);

  124.   })), classOrClassPropertyParent) {

  125.     if (t.isClassProperty(classOrClassPropertyParent) && !1 === classOrClassPropertyParent.node.computed && t.isIdentifier(classOrClassPropertyParent.node.key)) return classOrClassPropertyParent.node.key.name;

  126.     if (t.isClass(classOrClassPropertyParent) && classOrClassPropertyParent.node.id) return t.isIdentifier(classOrClassPropertyParent.node.id) ? classOrClassPropertyParent.node.id.name : "";

  127.   }

  128.   var declaratorName = getDeclaratorName(path, t);

  129.   return "_" === declaratorName.charAt(0) ? "" : declaratorName;

  130. }

  131. 

  132. function getGeneratorOpts(file) {

  133.   return file.opts.generatorOpts ? file.opts.generatorOpts : file.opts;

  134. }

  135. 

  136. function makeSourceMapGenerator(file) {

  137.   var generatorOpts = getGeneratorOpts(file), filename = generatorOpts.sourceFileName, generator = new sourceMap.SourceMapGenerator({

  138.     file: filename,

  139.     sourceRoot: generatorOpts.sourceRoot

  140.   });

  141.   return generator.setSourceContent(filename, file.code), generator;

  142. }

  143. 

  144. function getSourceMap(offset, state) {

  145.   var generator = makeSourceMapGenerator(state.file), generatorOpts = getGeneratorOpts(state.file);

  146.   return generatorOpts.sourceFileName && "unknown" !== generatorOpts.sourceFileName ? (generator.addMapping({

  147.     generated: {

  148.       line: 1,

  149.       column: 0

  150.     },

  151.     source: generatorOpts.sourceFileName,

  152.     original: offset

  153.   }), convert.fromObject(generator).toComment({

  154.     multiline: !0

  155.   })) : "";

  156. }

  157. 

  158. var hashArray = function(arr) {

  159.   return hashString(arr.join(""));

  160. }, unsafeRequire = require, getPackageRootPath = memoize(function(filename) {

  161.   return findRoot(filename);

  162. }), separator = new RegExp(escapeRegexp(nodePath.sep), "g"), normalizePath = function(path) {

  163.   return nodePath.normalize(path).replace(separator, "/");

  164. };

  165. 

  166. function getTargetClassName(state, t) {

  167.   void 0 === state.emotionTargetClassNameCount && (state.emotionTargetClassNameCount = 0);

  168.   var filename = state.file.opts.filename && "unknown" !== state.file.opts.filename ? state.file.opts.filename : "", moduleName = "", rootPath = filename;

  169.   try {

  170.     rootPath = getPackageRootPath(filename), moduleName = unsafeRequire(rootPath + "/package.json").name;

  171.   } catch (err) {}

  172.   var finalPath = filename === rootPath ? "root" : filename.slice(rootPath.length), positionInFile = state.emotionTargetClassNameCount++, stuffToHash = [ moduleName ];

  173.   return finalPath ? stuffToHash.push(normalizePath(finalPath)) : stuffToHash.push(state.file.code), 

  174.   "e" + hashArray(stuffToHash) + positionInFile;

  175. }

  176. 

  177. function simplifyObject(node, t) {

  178.   for (var finalString = "", i = 0; i < node.properties.length; i++) {

  179.     var _ref, property = node.properties[i];

  180.     if (!t.isObjectProperty(property) || property.computed || !t.isIdentifier(property.key) && !t.isStringLiteral(property.key) || !t.isStringLiteral(property.value) && !t.isNumericLiteral(property.value) && !t.isObjectExpression(property.value)) return node;

  181.     var key = property.key.name || property.key.value;

  182.     if ("styles" === key) return node;

  183.     if (t.isObjectExpression(property.value)) {

  184.       var simplifiedChild = simplifyObject(property.value, t);

  185.       if (!t.isStringLiteral(simplifiedChild)) return node;

  186.       finalString += key + "{" + simplifiedChild.value + "}";

  187.     } else {

  188.       var value = property.value.value;

  189.       finalString += serialize.serializeStyles([ (_ref = {}, _ref[key] = value, _ref) ]).styles;

  190.     }

  191.   }

  192.   return t.stringLiteral(finalString);

  193. }

  194. 

  195. function getTypeScriptMakeTemplateObjectPath(path) {

  196.   if (0 === path.node.arguments.length) return null;

  197.   var firstArgPath = path.get("arguments")[0];

  198.   return firstArgPath.isLogicalExpression() && firstArgPath.get("left").isIdentifier() && firstArgPath.get("right").isAssignmentExpression() && firstArgPath.get("right.right").isCallExpression() && firstArgPath.get("right.right.callee").isIdentifier() && firstArgPath.node.right.right.callee.name.includes("makeTemplateObject") && 2 === firstArgPath.node.right.right.arguments.length ? firstArgPath.get("right.right") : null;

  199. }

  200. 

  201. function isTaggedTemplateTranspiledByBabel(path) {

  202.   if (0 === path.node.arguments.length) return !1;

  203.   var firstArgPath = path.get("arguments")[0];

  204.   if (!firstArgPath.isCallExpression() || !firstArgPath.get("callee").isIdentifier()) return !1;

  205.   var calleeName = firstArgPath.node.callee.name;

  206.   if (!calleeName.includes("templateObject")) return !1;

  207.   var bindingPath = path.scope.getBinding(calleeName).path;

  208.   if (!bindingPath.isFunction()) return !1;

  209.   var functionBody = bindingPath.get("body.body");

  210.   if (!functionBody[0].isVariableDeclaration()) return !1;

  211.   var declarationInit = functionBody[0].get("declarations")[0].get("init");

  212.   if (!declarationInit.isCallExpression()) return !1;

  213.   var declarationInitArguments = declarationInit.get("arguments");

  214.   return !(0 === declarationInitArguments.length || declarationInitArguments.length > 2 || declarationInitArguments.some(function(argPath) {

  215.     return !argPath.isArrayExpression();

  216.   }));

  217. }

  218. 

  219. var appendStringToArguments = function(path, string, t) {

  220.   if (string) {

  221.     var args = path.node.arguments;

  222.     if (t.isStringLiteral(args[args.length - 1])) args[args.length - 1].value += string; else {

  223.       var makeTemplateObjectCallPath = getTypeScriptMakeTemplateObjectPath(path);

  224.       makeTemplateObjectCallPath ? makeTemplateObjectCallPath.get("arguments").forEach(function(argPath) {

  225.         var elements = argPath.get("elements"), lastElement = elements[elements.length - 1];

  226.         lastElement.replaceWith(t.stringLiteral(lastElement.node.value + string));

  227.       }) : isTaggedTemplateTranspiledByBabel(path) || args.push(t.stringLiteral(string));

  228.     }

  229.   }

  230. }, joinStringLiterals = function(expressions, t) {

  231.   return expressions.reduce(function(finalExpressions, currentExpression, i) {

  232.     return t.isStringLiteral(currentExpression) && t.isStringLiteral(finalExpressions[finalExpressions.length - 1]) ? finalExpressions[finalExpressions.length - 1].value += currentExpression.value : finalExpressions.push(currentExpression), 

  233.     finalExpressions;

  234.   }, []);

  235. }, CSS_OBJECT_STRINGIFIED_ERROR = "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).", cloneNode = function(t, node) {

  236.   return "function" == typeof t.cloneNode ? t.cloneNode(node) : t.cloneDeep(node);

  237. };

  238. 

  239. function createSourceMapConditional(t, production, development) {

  240.   return t.conditionalExpression(t.binaryExpression("===", t.memberExpression(t.memberExpression(t.identifier("process"), t.identifier("env")), t.identifier("NODE_ENV")), t.stringLiteral("production")), production, development);

  241. }

  242. 

  243. var transformExpressionWithStyles = function(_ref) {

  244.   var babel = _ref.babel, state = _ref.state, path = _ref.path, shouldLabel = _ref.shouldLabel, _ref$sourceMap = _ref.sourceMap, sourceMap = void 0 === _ref$sourceMap ? "" : _ref$sourceMap, t = babel.types;

  245.   if (t.isTaggedTemplateExpression(path)) {

  246.     var expressions = getExpressionsFromTemplateLiteral(path.node.quasi, t);

  247.     state.emotionSourceMap && void 0 !== path.node.quasi.loc && (sourceMap = getSourceMap(path.node.quasi.loc.start, state)), 

  248.     path.replaceWith(t.callExpression(path.node.tag, expressions));

  249.   }

  250.   if (t.isCallExpression(path)) {

  251.     var canAppendStrings = path.node.arguments.every(function(arg) {

  252.       return "SpreadElement" !== arg.type;

  253.     });

  254.     if (canAppendStrings && shouldLabel) {

  255.       var label = getLabelFromPath(path, state, t);

  256.       label && appendStringToArguments(path, ";label:" + label + ";", t);

  257.     }

  258.     if (path.get("arguments").forEach(function(node) {

  259.       t.isObjectExpression(node) && node.replaceWith(simplifyObject(node.node, t));

  260.     }), path.node.arguments = joinStringLiterals(path.node.arguments, t), canAppendStrings && state.emotionSourceMap && !sourceMap && void 0 !== path.node.loc && (sourceMap = getSourceMap(path.node.loc.start, state)), 

  261.     1 === path.node.arguments.length && t.isStringLiteral(path.node.arguments[0])) {

  262.       var cssString = path.node.arguments[0].value, res = serialize.serializeStyles([ cssString ]), prodNode = t.objectExpression([ t.objectProperty(t.identifier("name"), t.stringLiteral(res.name)), t.objectProperty(t.identifier("styles"), t.stringLiteral(res.styles)) ]), node = prodNode;

  263.       if (sourceMap) {

  264.         if (!state.emotionStringifiedCssId) {

  265.           var uid = state.file.scope.generateUidIdentifier("__EMOTION_STRINGIFIED_CSS_ERROR__");

  266.           state.emotionStringifiedCssId = uid;

  267.           var cssObjectToString = t.functionDeclaration(uid, [], t.blockStatement([ t.returnStatement(t.stringLiteral(CSS_OBJECT_STRINGIFIED_ERROR)) ]));

  268.           cssObjectToString._compact = !0, state.file.path.unshiftContainer("body", [ cssObjectToString ]);

  269.         }

  270.         var devNode = t.objectExpression([ t.objectProperty(t.identifier("name"), t.stringLiteral(res.name)), t.objectProperty(t.identifier("styles"), t.stringLiteral(res.styles)), t.objectProperty(t.identifier("map"), t.stringLiteral(sourceMap)), t.objectProperty(t.identifier("toString"), cloneNode(t, state.emotionStringifiedCssId)) ]);

  271.         node = createSourceMapConditional(t, prodNode, devNode);

  272.       }

  273.       return node;

  274.     }

  275.     if (sourceMap) {

  276.       var lastIndex = path.node.arguments.length - 1, last = path.node.arguments[lastIndex], sourceMapConditional = createSourceMapConditional(t, t.stringLiteral(""), t.stringLiteral(sourceMap));

  277.       if (t.isStringLiteral(last)) path.node.arguments[lastIndex] = t.binaryExpression("+", last, sourceMapConditional); else {

  278.         var makeTemplateObjectCallPath = getTypeScriptMakeTemplateObjectPath(path);

  279.         if (makeTemplateObjectCallPath) {

  280.           var sourceMapId = state.file.scope.generateUidIdentifier("emotionSourceMap"), sourceMapDeclaration = t.variableDeclaration("var", [ t.variableDeclarator(sourceMapId, sourceMapConditional) ]);

  281.           sourceMapDeclaration._compact = !0, state.file.path.unshiftContainer("body", [ sourceMapDeclaration ]), 

  282.           makeTemplateObjectCallPath.get("arguments").forEach(function(argPath) {

  283.             var elements = argPath.get("elements"), lastElement = elements[elements.length - 1];

  284.             lastElement.replaceWith(t.binaryExpression("+", lastElement.node, cloneNode(t, sourceMapId)));

  285.           });

  286.         } else isTaggedTemplateTranspiledByBabel(path) || path.node.arguments.push(sourceMapConditional);

  287.       }

  288.     }

  289.   }

  290. }, getKnownProperties = function(t, node) {

  291.   return new Set(node.properties.filter(function(n) {

  292.     return t.isObjectProperty(n) && !n.computed;

  293.   }).map(function(n) {

  294.     return t.isIdentifier(n.key) ? n.key.name : n.key.value;

  295.   }));

  296. }, getStyledOptions = function(t, path, state) {

  297.   var args = path.node.arguments, optionsArgument = args.length >= 2 ? args[1] : null, properties = [], knownProperties = optionsArgument && t.isObjectExpression(optionsArgument) ? getKnownProperties(t, optionsArgument) : new Set();

  298.   knownProperties.has("target") || properties.push(t.objectProperty(t.identifier("target"), t.stringLiteral(getTargetClassName(state))));

  299.   var label = getLabelFromPath(path, state, t);

  300.   if (label && !knownProperties.has("label") && properties.push(t.objectProperty(t.identifier("label"), t.stringLiteral(label))), 

  301.   optionsArgument) {

  302.     if (!t.isObjectExpression(optionsArgument)) return t.callExpression(state.file.addHelper("extends"), [ t.objectExpression([]), t.objectExpression(properties), optionsArgument ]);

  303.     properties.unshift.apply(properties, optionsArgument.properties);

  304.   }

  305.   return t.objectExpression(properties);

  306. }, createEmotionMacro = function(instancePath) {

  307.   return babelPluginMacros.createMacro(function(_ref) {

  308.     var references = _ref.references, state = _ref.state, babel = _ref.babel;

  309.     _ref.isEmotionCall || (state.emotionSourceMap = !0);

  310.     var t = babel.types;

  311.     Object.keys(references).forEach(function(referenceKey) {

  312.       var isPure = !0, runtimeNode = helperModuleImports.addNamed(state.file.path, referenceKey, instancePath);

  313.       switch (referenceKey) {

  314.        case "injectGlobal":

  315.         isPure = !1;

  316. 

  317.        case "css":

  318.        case "keyframes":

  319.         references[referenceKey].reverse().forEach(function(reference) {

  320.           var path = reference.parentPath;

  321.           reference.replaceWith(t.cloneDeep(runtimeNode)), isPure && path.addComment("leading", "#__PURE__");

  322.           var node = transformExpressionWithStyles({

  323.             babel: babel,

  324.             state: state,

  325.             path: path,

  326.             shouldLabel: !0

  327.           });

  328.           node && (path.node.arguments[0] = node);

  329.         });

  330.         break;

  331. 

  332.        default:

  333.         references[referenceKey].reverse().forEach(function(reference) {

  334.           reference.replaceWith(t.cloneDeep(runtimeNode));

  335.         });

  336.       }

  337.     });

  338.   });

  339. }, createStyledMacro = function(_ref) {

  340.   var importPath = _ref.importPath, _ref$originalImportPa = _ref.originalImportPath, originalImportPath = void 0 === _ref$originalImportPa ? importPath : _ref$originalImportPa, isWeb = _ref.isWeb;

  341.   return babelPluginMacros.createMacro(function(_ref2) {

  342.     var references = _ref2.references, state = _ref2.state, babel = _ref2.babel;

  343.     _ref2.isEmotionCall || (state.emotionSourceMap = !0);

  344.     var t = babel.types;

  345.     if (references.default && references.default.length) {

  346.       var _styledIdentifier, originalImportPathStyledIdentifier, getStyledIdentifier = function() {

  347.         return void 0 === _styledIdentifier && (_styledIdentifier = helperModuleImports.addDefault(state.file.path, importPath, {

  348.           nameHint: "styled"

  349.         })), t.cloneDeep(_styledIdentifier);

  350.       }, getOriginalImportPathStyledIdentifier = function() {

  351.         return void 0 === originalImportPathStyledIdentifier && (originalImportPathStyledIdentifier = helperModuleImports.addDefault(state.file.path, originalImportPath, {

  352.           nameHint: "styled"

  353.         })), t.cloneDeep(originalImportPathStyledIdentifier);

  354.       };

  355.       importPath === originalImportPath && (getOriginalImportPathStyledIdentifier = getStyledIdentifier), 

  356.       references.default.forEach(function(reference) {

  357.         var isCall = !1;

  358.         if (t.isMemberExpression(reference.parent) && !1 === reference.parent.computed ? (isCall = !0, 

  359.         reference.parent.property.name.charCodeAt(0) > 96 ? reference.parentPath.replaceWith(t.callExpression(getStyledIdentifier(), [ t.stringLiteral(reference.parent.property.name) ])) : reference.replaceWith(getStyledIdentifier())) : reference.parentPath && reference.parentPath.parentPath && t.isCallExpression(reference.parentPath) && reference.parent.callee === reference.node ? (isCall = !0, 

  360.         reference.replaceWith(getStyledIdentifier())) : reference.replaceWith(getOriginalImportPathStyledIdentifier()), 

  361.         reference.parentPath && reference.parentPath.parentPath) {

  362.           var styledCallPath = reference.parentPath.parentPath, node = transformExpressionWithStyles({

  363.             path: styledCallPath,

  364.             state: state,

  365.             babel: babel,

  366.             shouldLabel: !1

  367.           });

  368.           node && isWeb && (styledCallPath.node.arguments[0] = node);

  369.         }

  370.         isCall && (reference.addComment("leading", "#__PURE__"), isWeb && (reference.parentPath.node.arguments[1] = getStyledOptions(t, reference.parentPath, state)));

  371.       });

  372.     }

  373.     Object.keys(references).filter(function(x) {

  374.       return "default" !== x;

  375.     }).forEach(function(referenceKey) {

  376.       var runtimeNode = helperModuleImports.addNamed(state.file.path, referenceKey, importPath);

  377.       references[referenceKey].reverse().forEach(function(reference) {

  378.         reference.replaceWith(t.cloneDeep(runtimeNode));

  379.       });

  380.     });

  381.   });

  382. }, transformCssCallExpression = function(_ref) {

  383.   var babel = _ref.babel, state = _ref.state, path = _ref.path, sourceMap = _ref.sourceMap, node = transformExpressionWithStyles({

  384.     babel: babel,

  385.     state: state,

  386.     path: path,

  387.     shouldLabel: !0,

  388.     sourceMap: sourceMap

  389.   });

  390.   node ? (path.replaceWith(node), path.hoist()) : path.isCallExpression() && path.addComment("leading", "#__PURE__");

  391. }, cssMacro = babelPluginMacros.createMacro(function(_ref2) {

  392.   var references = _ref2.references, state = _ref2.state, babel = _ref2.babel;

  393.   _ref2.isEmotionCall || (state.emotionSourceMap = !0);

  394.   var t = babel.types;

  395.   references.default && references.default.length && references.default.reverse().forEach(function(reference) {

  396.     state.cssIdentifier || (state.cssIdentifier = helperModuleImports.addDefault(reference, "@emotion/css", {

  397.       nameHint: "css"

  398.     })), reference.replaceWith(t.cloneDeep(state.cssIdentifier)), transformCssCallExpression({

  399.       babel: babel,

  400.       state: state,

  401.       path: reference.parentPath

  402.     });

  403.   }), Object.keys(references).filter(function(x) {

  404.     return "default" !== x;

  405.   }).forEach(function(referenceKey) {

  406.     var runtimeNode = helperModuleImports.addNamed(state.file.path, referenceKey, "@emotion/css", {

  407.       nameHint: referenceKey

  408.     });

  409.     references[referenceKey].reverse().forEach(function(reference) {

  410.       reference.replaceWith(t.cloneDeep(runtimeNode));

  411.     });

  412.   });

  413. }), webStyledMacro = createStyledMacro({

  414.   importPath: "@emotion/styled-base",

  415.   originalImportPath: "@emotion/styled",

  416.   isWeb: !0

  417. }), nativeStyledMacro = createStyledMacro({

  418.   importPath: "@emotion/native",

  419.   originalImportPath: "@emotion/native",

  420.   isWeb: !1

  421. }), primitivesStyledMacro = createStyledMacro({

  422.   importPath: "@emotion/primitives",

  423.   originalImportPath: "@emotion/primitives",

  424.   isWeb: !1

  425. }), macros = {

  426.   createEmotionMacro: createEmotionMacro,

  427.   css: cssMacro,

  428.   createStyledMacro: createStyledMacro

  429. }, emotionCoreMacroThatsNotARealMacro = function(_ref) {

  430.   var references = _ref.references, state = _ref.state, babel = _ref.babel;

  431.   Object.keys(references).forEach(function(refKey) {

  432.     "css" === refKey && references[refKey].forEach(function(path) {

  433.       transformCssCallExpression({

  434.         babel: babel,

  435.         state: state,

  436.         path: path.parentPath

  437.       });

  438.     });

  439.   });

  440. };

  441. 

  442. function getAbsolutePath(instancePath, rootPath) {

  443.   return "." === instancePath.charAt(0) && nodePath.resolve(rootPath, instancePath);

  444. }

  445. 

  446. function getInstancePathToCompare(instancePath, rootPath) {

  447.   var absolutePath = getAbsolutePath(instancePath, rootPath);

  448.   return !1 === absolutePath ? instancePath : absolutePath;

  449. }

  450. 

  451. function index(babel) {

  452.   var t = babel.types;

  453.   return {

  454.     name: "emotion",

  455.     inherits: require("babel-plugin-syntax-jsx"),

  456.     visitor: {

  457.       ImportDeclaration: function(path, state) {

  458.         var dirname = path.hub.file.opts.filename && "unknown" !== path.hub.file.opts.filename ? nodePath.dirname(path.hub.file.opts.filename) : "";

  459.         state.pluginMacros[path.node.source.value] || -1 === state.emotionInstancePaths.indexOf(getInstancePathToCompare(path.node.source.value, dirname)) || (state.pluginMacros[path.node.source.value] = createEmotionMacro(path.node.source.value));

  460.         var pluginMacros = state.pluginMacros;

  461.         if (void 0 !== pluginMacros[path.node.source.value] && !t.isImportNamespaceSpecifier(path.node.specifiers[0])) {

  462.           var imports = path.node.specifiers.map(function(s) {

  463.             return {

  464.               localName: s.local.name,

  465.               importedName: "ImportDefaultSpecifier" === s.type ? "default" : s.imported.name

  466.             };

  467.           }), shouldExit = !1, hasReferences = !1, referencePathsByImportName = imports.reduce(function(byName, _ref2) {

  468.             var importedName = _ref2.importedName, localName = _ref2.localName, binding = path.scope.getBinding(localName);

  469.             return binding ? (byName[importedName] = binding.referencePaths, hasReferences = hasReferences || Boolean(byName[importedName].length), 

  470.             byName) : (shouldExit = !0, byName);

  471.           }, {});

  472.           hasReferences && !shouldExit && (state.file.scope.path.traverse({

  473.             Identifier: function() {}

  474.           }), pluginMacros[path.node.source.value]({

  475.             references: referencePathsByImportName,

  476.             state: state,

  477.             babel: babel,

  478.             isBabelMacrosCall: !0,

  479.             isEmotionCall: !0

  480.           }), pluginMacros[path.node.source.value].keepImport || path.remove());

  481.         }

  482.       },

  483.       Program: function(path, state) {

  484.         if (state.emotionInstancePaths = (state.opts.instances || []).map(function(instancePath) {

  485.           return getInstancePathToCompare(instancePath, process.cwd());

  486.         }), state.pluginMacros = {

  487.           "@emotion/css": cssMacro,

  488.           "@emotion/styled": webStyledMacro,

  489.           "@emotion/core": emotionCoreMacroThatsNotARealMacro,

  490.           "@emotion/primitives": primitivesStyledMacro,

  491.           "@emotion/native": nativeStyledMacro,

  492.           emotion: createEmotionMacro("emotion")

  493.         }, void 0 === state.opts.cssPropOptimization) {

  494.           var _iterator = path.node.body, _isArray = Array.isArray(_iterator), _i = 0;

  495.           for (_iterator = _isArray ? _iterator : _iterator[Symbol.iterator](); ;) {

  496.             var _ref3;

  497.             if (_isArray) {

  498.               if (_i >= _iterator.length) break;

  499.               _ref3 = _iterator[_i++];

  500.             } else {

  501.               if ((_i = _iterator.next()).done) break;

  502.               _ref3 = _i.value;

  503.             }

  504.             var node = _ref3;

  505.             if (t.isImportDeclaration(node) && "@emotion/core" === node.source.value && node.specifiers.some(function(x) {

  506.               return t.isImportSpecifier(x) && "jsx" === x.imported.name;

  507.             })) {

  508.               state.transformCssProp = !0;

  509.               break;

  510.             }

  511.           }

  512.         } else state.transformCssProp = state.opts.cssPropOptimization;

  513.         !1 === state.opts.sourceMap ? state.emotionSourceMap = !1 : state.emotionSourceMap = !0;

  514.       },

  515.       JSXAttribute: function(path, state) {

  516.         if ("css" === path.node.name.name && state.transformCssProp && t.isJSXExpressionContainer(path.node.value) && (t.isObjectExpression(path.node.value.expression) || t.isArrayExpression(path.node.value.expression))) {

  517.           var expressionPath = path.get("value.expression"), sourceMap = state.emotionSourceMap && void 0 !== path.node.loc ? getSourceMap(path.node.loc.start, state) : "";

  518.           expressionPath.replaceWith(t.callExpression(t.identifier("___shouldNeverAppearCSS"), [ path.node.value.expression ])), 

  519.           transformCssCallExpression({

  520.             babel: babel,

  521.             state: state,

  522.             path: expressionPath,

  523.             sourceMap: sourceMap

  524.           }), t.isCallExpression(expressionPath) && (state.cssIdentifier || (state.cssIdentifier = helperModuleImports.addDefault(path, "@emotion/css", {

  525.             nameHint: "css"

  526.           })), expressionPath.get("callee").replaceWith(t.cloneDeep(state.cssIdentifier)));

  527.         }

  528.       },

  529.       CallExpression: {

  530.         exit: function(path, state) {

  531.           try {

  532.             if (path.node.callee && path.node.callee.property && "withComponent" === path.node.callee.property.name) switch (path.node.arguments.length) {

  533.              case 1:

  534.              case 2:

  535.               path.node.arguments[1] = getStyledOptions(t, path, state);

  536.             }

  537.           } catch (e) {

  538.             throw path.buildCodeFrameError(e);

  539.           }

  540.         }

  541.       }

  542.     }

  543.   };

  544. }

  545. 

  546. emotionCoreMacroThatsNotARealMacro.keepImport = !0, exports.default = index, exports.macros = macros;