Homec4science
Diffusion Open Access Compliance Check Tool (OACCT) (validity_dates) Browse

rOACCT/node_modules/webpack/lib/javascript/BasicEvaluatedExpression.js
9045e4d5dbe1validity_dates

Last Change
Raw File

BasicEvaluatedExpression.js
View Options

/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
/** @typedef {import("estree").Node} EsTreeNode */
/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
const TypeUnknown = 0;
const TypeUndefined = 1;
const TypeNull = 2;
const TypeString = 3;
const TypeNumber = 4;
const TypeBoolean = 5;
const TypeRegExp = 6;
const TypeConditional = 7;
const TypeArray = 8;
const TypeConstArray = 9;
const TypeIdentifier = 10;
const TypeWrapped = 11;
const TypeTemplateString = 12;
const TypeBigInt = 13;
class BasicEvaluatedExpression {
constructor() {
this.type = TypeUnknown;
/** @type {[number, number]} */
this.range = undefined;
/** @type {boolean} */
this.falsy = false;
/** @type {boolean} */
this.truthy = false;
/** @type {boolean | undefined} */
this.nullish = undefined;
/** @type {boolean} */
this.sideEffects = true;
/** @type {boolean | undefined} */
this.bool = undefined;
/** @type {number | undefined} */
this.number = undefined;
/** @type {bigint | undefined} */
this.bigint = undefined;
/** @type {RegExp | undefined} */
this.regExp = undefined;
/** @type {string | undefined} */
this.string = undefined;
/** @type {BasicEvaluatedExpression[] | undefined} */
this.quasis = undefined;
/** @type {BasicEvaluatedExpression[] | undefined} */
this.parts = undefined;
/** @type {any[] | undefined} */
this.array = undefined;
/** @type {BasicEvaluatedExpression[] | undefined} */
this.items = undefined;
/** @type {BasicEvaluatedExpression[] | undefined} */
this.options = undefined;
/** @type {BasicEvaluatedExpression | undefined} */
this.prefix = undefined;
/** @type {BasicEvaluatedExpression | undefined} */
this.postfix = undefined;
this.wrappedInnerExpressions = undefined;
/** @type {string | undefined} */
this.identifier = undefined;
/** @type {VariableInfoInterface} */
this.rootInfo = undefined;
/** @type {() => string[]} */
this.getMembers = undefined;
/** @type {EsTreeNode} */
this.expression = undefined;
}
isUnknown() {
return this.type === TypeUnknown;
}
isNull() {
return this.type === TypeNull;
}
isUndefined() {
return this.type === TypeUndefined;
}
isString() {
return this.type === TypeString;
}
isNumber() {
return this.type === TypeNumber;
}
isBigInt() {
return this.type === TypeBigInt;
}
isBoolean() {
return this.type === TypeBoolean;
}
isRegExp() {
return this.type === TypeRegExp;
}
isConditional() {
return this.type === TypeConditional;
}
isArray() {
return this.type === TypeArray;
}
isConstArray() {
return this.type === TypeConstArray;
}
isIdentifier() {
return this.type === TypeIdentifier;
}
isWrapped() {
return this.type === TypeWrapped;
}
isTemplateString() {
return this.type === TypeTemplateString;
}
/**
* Is expression a primitive or an object type value?
* @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
*/
isPrimitiveType() {
switch (this.type) {
case TypeUndefined:
case TypeNull:
case TypeString:
case TypeNumber:
case TypeBoolean:
case TypeBigInt:
case TypeWrapped:
case TypeTemplateString:
return true;
case TypeRegExp:
case TypeArray:
case TypeConstArray:
return false;
default:
return undefined;
}
}
/**
* Is expression a runtime or compile-time value?
* @returns {boolean} true: compile time value, false: runtime value
*/
isCompileTimeValue() {
switch (this.type) {
case TypeUndefined:
case TypeNull:
case TypeString:
case TypeNumber:
case TypeBoolean:
case TypeRegExp:
case TypeConstArray:
case TypeBigInt:
return true;
default:
return false;
}
}
/**
* Gets the compile-time value of the expression
* @returns {any} the javascript value
*/
asCompileTimeValue() {
switch (this.type) {
case TypeUndefined:
return undefined;
case TypeNull:
return null;
case TypeString:
return this.string;
case TypeNumber:
return this.number;
case TypeBoolean:
return this.bool;
case TypeRegExp:
return this.regExp;
case TypeConstArray:
return this.array;
case TypeBigInt:
return this.bigint;
default:
throw new Error(
"asCompileTimeValue must only be called for compile-time values"
);
}
}
isTruthy() {
return this.truthy;
}
isFalsy() {
return this.falsy;
}
isNullish() {
return this.nullish;
}
/**
* Can this expression have side effects?
* @returns {boolean} false: never has side effects
*/
couldHaveSideEffects() {
return this.sideEffects;
}
asBool() {
if (this.truthy) return true;
if (this.falsy || this.nullish) return false;
if (this.isBoolean()) return this.bool;
if (this.isNull()) return false;
if (this.isUndefined()) return false;
if (this.isString()) return this.string !== "";
if (this.isNumber()) return this.number !== 0;
if (this.isBigInt()) return this.bigint !== BigInt(0);
if (this.isRegExp()) return true;
if (this.isArray()) return true;
if (this.isConstArray()) return true;
if (this.isWrapped()) {
return (this.prefix && this.prefix.asBool()) ||
(this.postfix && this.postfix.asBool())
? true
: undefined;
}
if (this.isTemplateString()) {
const str = this.asString();
if (typeof str === "string") return str !== "";
}
return undefined;
}
asNullish() {
const nullish = this.isNullish();
if (nullish === true || this.isNull() || this.isUndefined()) return true;
if (nullish === false) return false;
if (this.isTruthy()) return false;
if (this.isBoolean()) return false;
if (this.isString()) return false;
if (this.isNumber()) return false;
if (this.isBigInt()) return false;
if (this.isRegExp()) return false;
if (this.isArray()) return false;
if (this.isConstArray()) return false;
if (this.isTemplateString()) return false;
if (this.isRegExp()) return false;
return undefined;
}
asString() {
if (this.isBoolean()) return `${this.bool}`;
if (this.isNull()) return "null";
if (this.isUndefined()) return "undefined";
if (this.isString()) return this.string;
if (this.isNumber()) return `${this.number}`;
if (this.isBigInt()) return `${this.bigint}`;
if (this.isRegExp()) return `${this.regExp}`;
if (this.isArray()) {
let array = [];
for (const item of this.items) {
const itemStr = item.asString();
if (itemStr === undefined) return undefined;
array.push(itemStr);
}
return `${array}`;
}
if (this.isConstArray()) return `${this.array}`;
if (this.isTemplateString()) {
let str = "";
for (const part of this.parts) {
const partStr = part.asString();
if (partStr === undefined) return undefined;
str += partStr;
}
return str;
}
return undefined;
}
setString(string) {
this.type = TypeString;
this.string = string;
this.sideEffects = false;
return this;
}
setUndefined() {
this.type = TypeUndefined;
this.sideEffects = false;
return this;
}
setNull() {
this.type = TypeNull;
this.sideEffects = false;
return this;
}
setNumber(number) {
this.type = TypeNumber;
this.number = number;
this.sideEffects = false;
return this;
}
setBigInt(bigint) {
this.type = TypeBigInt;
this.bigint = bigint;
this.sideEffects = false;
return this;
}
setBoolean(bool) {
this.type = TypeBoolean;
this.bool = bool;
this.sideEffects = false;
return this;
}
setRegExp(regExp) {
this.type = TypeRegExp;
this.regExp = regExp;
this.sideEffects = false;
return this;
}
setIdentifier(identifier, rootInfo, getMembers) {
this.type = TypeIdentifier;
this.identifier = identifier;
this.rootInfo = rootInfo;
this.getMembers = getMembers;
this.sideEffects = true;
return this;
}
setWrapped(prefix, postfix, innerExpressions) {
this.type = TypeWrapped;
this.prefix = prefix;
this.postfix = postfix;
this.wrappedInnerExpressions = innerExpressions;
this.sideEffects = true;
return this;
}
setOptions(options) {
this.type = TypeConditional;
this.options = options;
this.sideEffects = true;
return this;
}
addOptions(options) {
if (!this.options) {
this.type = TypeConditional;
this.options = [];
this.sideEffects = true;
}
for (const item of options) {
this.options.push(item);
}
return this;
}
setItems(items) {
this.type = TypeArray;
this.items = items;
this.sideEffects = items.some(i => i.couldHaveSideEffects());
return this;
}
setArray(array) {
this.type = TypeConstArray;
this.array = array;
this.sideEffects = false;
return this;
}
setTemplateString(quasis, parts, kind) {
this.type = TypeTemplateString;
this.quasis = quasis;
this.parts = parts;
this.templateStringKind = kind;
this.sideEffects = parts.some(p => p.sideEffects);
return this;
}
setTruthy() {
this.falsy = false;
this.truthy = true;
this.nullish = false;
return this;
}
setFalsy() {
this.falsy = true;
this.truthy = false;
return this;
}
setNullish(value) {
this.nullish = value;
return this;
}
setRange(range) {
this.range = range;
return this;
}
setSideEffects(sideEffects = true) {
this.sideEffects = sideEffects;
return this;
}
setExpression(expression) {
this.expression = expression;
return this;
}
}
/**
* @param {string} flags regexp flags
* @returns {boolean} is valid flags
*/
BasicEvaluatedExpression.isValidRegExpFlags = flags => {
const len = flags.length;
if (len === 0) return true;
if (len > 4) return false;
// cspell:word gimy
let remaining = 0b0000; // bit per RegExp flag: gimy
for (let i = 0; i < len; i++)
switch (flags.charCodeAt(i)) {
case 103 /* g */:
if (remaining & 0b1000) return false;
remaining |= 0b1000;
break;
case 105 /* i */:
if (remaining & 0b0100) return false;
remaining |= 0b0100;
break;
case 109 /* m */:
if (remaining & 0b0010) return false;
remaining |= 0b0010;
break;
case 121 /* y */:
if (remaining & 0b0001) return false;
remaining |= 0b0001;
break;
default:
return false;
}
return true;
};
module.exports = BasicEvaluatedExpression;
c4science · Help