react-querybuilder
Version:
React Query Builder component for constructing queries and filters, with utilities for executing them in various database and evaluation contexts
1,226 lines (1,224 loc) • 112 kB
JavaScript
const require_isRuleGroup = require('./isRuleGroup-Bf2BUwdE.js');
const require_arrayUtils = require('./arrayUtils-D5EoIsKP.js');
require('./optGroupUtils-BVZSodaD.js');
const require_prepareQueryObjects = require('./prepareQueryObjects-D-xu06SF.js');
//#region ../../node_modules/spel2js/dist/spel2js.js
var require_spel2js = /* @__PURE__ */ require_isRuleGroup.__commonJS({ "../../node_modules/spel2js/dist/spel2js.js": ((exports, module) => {
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === "object" && typeof module === "object") module.exports = factory();
else if (typeof define === "function" && define.amd) define([], factory);
else if (typeof exports === "object") exports["spel2js"] = factory();
else root["spel2js"] = factory();
})(exports, function() {
return (function(modules) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId]) return installedModules[moduleId].exports;
var module$1 = installedModules[moduleId] = {
i: moduleId,
l: false,
exports: {}
};
modules[moduleId].call(module$1.exports, module$1, module$1.exports, __webpack_require__);
module$1.l = true;
return module$1.exports;
}
__webpack_require__.m = modules;
__webpack_require__.c = installedModules;
__webpack_require__.d = function(exports$1, name, getter) {
if (!__webpack_require__.o(exports$1, name)) Object.defineProperty(exports$1, name, {
configurable: false,
enumerable: true,
get: getter
});
};
__webpack_require__.n = function(module$1) {
var getter = module$1 && module$1.__esModule ? function getDefault() {
return module$1["default"];
} : function getModuleExports() {
return module$1;
};
__webpack_require__.d(getter, "a", getter);
return getter;
};
__webpack_require__.o = function(object, property) {
return Object.prototype.hasOwnProperty.call(object, property);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = 3);
})([
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
/**
* The common supertype of all AST nodes in a parsed Spring Expression Language
* format expression.
*
* @author Andy Clement
* @author Ben March
* @since 0.2.0
*/
function createSpelNode(nodeType, position) {
var node = {}, type = nodeType || "Abstract", children = [], parent = null, activeContext;
node._type = type;
node.getType = function() {
return type;
};
node.setType = function(nodeType$1) {
type = nodeType$1;
};
node.getChildren = function() {
return children;
};
node.addChild = function(childNode) {
if (!childNode) return;
if (!childNode.setParent) throw {
name: "Error",
message: "Trying to add a child which is not a node: " + JSON.stringify(childNode)
};
childNode.setParent(node);
children.push(childNode);
};
node.getParent = function() {
return parent;
};
node.setParent = function(parentNode) {
parent = parentNode;
};
node.getContext = function(state) {
return activeContext || state.activeContext.peek();
};
node.setContext = function(nodeContext) {
activeContext = nodeContext;
};
node.getStartPosition = function() {
return position >> 16;
};
node.getEndPosition = function() {
return position & 65535;
};
node.getValue = function() {
throw {
name: "MethodNotImplementedException",
message: "SpelNode#getValue() must be overridden."
};
};
node.toString = function() {
var s = "Kind: " + node.getType();
s += ", Children: [";
for (var i = 0, l = node.getChildren().length; i < l; i += 1) s += "{" + node.getChildren()[i] + "}, ";
s += "]";
return s;
};
if (position === 0) throw {
name: "Error",
message: "Position cannot be 0"
};
for (var _len = arguments.length, operands = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) operands[_key - 2] = arguments[_key];
if (operands) operands.forEach(function(operand) {
node.addChild(operand);
});
return node;
}
exports$1.SpelNode = { create: createSpelNode };
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.Stack = Stack;
/**
* @author Ben March
* @since 0.2.0
*/
function Stack(startingElements) {
this.elements = startingElements || [];
}
Stack.prototype.push = function(el) {
this.elements.push(el);
return el;
};
Stack.prototype.pop = function() {
return this.elements.pop();
};
Stack.prototype.peek = function() {
return this.elements[this.elements.length - 1];
};
Stack.prototype.empty = function() {
return this.elements.length > 0;
};
Stack.prototype.search = function(el) {
return this.elements.length - this.elements.indexOf(el);
};
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
/**
* @author Andy Clement
* @author Ben March
* @since 0.2.0
*/
var types = {
LITERAL_INT: 1,
LITERAL_LONG: 2,
LITERAL_HEXINT: 3,
LITERAL_HEXLONG: 4,
LITERAL_STRING: 5,
LITERAL_REAL: 6,
LITERAL_REAL_FLOAT: 7,
LPAREN: "(",
RPAREN: ")",
COMMA: ",",
IDENTIFIER: 0,
COLON: ":",
HASH: "#",
RSQUARE: "]",
LSQUARE: "[",
LCURLY: "{",
RCURLY: "}",
DOT: ".",
PLUS: "+",
STAR: "*",
MINUS: "-",
SELECT_FIRST: "^[",
SELECT_LAST: "$[",
QMARK: "?",
PROJECT: "![",
DIV: "/",
GE: ">=",
GT: ">",
LE: "<=",
LT: "<",
EQ: "==",
NE: "!=",
MOD: "%",
NOT: "!",
ASSIGN: "=",
INSTANCEOF: "instanceof",
MATCHES: "matches",
BETWEEN: "between",
SELECT: "?[",
POWER: "^",
ELVIS: "?:",
SAFE_NAVI: "?.",
BEAN_REF: "@",
SYMBOLIC_OR: "||",
SYMBOLIC_AND: "&&",
INC: "++",
DEC: "--"
};
function TokenKind(type) {
this.type = type;
this.tokenChars = types[type];
this._hasPayload = typeof types[type] !== "string";
if (typeof types[type] === "number") this._ordinal = types[type];
}
for (var t in types) if (types.hasOwnProperty(t)) TokenKind[t] = new TokenKind(t);
TokenKind.prototype.toString = function() {
return this.type + (this.tokenChars.length !== 0 ? "(" + this.tokenChars + ")" : "");
};
TokenKind.prototype.getLength = function() {
return this.tokenChars.length;
};
TokenKind.prototype.hasPayload = function() {
return this._hasPayload;
};
TokenKind.prototype.valueOf = function(id) {
for (var t$1 in types) if (types.hasOwnProperty(t$1) && types[t$1] === id) return TokenKind[t$1];
};
TokenKind.prototype.ordinal = function() {
return this._ordinal;
};
exports$1.TokenKind = TokenKind;
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.StandardContext = exports$1.SpelExpressionEvaluator = void 0;
var _SpelExpressionEvaluator = __webpack_require__(4);
var _StandardContext = __webpack_require__(50);
/**
* @author Ben March
* @since 0.2.0
*/
exports$1.SpelExpressionEvaluator = _SpelExpressionEvaluator.SpelExpressionEvaluator;
exports$1.StandardContext = _StandardContext.StandardContext;
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.SpelExpressionEvaluator = void 0;
var _SpelExpressionParser = __webpack_require__(5);
var _Stack = __webpack_require__(1);
/**
* @author Ben March
* @since 0.2.0
*/
var spelExpressionEvaluator = {};
function evalCompiled(compiledExpression, context, locals) {
var activeContext = new _Stack.Stack(), state;
if (!context) context = {};
activeContext.push(context);
state = {
rootContext: context,
activeContext,
locals
};
return compiledExpression.getValue(state);
}
spelExpressionEvaluator.compile = function(expression) {
var compiledExpression = (0, _SpelExpressionParser.SpelExpressionParser)().parse(expression);
return {
eval: function _eval(context, locals) {
return evalCompiled(compiledExpression, context, locals);
},
_compiledExpression: compiledExpression
};
};
spelExpressionEvaluator.eval = function(expression, context, locals) {
return spelExpressionEvaluator.compile(expression).eval(context, locals);
};
exports$1.SpelExpressionEvaluator = spelExpressionEvaluator;
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.SpelExpressionParser = void 0;
var _TokenKind = __webpack_require__(2);
var _Tokenizer = __webpack_require__(6);
var _BooleanLiteral = __webpack_require__(8);
var _NumberLiteral = __webpack_require__(9);
var _StringLiteral = __webpack_require__(10);
var _NullLiteral = __webpack_require__(11);
var _FunctionReference = __webpack_require__(12);
var _MethodReference = __webpack_require__(13);
var _PropertyReference = __webpack_require__(14);
var _VariableReference = __webpack_require__(15);
var _CompoundExpression = __webpack_require__(16);
var _Indexer = __webpack_require__(17);
var _Assign = __webpack_require__(18);
var _OpEQ = __webpack_require__(19);
var _OpNE = __webpack_require__(20);
var _OpGE = __webpack_require__(21);
var _OpGT = __webpack_require__(22);
var _OpLE = __webpack_require__(23);
var _OpLT = __webpack_require__(24);
var _OpPlus = __webpack_require__(25);
var _OpMinus = __webpack_require__(26);
var _OpMultiply = __webpack_require__(27);
var _OpDivide = __webpack_require__(28);
var _OpModulus = __webpack_require__(29);
var _OpPower = __webpack_require__(30);
var _OpInc = __webpack_require__(31);
var _OpDec = __webpack_require__(32);
var _OpNot = __webpack_require__(33);
var _OpAnd = __webpack_require__(34);
var _OpOr = __webpack_require__(35);
var _OpMatches = __webpack_require__(36);
var _Ternary = __webpack_require__(37);
var _Elvis = __webpack_require__(38);
var _InlineList = __webpack_require__(39);
var _InlineMap = __webpack_require__(40);
var _Selection = __webpack_require__(41);
var _Projection = __webpack_require__(42);
var _OpInstanceof = __webpack_require__(43);
var _OpBetween = __webpack_require__(44);
var _TypeReference = __webpack_require__(45);
var _BeanReference = __webpack_require__(46);
var _Identifier = __webpack_require__(47);
var _QualifiedIdentifier = __webpack_require__(48);
var _ConstructorReference = __webpack_require__(49);
exports$1.SpelExpressionParser = function SpelExpressionParser() {
var VALID_QUALIFIED_ID_PATTERN = /* @__PURE__ */ new RegExp("[\\p{L}\\p{N}_$]+");
var configuration;
var constructedNodes = [];
var expressionString;
var tokenStream;
var tokenStreamLength;
var tokenStreamPointer;
/**
* Create a parser with some configured behavior.
* @param config custom configuration options
*/
function setConfiguration(config) {
configuration = config;
}
function parse(expression, context) {
try {
expressionString = expression;
tokenStream = _Tokenizer.Tokenizer.tokenize(expression);
tokenStreamLength = tokenStream.length;
tokenStreamPointer = 0;
constructedNodes = [];
var ast = eatExpression();
if (moreTokens()) raiseInternalException(peekToken().startPos, "MORE_INPUT", nextToken().toString());
return ast;
} catch (e) {
throw e.message;
}
}
function eatExpression() {
var expr = eatLogicalOrExpression();
if (moreTokens()) {
var token = peekToken();
if (token.getKind() === _TokenKind.TokenKind.ASSIGN) {
if (expr === null) expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 1));
nextToken();
var assignedValue = eatLogicalOrExpression();
return _Assign.Assign.create(toPosToken(token), expr, assignedValue);
}
if (token.getKind() === _TokenKind.TokenKind.ELVIS) {
if (expr === null) expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 2));
nextToken();
var valueIfNull = eatExpression();
if (valueIfNull === null) valueIfNull = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos + 1, token.endPos + 1));
return _Elvis.Elvis.create(toPosToken(token), expr, valueIfNull);
}
if (token.getKind() === _TokenKind.TokenKind.QMARK) {
if (expr === null) expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 1));
nextToken();
var ifTrueExprValue = eatExpression();
eatToken(_TokenKind.TokenKind.COLON);
var ifFalseExprValue = eatExpression();
return _Ternary.Ternary.create(toPosToken(token), expr, ifTrueExprValue, ifFalseExprValue);
}
}
return expr;
}
function eatLogicalOrExpression() {
var expr = eatLogicalAndExpression();
while (peekIdentifierToken("or") || peekTokenOne(_TokenKind.TokenKind.SYMBOLIC_OR)) {
var token = nextToken();
var rhExpr = eatLogicalAndExpression();
checkOperands(token, expr, rhExpr);
expr = _OpOr.OpOr.create(toPosToken(token), expr, rhExpr);
}
return expr;
}
function eatLogicalAndExpression() {
var expr = eatRelationalExpression();
while (peekIdentifierToken("and") || peekTokenOne(_TokenKind.TokenKind.SYMBOLIC_AND)) {
var token = nextToken();
var rhExpr = eatRelationalExpression();
checkOperands(token, expr, rhExpr);
expr = _OpAnd.OpAnd.create(toPosToken(token), expr, rhExpr);
}
return expr;
}
function eatRelationalExpression() {
var expr = eatSumExpression();
var relationalOperatorToken = maybeEatRelationalOperator();
if (relationalOperatorToken !== null) {
var token = nextToken();
var rhExpr = eatSumExpression();
checkOperands(token, expr, rhExpr);
var tk = relationalOperatorToken.kind;
if (relationalOperatorToken.isNumericRelationalOperator()) {
var pos = toPosToken(token);
if (tk === _TokenKind.TokenKind.GT) return _OpGT.OpGT.create(pos, expr, rhExpr);
if (tk === _TokenKind.TokenKind.LT) return _OpLT.OpLT.create(pos, expr, rhExpr);
if (tk === _TokenKind.TokenKind.LE) return _OpLE.OpLE.create(pos, expr, rhExpr);
if (tk === _TokenKind.TokenKind.GE) return _OpGE.OpGE.create(pos, expr, rhExpr);
if (tk === _TokenKind.TokenKind.EQ) return _OpEQ.OpEQ.create(pos, expr, rhExpr);
return _OpNE.OpNE.create(pos, expr, rhExpr);
}
if (tk === _TokenKind.TokenKind.INSTANCEOF) return _OpInstanceof.OpInstanceof.create(toPosToken(token), expr, rhExpr);
if (tk === _TokenKind.TokenKind.MATCHES) return _OpMatches.OpMatches.create(toPosToken(token), expr, rhExpr);
return _OpBetween.OpBetween.create(toPosToken(token), expr, rhExpr);
}
return expr;
}
function eatSumExpression() {
var expr = eatProductExpression();
while (peekTokenAny(_TokenKind.TokenKind.PLUS, _TokenKind.TokenKind.MINUS, _TokenKind.TokenKind.INC)) {
var token = nextToken();
var rhExpr = eatProductExpression();
checkRightOperand(token, rhExpr);
if (token.getKind() === _TokenKind.TokenKind.PLUS) expr = _OpPlus.OpPlus.create(toPosToken(token), expr, rhExpr);
else if (token.getKind() === _TokenKind.TokenKind.MINUS) expr = _OpMinus.OpMinus.create(toPosToken(token), expr, rhExpr);
}
return expr;
}
function eatProductExpression() {
var expr = eatPowerIncDecExpression();
while (peekTokenAny(_TokenKind.TokenKind.STAR, _TokenKind.TokenKind.DIV, _TokenKind.TokenKind.MOD)) {
var token = nextToken();
var rhExpr = eatPowerIncDecExpression();
checkOperands(token, expr, rhExpr);
if (token.getKind() === _TokenKind.TokenKind.STAR) expr = _OpMultiply.OpMultiply.create(toPosToken(token), expr, rhExpr);
else if (token.getKind() === _TokenKind.TokenKind.DIV) expr = _OpDivide.OpDivide.create(toPosToken(token), expr, rhExpr);
else expr = _OpModulus.OpModulus.create(toPosToken(token), expr, rhExpr);
}
return expr;
}
function eatPowerIncDecExpression() {
var expr = eatUnaryExpression(), token;
if (peekTokenOne(_TokenKind.TokenKind.POWER)) {
token = nextToken();
var rhExpr = eatUnaryExpression();
checkRightOperand(token, rhExpr);
return _OpPower.OpPower.create(toPosToken(token), expr, rhExpr);
}
if (expr !== null && peekTokenAny(_TokenKind.TokenKind.INC, _TokenKind.TokenKind.DEC)) {
token = nextToken();
if (token.getKind() === _TokenKind.TokenKind.INC) return _OpInc.OpInc.create(toPosToken(token), true, expr);
return _OpDec.OpDec.create(toPosToken(token), true, expr);
}
return expr;
}
function eatUnaryExpression() {
var token, expr;
if (peekTokenAny(_TokenKind.TokenKind.PLUS, _TokenKind.TokenKind.MINUS, _TokenKind.TokenKind.NOT)) {
token = nextToken();
expr = eatUnaryExpression();
if (token.getKind() === _TokenKind.TokenKind.NOT) return _OpNot.OpNot.create(toPosToken(token), expr);
if (token.getKind() === _TokenKind.TokenKind.PLUS) return _OpPlus.OpPlus.create(toPosToken(token), expr);
return _OpMinus.OpMinus.create(toPosToken(token), expr);
}
if (peekTokenAny(_TokenKind.TokenKind.INC, _TokenKind.TokenKind.DEC)) {
token = nextToken();
expr = eatUnaryExpression();
if (token.getKind() === _TokenKind.TokenKind.INC) return _OpInc.OpInc.create(toPosToken(token), false, expr);
return _OpDec.OpDec.create(toPosToken(token), false, expr);
}
return eatPrimaryExpression();
}
function eatPrimaryExpression() {
var nodes = [];
var start = eatStartNode();
nodes.push(start);
while (maybeEatNode()) nodes.push(pop());
if (nodes.length === 1) return nodes[0];
return _CompoundExpression.CompoundExpression.create(toPosBounds(start.getStartPosition(), nodes[nodes.length - 1].getEndPosition()), nodes);
}
function maybeEatNode() {
var expr = null;
if (peekTokenAny(_TokenKind.TokenKind.DOT, _TokenKind.TokenKind.SAFE_NAVI)) expr = eatDottedNode();
else expr = maybeEatNonDottedNode();
if (expr === null) return false;
else {
push(expr);
return true;
}
}
function maybeEatNonDottedNode() {
if (peekTokenOne(_TokenKind.TokenKind.LSQUARE)) {
if (maybeEatIndexer()) return pop();
}
return null;
}
function eatDottedNode() {
var token = nextToken();
var nullSafeNavigation = token.getKind() === _TokenKind.TokenKind.SAFE_NAVI;
if (maybeEatMethodOrProperty(nullSafeNavigation) || maybeEatFunctionOrVar() || maybeEatProjection(nullSafeNavigation) || maybeEatSelection(nullSafeNavigation)) return pop();
if (peekToken() === null) raiseInternalException(token.startPos, "OOD");
else raiseInternalException(token.startPos, "UNEXPECTED_DATA_AFTER_DOT", toString(peekToken()));
return null;
}
function maybeEatFunctionOrVar() {
if (!peekTokenOne(_TokenKind.TokenKind.HASH)) return false;
var token = nextToken();
var functionOrVariableName = eatToken(_TokenKind.TokenKind.IDENTIFIER);
var args = maybeEatMethodArgs();
if (args === null) {
push(_VariableReference.VariableReference.create(functionOrVariableName.data, toPosBounds(token.startPos, functionOrVariableName.endPos)));
return true;
}
push(_FunctionReference.FunctionReference.create(functionOrVariableName.data, toPosBounds(token.startPos, functionOrVariableName.endPos), args));
return true;
}
function maybeEatMethodArgs() {
if (!peekTokenOne(_TokenKind.TokenKind.LPAREN)) return null;
var args = [];
consumeArguments(args);
eatToken(_TokenKind.TokenKind.RPAREN);
return args;
}
function eatConstructorArgs(accumulatedArguments) {
if (!peekTokenOne(_TokenKind.TokenKind.LPAREN)) raiseInternalException(toPosToken(peekToken()), "MISSING_CONSTRUCTOR_ARGS");
consumeArguments(accumulatedArguments);
eatToken(_TokenKind.TokenKind.RPAREN);
}
/**
* Used for consuming arguments for either a method or a constructor call
*/
function consumeArguments(accumulatedArguments) {
var pos = peekToken().startPos;
var next;
do {
nextToken();
var token = peekToken();
if (token === null) raiseInternalException(pos, "RUN_OUT_OF_ARGUMENTS");
if (token.getKind() !== _TokenKind.TokenKind.RPAREN) accumulatedArguments.push(eatExpression());
next = peekToken();
} while (next !== null && next.kind === _TokenKind.TokenKind.COMMA);
if (next === null) raiseInternalException(pos, "RUN_OUT_OF_ARGUMENTS");
}
function eatStartNode() {
if (maybeEatLiteral()) return pop();
else if (maybeEatParenExpression()) return pop();
else if (maybeEatTypeReference() || maybeEatNullReference() || maybeEatConstructorReference() || maybeEatMethodOrProperty(false) || maybeEatFunctionOrVar()) return pop();
else if (maybeEatBeanReference()) return pop();
else if (maybeEatProjection(false) || maybeEatSelection(false) || maybeEatIndexer()) return pop();
else if (maybeEatInlineListOrMap()) return pop();
else return null;
}
function maybeEatBeanReference() {
if (peekTokenOne(_TokenKind.TokenKind.BEAN_REF)) {
var beanRefToken = nextToken();
var beanNameToken = null;
var beanName = null;
if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {
beanNameToken = eatToken(_TokenKind.TokenKind.IDENTIFIER);
beanName = beanNameToken.data;
} else if (peekTokenOne(_TokenKind.TokenKind.LITERAL_STRING)) {
beanNameToken = eatToken(_TokenKind.TokenKind.LITERAL_STRING);
beanName = beanNameToken.stringValue();
beanName = beanName.substring(1, beanName.length() - 1);
} else raiseInternalException(beanRefToken.startPos, "INVALID_BEAN_REFERENCE");
var beanReference = _BeanReference.BeanReference.create(toPosToken(beanNameToken), beanName);
push(beanReference);
return true;
}
return false;
}
function maybeEatTypeReference() {
if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {
var typeName = peekToken();
if (typeName.stringValue() !== "T") return false;
var token = nextToken();
if (peekTokenOne(_TokenKind.TokenKind.RSQUARE)) {
push(_PropertyReference.PropertyReference.create(token.stringValue(), toPosToken(token)));
return true;
}
eatToken(_TokenKind.TokenKind.LPAREN);
var node = eatPossiblyQualifiedId();
var dims = 0;
while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) {
eatToken(_TokenKind.TokenKind.RSQUARE);
dims++;
}
eatToken(_TokenKind.TokenKind.RPAREN);
push(_TypeReference.TypeReference.create(toPosToken(typeName), node, dims));
return true;
}
return false;
}
function maybeEatNullReference() {
if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {
var nullToken = peekToken();
if (nullToken.stringValue().toLowerCase() !== "null") return false;
nextToken();
push(_NullLiteral.NullLiteral.create(toPosToken(nullToken)));
return true;
}
return false;
}
function maybeEatProjection(nullSafeNavigation) {
var token = peekToken();
if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.PROJECT, true)) return false;
var expr = eatExpression();
eatToken(_TokenKind.TokenKind.RSQUARE);
push(_Projection.Projection.create(nullSafeNavigation, toPosToken(token), expr));
return true;
}
function maybeEatInlineListOrMap() {
var token = peekToken(), listElements = [];
if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.LCURLY, true)) return false;
var expr = null;
var closingCurly = peekToken();
if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.RCURLY, true)) expr = _InlineList.InlineList.create(toPosBounds(token.startPos, closingCurly.endPos));
else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COLON, true)) {
closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);
expr = _InlineMap.InlineMap.create(toPosBounds(token.startPos, closingCurly.endPos));
} else {
var firstExpression = eatExpression();
if (peekTokenOne(_TokenKind.TokenKind.RCURLY)) {
listElements.push(firstExpression);
closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);
expr = _InlineList.InlineList.create(toPosBounds(token.startPos, closingCurly.endPos), listElements);
} else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true)) {
listElements.push(firstExpression);
do
listElements.push(eatExpression());
while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true));
closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);
expr = _InlineList.InlineList.create(toPosToken(token.startPos, closingCurly.endPos), listElements);
} else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COLON, true)) {
var mapElements = [];
mapElements.push(firstExpression);
mapElements.push(eatExpression());
while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true)) {
mapElements.push(eatExpression());
eatToken(_TokenKind.TokenKind.COLON);
mapElements.push(eatExpression());
}
closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);
expr = _InlineMap.InlineMap.create(toPosBounds(token.startPos, closingCurly.endPos), mapElements);
} else raiseInternalException(token.startPos, "OOD");
}
push(expr);
return true;
}
function maybeEatIndexer() {
var token = peekToken();
if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) return false;
var expr = eatExpression();
eatToken(_TokenKind.TokenKind.RSQUARE);
push(_Indexer.Indexer.create(toPosToken(token), expr));
return true;
}
function maybeEatSelection(nullSafeNavigation) {
var token = peekToken();
if (!peekSelectToken()) return false;
nextToken();
var expr = eatExpression();
if (expr === null) raiseInternalException(toPosToken(token), "MISSING_SELECTION_EXPRESSION");
eatToken(_TokenKind.TokenKind.RSQUARE);
if (token.getKind() === _TokenKind.TokenKind.SELECT_FIRST) push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.FIRST, toPosToken(token), expr));
else if (token.getKind() === _TokenKind.TokenKind.SELECT_LAST) push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.LAST, toPosToken(token), expr));
else push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.ALL, toPosToken(token), expr));
return true;
}
/**
* Eat an identifier, possibly qualified (meaning that it is dotted).
* TODO AndyC Could create complete identifiers (a.b.c) here rather than a sequence of them? (a, b, c)
*/
function eatPossiblyQualifiedId() {
var qualifiedIdPieces = [];
var node = peekToken();
while (isValidQualifiedId(node)) {
nextToken();
if (node.kind !== _TokenKind.TokenKind.DOT) qualifiedIdPieces.push(_Identifier.Identifier.create(node.stringValue(), toPosToken(node)));
node = peekToken();
}
if (!qualifiedIdPieces.length) {
if (node === null) raiseInternalException(expressionString.length(), "OOD");
raiseInternalException(node.startPos, "NOT_EXPECTED_TOKEN", "qualified ID", node.getKind().toString().toLowerCase());
}
var pos = toPosBounds(qualifiedIdPieces[0].getStartPosition(), qualifiedIdPieces[qualifiedIdPieces.length - 1].getEndPosition());
return _QualifiedIdentifier.QualifiedIdentifier.create(pos, qualifiedIdPieces);
}
function isValidQualifiedId(node) {
if (node === null || node.kind === _TokenKind.TokenKind.LITERAL_STRING) return false;
if (node.kind === _TokenKind.TokenKind.DOT || node.kind === _TokenKind.TokenKind.IDENTIFIER) return true;
var value = node.stringValue();
return value && value.length && VALID_QUALIFIED_ID_PATTERN.test(value);
}
function maybeEatMethodOrProperty(nullSafeNavigation) {
if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {
var methodOrPropertyName = nextToken();
var args = maybeEatMethodArgs();
if (args === null) {
push(_PropertyReference.PropertyReference.create(nullSafeNavigation, methodOrPropertyName.stringValue(), toPosToken(methodOrPropertyName)));
return true;
}
push(_MethodReference.MethodReference.create(nullSafeNavigation, methodOrPropertyName.stringValue(), toPosToken(methodOrPropertyName), args));
return true;
}
return false;
}
function maybeEatConstructorReference() {
if (peekIdentifierToken("new")) {
var newToken = nextToken();
if (peekTokenOne(_TokenKind.TokenKind.RSQUARE)) {
push(_PropertyReference.PropertyReference.create(newToken.stringValue(), toPosToken(newToken)));
return true;
}
var possiblyQualifiedConstructorName = eatPossiblyQualifiedId();
var nodes = [];
nodes.push(possiblyQualifiedConstructorName);
if (peekTokenOne(_TokenKind.TokenKind.LSQUARE)) {
var dimensions = [];
while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) {
if (!peekTokenOne(_TokenKind.TokenKind.RSQUARE)) dimensions.push(eatExpression());
else dimensions.push(null);
eatToken(_TokenKind.TokenKind.RSQUARE);
}
if (maybeEatInlineListOrMap()) nodes.push(pop());
push(_ConstructorReference.ConstructorReference.create(toPosToken(newToken), dimensions, nodes));
} else {
eatConstructorArgs(nodes);
push(_ConstructorReference.ConstructorReference.create(toPosToken(newToken), nodes));
}
return true;
}
return false;
}
function push(newNode) {
constructedNodes.push(newNode);
}
function pop() {
return constructedNodes.pop();
}
function maybeEatLiteral() {
var token = peekToken();
if (token === null) return false;
if (token.getKind() === _TokenKind.TokenKind.LITERAL_INT || token.getKind() === _TokenKind.TokenKind.LITERAL_LONG) push(_NumberLiteral.NumberLiteral.create(parseInt(token.stringValue(), 10), toPosToken(token)));
else if (token.getKind() === _TokenKind.TokenKind.LITERAL_REAL || token.getKind() === _TokenKind.TokenKind.LITERAL_REAL_FLOAT) push(_NumberLiteral.NumberLiteral.create(parseFloat(token.stringValue()), toPosToken(token)));
else if (token.getKind() === _TokenKind.TokenKind.LITERAL_HEXINT || token.getKind() === _TokenKind.TokenKind.LITERAL_HEXLONG) push(_NumberLiteral.NumberLiteral.create(parseInt(token.stringValue(), 16), toPosToken(token)));
else if (peekIdentifierToken("true")) push(_BooleanLiteral.BooleanLiteral.create(true, toPosToken(token)));
else if (peekIdentifierToken("false")) push(_BooleanLiteral.BooleanLiteral.create(false, toPosToken(token)));
else if (token.getKind() === _TokenKind.TokenKind.LITERAL_STRING) push(_StringLiteral.StringLiteral.create(token.stringValue(), toPosToken(token)));
else return false;
nextToken();
return true;
}
function maybeEatParenExpression() {
if (peekTokenOne(_TokenKind.TokenKind.LPAREN)) {
nextToken();
var expr = eatExpression();
eatToken(_TokenKind.TokenKind.RPAREN);
push(expr);
return true;
} else return false;
}
function maybeEatRelationalOperator() {
var token = peekToken();
if (token === null) return null;
if (token.isNumericRelationalOperator()) return token;
if (token.isIdentifier()) {
var idString = token.stringValue();
if (idString.toLowerCase() === "instanceof") return token.asInstanceOfToken();
if (idString.toLowerCase() === "matches") return token.asMatchesToken();
if (idString.toLowerCase() === "between") return token.asBetweenToken();
}
return null;
}
function eatToken(expectedKind) {
var token = nextToken();
if (token === null) raiseInternalException(expressionString.length, "OOD");
if (token.getKind() !== expectedKind) raiseInternalException(token.startPos, "NOT_EXPECTED_TOKEN", expectedKind.toString().toLowerCase(), token.getKind().toString().toLowerCase());
return token;
}
function peekTokenOne(desiredTokenKind) {
return peekTokenConsumeIfMatched(desiredTokenKind, false);
}
function peekTokenConsumeIfMatched(desiredTokenKind, consumeIfMatched) {
if (!moreTokens()) return false;
var token = peekToken();
if (token.getKind() === desiredTokenKind) {
if (consumeIfMatched) tokenStreamPointer++;
return true;
}
if (desiredTokenKind === _TokenKind.TokenKind.IDENTIFIER) {
if (token.getKind().ordinal() >= _TokenKind.TokenKind.DIV.ordinal() && token.getKind().ordinal() <= _TokenKind.TokenKind.NOT.ordinal() && token.data !== null) return true;
}
return false;
}
function peekTokenAny() {
if (!moreTokens()) return false;
var token = peekToken();
var args = Array.prototype.slice.call(arguments);
for (var i = 0, l = args.length; i < l; i += 1) if (token.getKind() === args[i]) return true;
return false;
}
function peekIdentifierToken(identifierString) {
if (!moreTokens()) return false;
var token = peekToken();
return token.getKind() === _TokenKind.TokenKind.IDENTIFIER && token.stringValue().toLowerCase() === identifierString.toLowerCase();
}
function peekSelectToken() {
if (!moreTokens()) return false;
var token = peekToken();
return token.getKind() === _TokenKind.TokenKind.SELECT || token.getKind() === _TokenKind.TokenKind.SELECT_FIRST || token.getKind() === _TokenKind.TokenKind.SELECT_LAST;
}
function moreTokens() {
return tokenStreamPointer < tokenStream.length;
}
function nextToken() {
if (tokenStreamPointer >= tokenStreamLength) return null;
return tokenStream[tokenStreamPointer++];
}
function peekToken() {
if (tokenStreamPointer >= tokenStreamLength) return null;
return tokenStream[tokenStreamPointer];
}
function raiseInternalException(pos, message, expected, actual) {
if (expected) message += "\nExpected: " + expected;
if (actual) message += "\nActual: " + actual;
throw {
name: "InternalParseException",
message: "Error occurred while attempting to parse expression '" + expressionString + "' at position " + pos + ". Message: " + message
};
}
function toString(token) {
if (token.getKind().hasPayload()) return token.stringValue();
return token.getKind().toString().toLowerCase();
}
function checkOperands(token, left, right) {
checkLeftOperand(token, left);
checkRightOperand(token, right);
}
function checkLeftOperand(token, operandExpression) {
if (operandExpression === null) raiseInternalException(token.startPos, "LEFT_OPERAND_PROBLEM");
}
function checkRightOperand(token, operandExpression) {
if (operandExpression === null) raiseInternalException(token.startPos, "RIGHT_OPERAND_PROBLEM");
}
/**
* Compress the start and end of a token into a single int.
*/
function toPosToken(token) {
return (token.startPos << 16) + token.endPos;
}
function toPosBounds(start, end) {
return (start << 16) + end;
}
return {
setConfiguration,
parse
};
};
}),
(function(module$1, exports$1, __webpack_require__) {
Object.defineProperty(exports$1, "__esModule", { value: true });
exports$1.Tokenizer = void 0;
var _Token = __webpack_require__(7);
var _TokenKind = __webpack_require__(2);
/**
* @author Andy Clement
* @author Phillip Webb
* @author Ben March
* @since 0.2.0
*/
var ALTERNATIVE_OPERATOR_NAMES = [
"DIV",
"EQ",
"GE",
"GT",
"LE",
"LT",
"MOD",
"NE",
"NOT"
], FLAGS = [], IS_DIGIT = 1, IS_HEXDIGIT = 2, IS_ALPHA = 4;
function init() {
var ch;
for (ch = "0".charCodeAt(0); ch <= "9".charCodeAt(0); ch += 1) FLAGS[ch] |= IS_DIGIT | IS_HEXDIGIT;
for (ch = "A".charCodeAt(0); ch <= "F".charCodeAt(0); ch += 1) FLAGS[ch] |= IS_HEXDIGIT;
for (ch = "a".charCodeAt(0); ch <= "f".charCodeAt(0); ch += 1) FLAGS[ch] |= IS_HEXDIGIT;
for (ch = "A".charCodeAt(0); ch <= "Z".charCodeAt(0); ch += 1) FLAGS[ch] |= IS_ALPHA;
for (ch = "a".charCodeAt(0); ch <= "z".charCodeAt(0); ch += 1) FLAGS[ch] |= IS_ALPHA;
}
init();
function tokenize(inputData) {
var expressionString = inputData, toProcess = inputData + "\0", max = toProcess.length, pos = 0, tokens = [];
function process() {
var ch;
while (pos < max) {
ch = toProcess[pos];
if (isAlphabetic(ch)) lexIdentifier();
else switch (ch) {
case "+":
if (isTwoCharToken(_TokenKind.TokenKind.INC)) pushPairToken(_TokenKind.TokenKind.INC);
else pushCharToken(_TokenKind.TokenKind.PLUS);
break;
case "_":
lexIdentifier();
break;
case "-":
if (isTwoCharToken(_TokenKind.TokenKind.DEC)) pushPairToken(_TokenKind.TokenKind.DEC);
else pushCharToken(_TokenKind.TokenKind.MINUS);
break;
case ":":
pushCharToken(_TokenKind.TokenKind.COLON);
break;
case ".":
pushCharToken(_TokenKind.TokenKind.DOT);
break;
case ",":
pushCharToken(_TokenKind.TokenKind.COMMA);
break;
case "*":
pushCharToken(_TokenKind.TokenKind.STAR);
break;
case "/":
pushCharToken(_TokenKind.TokenKind.DIV);
break;
case "%":
pushCharToken(_TokenKind.TokenKind.MOD);
break;
case "(":
pushCharToken(_TokenKind.TokenKind.LPAREN);
break;
case ")":
pushCharToken(_TokenKind.TokenKind.RPAREN);
break;
case "[":
pushCharToken(_TokenKind.TokenKind.LSQUARE);
break;
case "#":
pushCharToken(_TokenKind.TokenKind.HASH);
break;
case "]":
pushCharToken(_TokenKind.TokenKind.RSQUARE);
break;
case "{":
pushCharToken(_TokenKind.TokenKind.LCURLY);
break;
case "}":
pushCharToken(_TokenKind.TokenKind.RCURLY);
break;
case "@":
pushCharToken(_TokenKind.TokenKind.BEAN_REF);
break;
case "^":
if (isTwoCharToken(_TokenKind.TokenKind.SELECT_FIRST)) pushPairToken(_TokenKind.TokenKind.SELECT_FIRST);
else pushCharToken(_TokenKind.TokenKind.POWER);
break;
case "!":
if (isTwoCharToken(_TokenKind.TokenKind.NE)) pushPairToken(_TokenKind.TokenKind.NE);
else if (isTwoCharToken(_TokenKind.TokenKind.PROJECT)) pushPairToken(_TokenKind.TokenKind.PROJECT);
else pushCharToken(_TokenKind.TokenKind.NOT);
break;
case "=":
if (isTwoCharToken(_TokenKind.TokenKind.EQ)) pushPairToken(_TokenKind.TokenKind.EQ);
else pushCharToken(_TokenKind.TokenKind.ASSIGN);
break;
case "&":
if (!isTwoCharToken(_TokenKind.TokenKind.SYMBOLIC_AND)) throw {
name: "SpelParseException",
message: "Missing character '&' in expression (" + expressionString + ") at position " + pos
};
pushPairToken(_TokenKind.TokenKind.SYMBOLIC_AND);
break;
case "|":
if (!isTwoCharToken(_TokenKind.TokenKind.SYMBOLIC_OR)) throw {
name: "SpelParseException",
message: "Missing character '|' in expression (" + expressionString + ") at position " + pos
};
pushPairToken(_TokenKind.TokenKind.SYMBOLIC_OR);
break;
case "?":
if (isTwoCharToken(_TokenKind.TokenKind.SELECT)) pushPairToken(_TokenKind.TokenKind.SELECT);
else if (isTwoCharToken(_TokenKind.TokenKind.ELVIS)) pushPairToken(_TokenKind.TokenKind.ELVIS);
else if (isTwoCharToken(_TokenKind.TokenKind.SAFE_NAVI)) pushPairToken(_TokenKind.TokenKind.SAFE_NAVI);
else pushCharToken(_TokenKind.TokenKind.QMARK);
break;
case "$":
if (isTwoCharToken(_TokenKind.TokenKind.SELECT_LAST)) pushPairToken(_TokenKind.TokenKind.SELECT_LAST);
else lexIdentifier();
break;
case ">":
if (isTwoCharToken(_TokenKind.TokenKind.GE)) pushPairToken(_TokenKind.TokenKind.GE);
else pushCharToken(_TokenKind.TokenKind.GT);
break;
case "<":
if (isTwoCharToken(_TokenKind.TokenKind.LE)) pushPairToken(_TokenKind.TokenKind.LE);
else pushCharToken(_TokenKind.TokenKind.LT);
break;
case "0":
case "1":
case "2":
case "3":
case "4":
case "5":
case "6":
case "7":
case "8":
case "9":
lexNumericLiteral(ch === "0");
break;
case " ":
case " ":
case "\r":
case "\n":
pos += 1;
break;
case "'":
lexQuotedStringLiteral();
break;
case "\"":
lexDoubleQuotedStringLiteral();
break;
case "\0":
pos += 1;
break;
case "\\": throw {
name: "SpelParseException",
message: "Unexpected escape character in expression (" + expressionString + ") at position " + pos
};
default: throw {
name: "SpelParseException",
message: "Cannot handle character '" + ch + "' in expression (" + expressionString + ") at position " + pos
};
}
}
}
function lexQuotedStringLiteral() {
var start = pos, terminated = false, ch;
while (!terminated) {
pos += 1;
ch = toProcess[pos];
if (ch === "'") if (toProcess[pos + 1] === "'") pos += 1;
else terminated = true;
if (ch.charCodeAt(0) === 0) throw {
name: "SpelParseException",
message: "Non-terminating quoted string in expression (" + expressionString + ") at position " + pos
};
}
pos += 1;
tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_STRING, subarray(start, pos), start, pos));
}
function lexDoubleQuotedStringLiteral() {
var start = pos, terminated = false, ch;
while (!terminated) {
pos += 1;
ch = toProcess[pos];
if (ch === "\"") if (toProcess[pos + 1] === "\"") pos += 1;
else terminated = true;
if (ch.charCodeAt(0) === 0) throw {
name: "SpelParseException",
message: "Non-terminating double-quoted string in expression (" + expressionString + ") at position " + pos
};
}
pos += 1;
tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_STRING, subarray(start, pos), start, pos));
}
function lexNumericLiteral(firstCharIsZero) {
var isReal = false, start = pos, ch = toProcess[pos + 1], isHex = ch === "x" || ch === "X", dotpos, endOfNumber, possibleSign, isFloat;
if (firstCharIsZero && isHex) {
pos = pos + 1;
do
pos += 1;
while (isHexadecimalDigit(toProcess[pos]));
if (isChar("L", "l")) {
pushHexIntToken(subarray(start + 2, pos), true, start, pos);
pos += 1;
} else pushHexIntToken(subarray(start + 2, pos), false, start, pos);
return;
}
do
pos += 1;
while (isDigit(toProcess[pos]));
ch = toProcess[pos];
if (ch === ".") {
isReal = true;
dotpos = pos;
do
pos += 1;
while (isDigit(toProcess[pos]));
if (pos === dotpos + 1) {
pos = dotpos;
pushIntToken(subarray(start, pos), false, start, pos);
return;
}
}
endOfNumber = pos;
if (isChar("L", "l")) {
if (isReal) throw {
name: "SpelParseException",
message: "Real cannot be long in expression (" + expressionString + ") at position " + pos
};
pushIntToken(subarray(start, endOfNumber), true, start, endOfNumber);
pos += 1;
} else if (isExponentChar(toProcess[pos])) {
isReal = true;
pos += 1;
possibleSign = toProcess[pos];
if (isSign(possibleSign)) pos += 1;
do
pos += 1;
while (isDigit(toProcess[pos]));
isFloat = false;
if (isFloatSuffix(toProcess[pos])) {
isFloat = true;
pos += 1;
endOfNumber = pos;
} else if (isDoubleSuffix(toProcess[pos])) {
pos += 1;
endOfNumber = pos;
}
pushRealToken(subarray(start, pos), isFloat, start, pos);
} else {
ch = toProcess[pos];
isFloat = false;
if (isFloatSuffix(ch)) {
isReal = true;
isFloat = true;
pos += 1;
endOfNumber = pos;
} else if (isDoubleSuffix(ch)) {
isReal = true;
pos += 1;
endOfNumber = pos;
}
if (isReal) pushRealToken(subarray(start, endOfNumber), isFloat, start, endOfNumber);
else pushIntToken(subarray(start, endOfNumber), false, start, endOfNumber);
}
}
function lexIdentifier() {
var start = pos, substring, asString, idx;
do
pos += 1;
while (isIdentifier(toProcess[pos]));
substring = subarray(start, pos);
if (pos - start === 2 || pos - start === 3) {
asString = substring.toUpperCase();
idx = ALTERNATIVE_OPERATOR_NAMES.indexOf(asString);
if (idx >= 0) {
pushOneCharOrTwoCharToken(_TokenKind.TokenKind.valueOf(asString), start, substring);
return;
}
}
tokens.push(new _Token.Token(_TokenKind.TokenKind.IDENTIFIER, substring.replace("\0", ""), start, pos));
}
function pushIntToken(data, isLong, start, end) {
if (isLong) tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_LONG, data, start, end));
else tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_INT, data, start, end));
}
function pushHexIntToken(data, isLong, start, end) {
if (data.length === 0) if (isLong) throw {
name: "SpelParseException",
message: "Not a long in expression (" + expressionString + ") at position " + pos
};
else throw {
name: "SpelParseException",
message: "Not an int in expression (" + expressionString + ") at position " + pos
};
if (isLong) tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_HEXLONG, data, start, end));
else tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_HEXINT, data, start, end));
}
function pushRealToken(data, isFloat, start, end) {
if (isFloat) tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_REAL_FLOAT, data, start, end));
else tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_REAL, data, start, end));
}
function subarray(start, end) {
return toProcess.substring(start, end);
}
/**
* Check if this might be a two character token.
*/
function isTwoCharToken(kind) {
if (kind.tokenChars.length === 2 && toProcess[pos] === kind.tokenChars[0]) return toProcess[pos + 1] === kind.tokenChars[1];
return false;
}
/**
* Push a token of just one character in length.
*/
function pushCharToken(kind) {
tokens.push(new _Token.Token(kind, null, pos, pos + 1));
pos += 1;
}
/**
* Push a token of two characters in length.
*/
function pushPairToken(kind) {
tokens.push(new _Token.Token(kind, null, pos, pos + 2));
pos += 2;
}
function pushOneCharOrTwoCharToken(kind, pos$1, data) {
tokens.push(new _Token.Token(kind, data, pos$1, pos$1 + kind.getLength()));
}
function isIdentifier(ch) {
return isAlphabetic(ch) || isDigit(ch) || ch === "_" || ch === "$";
}
function isChar(a, b) {
var ch = toProcess[pos];
return ch === a || ch === b;
}
function isExponentChar(ch) {
return ch === "e" || ch === "E";
}
function isFloatSuffix(ch) {
return ch === "f" || ch === "F";
}
function isDoubleSuffix(ch) {
return ch === "d" || ch === "D";
}
function isSign(ch) {