[6a3a178] | 1 | "use strict";
|
---|
| 2 |
|
---|
| 3 | Object.defineProperty(exports, "__esModule", {
|
---|
| 4 | value: true
|
---|
| 5 | });
|
---|
| 6 | exports.evaluateTruthy = evaluateTruthy;
|
---|
| 7 | exports.evaluate = evaluate;
|
---|
| 8 | const VALID_CALLEES = ["String", "Number", "Math"];
|
---|
| 9 | const INVALID_METHODS = ["random"];
|
---|
| 10 |
|
---|
| 11 | function evaluateTruthy() {
|
---|
| 12 | const res = this.evaluate();
|
---|
| 13 | if (res.confident) return !!res.value;
|
---|
| 14 | }
|
---|
| 15 |
|
---|
| 16 | function deopt(path, state) {
|
---|
| 17 | if (!state.confident) return;
|
---|
| 18 | state.deoptPath = path;
|
---|
| 19 | state.confident = false;
|
---|
| 20 | }
|
---|
| 21 |
|
---|
| 22 | function evaluateCached(path, state) {
|
---|
| 23 | const {
|
---|
| 24 | node
|
---|
| 25 | } = path;
|
---|
| 26 | const {
|
---|
| 27 | seen
|
---|
| 28 | } = state;
|
---|
| 29 |
|
---|
| 30 | if (seen.has(node)) {
|
---|
| 31 | const existing = seen.get(node);
|
---|
| 32 |
|
---|
| 33 | if (existing.resolved) {
|
---|
| 34 | return existing.value;
|
---|
| 35 | } else {
|
---|
| 36 | deopt(path, state);
|
---|
| 37 | return;
|
---|
| 38 | }
|
---|
| 39 | } else {
|
---|
| 40 | const item = {
|
---|
| 41 | resolved: false
|
---|
| 42 | };
|
---|
| 43 | seen.set(node, item);
|
---|
| 44 |
|
---|
| 45 | const val = _evaluate(path, state);
|
---|
| 46 |
|
---|
| 47 | if (state.confident) {
|
---|
| 48 | item.resolved = true;
|
---|
| 49 | item.value = val;
|
---|
| 50 | }
|
---|
| 51 |
|
---|
| 52 | return val;
|
---|
| 53 | }
|
---|
| 54 | }
|
---|
| 55 |
|
---|
| 56 | function _evaluate(path, state) {
|
---|
| 57 | if (!state.confident) return;
|
---|
| 58 |
|
---|
| 59 | if (path.isSequenceExpression()) {
|
---|
| 60 | const exprs = path.get("expressions");
|
---|
| 61 | return evaluateCached(exprs[exprs.length - 1], state);
|
---|
| 62 | }
|
---|
| 63 |
|
---|
| 64 | if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
|
---|
| 65 | return path.node.value;
|
---|
| 66 | }
|
---|
| 67 |
|
---|
| 68 | if (path.isNullLiteral()) {
|
---|
| 69 | return null;
|
---|
| 70 | }
|
---|
| 71 |
|
---|
| 72 | if (path.isTemplateLiteral()) {
|
---|
| 73 | return evaluateQuasis(path, path.node.quasis, state);
|
---|
| 74 | }
|
---|
| 75 |
|
---|
| 76 | if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
|
---|
| 77 | const object = path.get("tag.object");
|
---|
| 78 | const {
|
---|
| 79 | node: {
|
---|
| 80 | name
|
---|
| 81 | }
|
---|
| 82 | } = object;
|
---|
| 83 | const property = path.get("tag.property");
|
---|
| 84 |
|
---|
| 85 | if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
|
---|
| 86 | return evaluateQuasis(path, path.node.quasi.quasis, state, true);
|
---|
| 87 | }
|
---|
| 88 | }
|
---|
| 89 |
|
---|
| 90 | if (path.isConditionalExpression()) {
|
---|
| 91 | const testResult = evaluateCached(path.get("test"), state);
|
---|
| 92 | if (!state.confident) return;
|
---|
| 93 |
|
---|
| 94 | if (testResult) {
|
---|
| 95 | return evaluateCached(path.get("consequent"), state);
|
---|
| 96 | } else {
|
---|
| 97 | return evaluateCached(path.get("alternate"), state);
|
---|
| 98 | }
|
---|
| 99 | }
|
---|
| 100 |
|
---|
| 101 | if (path.isExpressionWrapper()) {
|
---|
| 102 | return evaluateCached(path.get("expression"), state);
|
---|
| 103 | }
|
---|
| 104 |
|
---|
| 105 | if (path.isMemberExpression() && !path.parentPath.isCallExpression({
|
---|
| 106 | callee: path.node
|
---|
| 107 | })) {
|
---|
| 108 | const property = path.get("property");
|
---|
| 109 | const object = path.get("object");
|
---|
| 110 |
|
---|
| 111 | if (object.isLiteral() && property.isIdentifier()) {
|
---|
| 112 | const value = object.node.value;
|
---|
| 113 | const type = typeof value;
|
---|
| 114 |
|
---|
| 115 | if (type === "number" || type === "string") {
|
---|
| 116 | return value[property.node.name];
|
---|
| 117 | }
|
---|
| 118 | }
|
---|
| 119 | }
|
---|
| 120 |
|
---|
| 121 | if (path.isReferencedIdentifier()) {
|
---|
| 122 | const binding = path.scope.getBinding(path.node.name);
|
---|
| 123 |
|
---|
| 124 | if (binding && binding.constantViolations.length > 0) {
|
---|
| 125 | return deopt(binding.path, state);
|
---|
| 126 | }
|
---|
| 127 |
|
---|
| 128 | if (binding && path.node.start < binding.path.node.end) {
|
---|
| 129 | return deopt(binding.path, state);
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | if (binding != null && binding.hasValue) {
|
---|
| 133 | return binding.value;
|
---|
| 134 | } else {
|
---|
| 135 | if (path.node.name === "undefined") {
|
---|
| 136 | return binding ? deopt(binding.path, state) : undefined;
|
---|
| 137 | } else if (path.node.name === "Infinity") {
|
---|
| 138 | return binding ? deopt(binding.path, state) : Infinity;
|
---|
| 139 | } else if (path.node.name === "NaN") {
|
---|
| 140 | return binding ? deopt(binding.path, state) : NaN;
|
---|
| 141 | }
|
---|
| 142 |
|
---|
| 143 | const resolved = path.resolve();
|
---|
| 144 |
|
---|
| 145 | if (resolved === path) {
|
---|
| 146 | return deopt(path, state);
|
---|
| 147 | } else {
|
---|
| 148 | return evaluateCached(resolved, state);
|
---|
| 149 | }
|
---|
| 150 | }
|
---|
| 151 | }
|
---|
| 152 |
|
---|
| 153 | if (path.isUnaryExpression({
|
---|
| 154 | prefix: true
|
---|
| 155 | })) {
|
---|
| 156 | if (path.node.operator === "void") {
|
---|
| 157 | return undefined;
|
---|
| 158 | }
|
---|
| 159 |
|
---|
| 160 | const argument = path.get("argument");
|
---|
| 161 |
|
---|
| 162 | if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
|
---|
| 163 | return "function";
|
---|
| 164 | }
|
---|
| 165 |
|
---|
| 166 | const arg = evaluateCached(argument, state);
|
---|
| 167 | if (!state.confident) return;
|
---|
| 168 |
|
---|
| 169 | switch (path.node.operator) {
|
---|
| 170 | case "!":
|
---|
| 171 | return !arg;
|
---|
| 172 |
|
---|
| 173 | case "+":
|
---|
| 174 | return +arg;
|
---|
| 175 |
|
---|
| 176 | case "-":
|
---|
| 177 | return -arg;
|
---|
| 178 |
|
---|
| 179 | case "~":
|
---|
| 180 | return ~arg;
|
---|
| 181 |
|
---|
| 182 | case "typeof":
|
---|
| 183 | return typeof arg;
|
---|
| 184 | }
|
---|
| 185 | }
|
---|
| 186 |
|
---|
| 187 | if (path.isArrayExpression()) {
|
---|
| 188 | const arr = [];
|
---|
| 189 | const elems = path.get("elements");
|
---|
| 190 |
|
---|
| 191 | for (const elem of elems) {
|
---|
| 192 | const elemValue = elem.evaluate();
|
---|
| 193 |
|
---|
| 194 | if (elemValue.confident) {
|
---|
| 195 | arr.push(elemValue.value);
|
---|
| 196 | } else {
|
---|
| 197 | return deopt(elemValue.deopt, state);
|
---|
| 198 | }
|
---|
| 199 | }
|
---|
| 200 |
|
---|
| 201 | return arr;
|
---|
| 202 | }
|
---|
| 203 |
|
---|
| 204 | if (path.isObjectExpression()) {
|
---|
| 205 | const obj = {};
|
---|
| 206 | const props = path.get("properties");
|
---|
| 207 |
|
---|
| 208 | for (const prop of props) {
|
---|
| 209 | if (prop.isObjectMethod() || prop.isSpreadElement()) {
|
---|
| 210 | return deopt(prop, state);
|
---|
| 211 | }
|
---|
| 212 |
|
---|
| 213 | const keyPath = prop.get("key");
|
---|
| 214 | let key = keyPath;
|
---|
| 215 |
|
---|
| 216 | if (prop.node.computed) {
|
---|
| 217 | key = key.evaluate();
|
---|
| 218 |
|
---|
| 219 | if (!key.confident) {
|
---|
| 220 | return deopt(key.deopt, state);
|
---|
| 221 | }
|
---|
| 222 |
|
---|
| 223 | key = key.value;
|
---|
| 224 | } else if (key.isIdentifier()) {
|
---|
| 225 | key = key.node.name;
|
---|
| 226 | } else {
|
---|
| 227 | key = key.node.value;
|
---|
| 228 | }
|
---|
| 229 |
|
---|
| 230 | const valuePath = prop.get("value");
|
---|
| 231 | let value = valuePath.evaluate();
|
---|
| 232 |
|
---|
| 233 | if (!value.confident) {
|
---|
| 234 | return deopt(value.deopt, state);
|
---|
| 235 | }
|
---|
| 236 |
|
---|
| 237 | value = value.value;
|
---|
| 238 | obj[key] = value;
|
---|
| 239 | }
|
---|
| 240 |
|
---|
| 241 | return obj;
|
---|
| 242 | }
|
---|
| 243 |
|
---|
| 244 | if (path.isLogicalExpression()) {
|
---|
| 245 | const wasConfident = state.confident;
|
---|
| 246 | const left = evaluateCached(path.get("left"), state);
|
---|
| 247 | const leftConfident = state.confident;
|
---|
| 248 | state.confident = wasConfident;
|
---|
| 249 | const right = evaluateCached(path.get("right"), state);
|
---|
| 250 | const rightConfident = state.confident;
|
---|
| 251 |
|
---|
| 252 | switch (path.node.operator) {
|
---|
| 253 | case "||":
|
---|
| 254 | state.confident = leftConfident && (!!left || rightConfident);
|
---|
| 255 | if (!state.confident) return;
|
---|
| 256 | return left || right;
|
---|
| 257 |
|
---|
| 258 | case "&&":
|
---|
| 259 | state.confident = leftConfident && (!left || rightConfident);
|
---|
| 260 | if (!state.confident) return;
|
---|
| 261 | return left && right;
|
---|
| 262 | }
|
---|
| 263 | }
|
---|
| 264 |
|
---|
| 265 | if (path.isBinaryExpression()) {
|
---|
| 266 | const left = evaluateCached(path.get("left"), state);
|
---|
| 267 | if (!state.confident) return;
|
---|
| 268 | const right = evaluateCached(path.get("right"), state);
|
---|
| 269 | if (!state.confident) return;
|
---|
| 270 |
|
---|
| 271 | switch (path.node.operator) {
|
---|
| 272 | case "-":
|
---|
| 273 | return left - right;
|
---|
| 274 |
|
---|
| 275 | case "+":
|
---|
| 276 | return left + right;
|
---|
| 277 |
|
---|
| 278 | case "/":
|
---|
| 279 | return left / right;
|
---|
| 280 |
|
---|
| 281 | case "*":
|
---|
| 282 | return left * right;
|
---|
| 283 |
|
---|
| 284 | case "%":
|
---|
| 285 | return left % right;
|
---|
| 286 |
|
---|
| 287 | case "**":
|
---|
| 288 | return Math.pow(left, right);
|
---|
| 289 |
|
---|
| 290 | case "<":
|
---|
| 291 | return left < right;
|
---|
| 292 |
|
---|
| 293 | case ">":
|
---|
| 294 | return left > right;
|
---|
| 295 |
|
---|
| 296 | case "<=":
|
---|
| 297 | return left <= right;
|
---|
| 298 |
|
---|
| 299 | case ">=":
|
---|
| 300 | return left >= right;
|
---|
| 301 |
|
---|
| 302 | case "==":
|
---|
| 303 | return left == right;
|
---|
| 304 |
|
---|
| 305 | case "!=":
|
---|
| 306 | return left != right;
|
---|
| 307 |
|
---|
| 308 | case "===":
|
---|
| 309 | return left === right;
|
---|
| 310 |
|
---|
| 311 | case "!==":
|
---|
| 312 | return left !== right;
|
---|
| 313 |
|
---|
| 314 | case "|":
|
---|
| 315 | return left | right;
|
---|
| 316 |
|
---|
| 317 | case "&":
|
---|
| 318 | return left & right;
|
---|
| 319 |
|
---|
| 320 | case "^":
|
---|
| 321 | return left ^ right;
|
---|
| 322 |
|
---|
| 323 | case "<<":
|
---|
| 324 | return left << right;
|
---|
| 325 |
|
---|
| 326 | case ">>":
|
---|
| 327 | return left >> right;
|
---|
| 328 |
|
---|
| 329 | case ">>>":
|
---|
| 330 | return left >>> right;
|
---|
| 331 | }
|
---|
| 332 | }
|
---|
| 333 |
|
---|
| 334 | if (path.isCallExpression()) {
|
---|
| 335 | const callee = path.get("callee");
|
---|
| 336 | let context;
|
---|
| 337 | let func;
|
---|
| 338 |
|
---|
| 339 | if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
|
---|
| 340 | func = global[callee.node.name];
|
---|
| 341 | }
|
---|
| 342 |
|
---|
| 343 | if (callee.isMemberExpression()) {
|
---|
| 344 | const object = callee.get("object");
|
---|
| 345 | const property = callee.get("property");
|
---|
| 346 |
|
---|
| 347 | if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
|
---|
| 348 | context = global[object.node.name];
|
---|
| 349 | func = context[property.node.name];
|
---|
| 350 | }
|
---|
| 351 |
|
---|
| 352 | if (object.isLiteral() && property.isIdentifier()) {
|
---|
| 353 | const type = typeof object.node.value;
|
---|
| 354 |
|
---|
| 355 | if (type === "string" || type === "number") {
|
---|
| 356 | context = object.node.value;
|
---|
| 357 | func = context[property.node.name];
|
---|
| 358 | }
|
---|
| 359 | }
|
---|
| 360 | }
|
---|
| 361 |
|
---|
| 362 | if (func) {
|
---|
| 363 | const args = path.get("arguments").map(arg => evaluateCached(arg, state));
|
---|
| 364 | if (!state.confident) return;
|
---|
| 365 | return func.apply(context, args);
|
---|
| 366 | }
|
---|
| 367 | }
|
---|
| 368 |
|
---|
| 369 | deopt(path, state);
|
---|
| 370 | }
|
---|
| 371 |
|
---|
| 372 | function evaluateQuasis(path, quasis, state, raw = false) {
|
---|
| 373 | let str = "";
|
---|
| 374 | let i = 0;
|
---|
| 375 | const exprs = path.get("expressions");
|
---|
| 376 |
|
---|
| 377 | for (const elem of quasis) {
|
---|
| 378 | if (!state.confident) break;
|
---|
| 379 | str += raw ? elem.value.raw : elem.value.cooked;
|
---|
| 380 | const expr = exprs[i++];
|
---|
| 381 | if (expr) str += String(evaluateCached(expr, state));
|
---|
| 382 | }
|
---|
| 383 |
|
---|
| 384 | if (!state.confident) return;
|
---|
| 385 | return str;
|
---|
| 386 | }
|
---|
| 387 |
|
---|
| 388 | function evaluate() {
|
---|
| 389 | const state = {
|
---|
| 390 | confident: true,
|
---|
| 391 | deoptPath: null,
|
---|
| 392 | seen: new Map()
|
---|
| 393 | };
|
---|
| 394 | let value = evaluateCached(this, state);
|
---|
| 395 | if (!state.confident) value = undefined;
|
---|
| 396 | return {
|
---|
| 397 | confident: state.confident,
|
---|
| 398 | deopt: state.deoptPath,
|
---|
| 399 | value: value
|
---|
| 400 | };
|
---|
| 401 | } |
---|