From efbc2ffe6a1ee5ec38a4396305561d6515d0943e Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Fri, 30 Aug 2024 17:21:18 +0800 Subject: node fixes, updates --- .../lib/index.js | 80 ++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 node_modules/babel-plugin-minify-guarded-expressions/lib/index.js (limited to 'node_modules/babel-plugin-minify-guarded-expressions/lib/index.js') diff --git a/node_modules/babel-plugin-minify-guarded-expressions/lib/index.js b/node_modules/babel-plugin-minify-guarded-expressions/lib/index.js new file mode 100644 index 00000000..5cc5f192 --- /dev/null +++ b/node_modules/babel-plugin-minify-guarded-expressions/lib/index.js @@ -0,0 +1,80 @@ +"use strict"; + +const evaluate = require("babel-helper-evaluate-path"); + +function evaluateTruthy(path) { + const res = evaluate(path); + if (res.confident) return !!res.value; +} + +module.exports = function ({ + types: t +}) { + const flipExpressions = require("babel-helper-flip-expressions")(t); + + return { + name: "minify-guarded-expressions", + visitor: { + // Convert guarded expressions + // !a && b() --> a || b(); + // This could change the return result of the expression so we only do it + // on things where the result is ignored. + LogicalExpression: { + enter: [function (path) { + const node = path.node; + const left = path.get("left"); + const right = path.get("right"); // issues - 171, 174, 176 + // we assume that it is returned/assigned/part of a bigger expression + // or utilized somehow + // we check if we shouldBail only when evaluating + // the rightside of the expression; + // if the left side is evaluated to be deterministic, + // we can safely replace the entire expression + + const shouldBail = !path.parentPath.isExpressionStatement(); + + if (node.operator === "&&") { + const leftTruthy = evaluateTruthy(left); + + if (leftTruthy === false) { + // Short-circuit + path.replaceWith(node.left); + } else if (leftTruthy === true && left.isPure()) { + path.replaceWith(node.right); + } else if (evaluateTruthy(right) === false && right.isPure() && !shouldBail) { + path.replaceWith(node.left); + } + } else if (node.operator === "||") { + const leftTruthy = evaluateTruthy(left); + + if (leftTruthy === false && left.isPure()) { + path.replaceWith(node.right); + } else if (leftTruthy === true) { + // Short-circuit + path.replaceWith(node.left); + } else if (evaluateTruthy(right) === false && right.isPure() && !shouldBail) { + path.replaceWith(node.left); + } + } + }, function (path) { + const node = path.node; + + if (flipExpressions.hasSeen(node)) { + return; + } + + if (!path.parentPath.isExpressionStatement() && !(path.parentPath.isSequenceExpression() && path.parentPath.parentPath.isExpressionStatement())) { + return; + } // Start counting savings from one since we can ignore the last + // expression. + + + if (flipExpressions.shouldFlip(node, 1)) { + const newNode = flipExpressions.flip(node, true); + path.replaceWith(newNode); + } + }] + } + } + }; +}; \ No newline at end of file -- cgit v1.2.3