expressionish 0.1.0 → 0.1.1

package/dist/expressionish.mjs

@@ -0,0 +1,1429 @@
+// src/misc/split.ts
+var HIGH_SURROGATE_START = 55296;
+var HIGH_SURROGATE_END = 56319;
+var LOW_SURROGATE_START = 56320;
+var REGIONAL_INDICATOR_START = 127462;
+var REGIONAL_INDICATOR_END = 127487;
+var FITZPATRICK_MODIFIER_START = 127995;
+var FITZPATRICK_MODIFIER_END = 127999;
+var VARIATION_MODIFIER_START = 65024;
+var VARIATION_MODIFIER_END = 65039;
+var DIACRITICAL_MARKS_START = 8400;
+var DIACRITICAL_MARKS_END = 8447;
+var ZWJ = 8205;
+var GRAPHEMS = /* @__PURE__ */ new Set([
+  776,
+  // ( ◌̈ ) COMBINING DIAERESIS
+  2359,
+  // ( ष ) DEVANAGARI LETTER SSA
+  2367,
+  // ( ि ) DEVANAGARI VOWEL SIGN I
+  2984,
+  // ( ந ) TAMIL LETTER NA
+  3007,
+  // ( ி ) TAMIL VOWEL SIGN I
+  3021,
+  // ( ◌்) TAMIL SIGN VIRAMA
+  3633,
+  // ( ◌ั ) THAI CHARACTER MAI HAN-AKAT
+  3635,
+  // ( ำ ) THAI CHARACTER SARA AM
+  3648,
+  // ( เ ) THAI CHARACTER SARA E
+  3657,
+  // ( เ ) THAI CHARACTER MAI THO
+  4352,
+  // ( ᄀ ) HANGUL CHOSEONG KIYEOK
+  4449,
+  // ( ᅡ ) HANGUL JUNGSEONG A
+  4520
+  // ( ᆨ ) HANGUL JONGSEONG KIYEOK
+]);
+var betweenInclusive = (value, lower, upper) => {
+  return value >= lower && value <= upper;
+};
+var codePointFromSurrogatePair = (pair) => {
+  const highOffset = pair.charCodeAt(0) - HIGH_SURROGATE_START;
+  const lowOffset = pair.charCodeAt(1) - LOW_SURROGATE_START;
+  return (highOffset << 10) + lowOffset + 65536;
+};
+var tokenize = (input) => {
+  if (typeof input !== "string") {
+    throw new Error("string cannot be undefined or null");
+  }
+  const asciiPunct = /^[\x01-\x2F\x3A-\x40\x5B-\x60\x7B-\x7E]$/;
+  const result = [];
+  let idx = 0;
+  let inc = 0;
+  let tok = null;
+  let escaped = false;
+  while (idx < input.length) {
+    const idxInc = idx + inc;
+    const current = input[idxInc];
+    if (idxInc < input.length - 1 && current && betweenInclusive(current.charCodeAt(0), HIGH_SURROGATE_START, HIGH_SURROGATE_END)) {
+      const currPair = codePointFromSurrogatePair(current + input[idxInc + 1]);
+      const nextPair = codePointFromSurrogatePair(input.substring(idxInc + 2, idxInc + 5));
+      if (betweenInclusive(currPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END) && betweenInclusive(nextPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END)) {
+        inc += 4;
+      } else if (betweenInclusive(nextPair, FITZPATRICK_MODIFIER_START, FITZPATRICK_MODIFIER_END)) {
+        inc += 4;
+      } else {
+        inc += 2;
+      }
+    } else {
+      inc += 1;
+    }
+    if (GRAPHEMS.has((input[idx + inc] + "").charCodeAt(0))) {
+      inc += 1;
+    }
+    if (betweenInclusive((input[idx + inc] + "").charCodeAt(0), VARIATION_MODIFIER_START, VARIATION_MODIFIER_END)) {
+      inc += 1;
+    }
+    if (betweenInclusive((input[idx + inc] + "").charCodeAt(0), DIACRITICAL_MARKS_START, DIACRITICAL_MARKS_END)) {
+      inc += 1;
+    }
+    if ((input[idx + inc] + "").charCodeAt(0) === ZWJ) {
+      inc += 1;
+      continue;
+    }
+    if (inc > 1) {
+      if (tok != null) {
+        result.push(tok);
+        tok = null;
+      }
+      result.push({ position: idx, value: input.substring(idx, idx + inc) });
+      escaped = false;
+    } else if (input.substring(idx, idx + 2) === "``") {
+      if (tok != null) {
+        result.push(tok);
+        tok = null;
+      }
+      if (escaped) {
+        result.push({ position: idx, value: "`" });
+        escaped = false;
+      } else {
+        result.push({ position: idx, value: "``" });
+        inc += 1;
+      }
+    } else if (input[idx] === "\\") {
+      if (tok != null) {
+        result.push(tok);
+        tok = null;
+      }
+      result.push({ position: idx, value: "\\" });
+      escaped = !escaped;
+    } else if (asciiPunct.test(input[idx])) {
+      if (tok != null) {
+        result.push(tok);
+        tok = null;
+      }
+      result.push({ position: idx, value: input[idx] });
+      escaped = false;
+    } else if (escaped) {
+      result.push({ position: idx, value: input[idx] });
+      escaped = false;
+    } else if (tok == null) {
+      tok = { position: idx, value: input[idx] };
+    } else {
+      tok.value += input[idx];
+    }
+    idx += inc;
+    inc = 0;
+  }
+  if (tok != null) {
+    result.push(tok);
+  }
+  return result;
+};
+
+// src/parse/base-token.ts
+var BaseToken = class {
+  position;
+  type;
+  value;
+  constructor(options) {
+    this.position = options.position;
+    this.type = options.type || "UNKNOWN";
+    this.value = options.value;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value
+    };
+  }
+  async evaluate(options) {
+    if (options.onlyValidate) {
+      return;
+    }
+    return this.value;
+  }
+};
+
+// src/parse/sequence-token.ts
+var SequenceToken = class extends BaseToken {
+  value;
+  constructor(options) {
+    super({
+      ...options,
+      type: "LIST"
+    });
+    this.value = [];
+  }
+  add(token) {
+    if (token.type !== "TEXT" || !this.value.length || this.value[this.value.length - 1].type !== "TEXT") {
+      this.value.push(token);
+    } else {
+      this.value[this.value.length - 1].value += token.value;
+    }
+  }
+  get unwrap() {
+    if (this.value.length === 1) {
+      return this.value[0];
+    }
+    return this;
+  }
+  toJSON() {
+    const unwrapped = this.unwrap;
+    if (unwrapped !== this) {
+      return unwrapped.toJSON();
+    }
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value.map((token) => token.toJSON())
+    };
+  }
+  async evaluate(options) {
+    if (this.value == null || this.value.length === 0) {
+      return;
+    }
+    if (this.value.length === 1) {
+      return this.value[0].evaluate(options || {});
+    }
+    return (await Promise.all(this.value.map((token) => token.evaluate(options || {})))).reduce((prev, curr) => {
+      if (prev == null) {
+        return curr;
+      }
+      if (curr == null) {
+        return prev;
+      }
+      return prev + curr;
+    });
+  }
+};
+
+// src/parse/root/token.ts
+var RootToken = class extends SequenceToken {
+  lookups;
+  variables;
+  expression;
+  logicOperators;
+  comparisonOperators;
+  constructor(options) {
+    super({
+      position: 0
+    });
+    this.type = "ROOT";
+    this.lookups = options.lookups;
+    this.variables = options.variables;
+    this.logicOperators = options.logicalOperators || /* @__PURE__ */ new Map();
+    this.comparisonOperators = options.comparisonOperators || /* @__PURE__ */ new Map();
+    this.expression = options.expression;
+  }
+  toJSON() {
+    return super.toJSON();
+  }
+  async evaluate(options = {}) {
+    return super.evaluate({
+      ...options,
+      lookups: this.lookups,
+      variables: this.variables,
+      logicalOperators: this.logicOperators,
+      comparisonOperators: this.comparisonOperators,
+      expression: this.expression
+    });
+  }
+};
+
+// src/parse/text/token.ts
+var TextToken = class extends BaseToken {
+  value;
+  constructor(options) {
+    super({
+      ...options,
+      type: "TEXT"
+    });
+    this.value = options.value || "";
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value
+    };
+  }
+};
+
+// src/errors.ts
+var ExpressionError = class extends Error {
+  /** When defined: where the error was encountered within the expression text */
+  position;
+  constructor(message, position) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = "ExpressionError";
+    this.message = message;
+    this.position = position;
+  }
+  static get name() {
+    return "ExpressionError";
+  }
+};
+var ExpressionArgumentsError = class extends ExpressionError {
+  /** The index of the argument in the arguments list */
+  index;
+  /** The variable name the arguments list belongs to */
+  varname;
+  constructor(message, position, index, varname) {
+    super(message, position);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = "ExpressionArgumentsError";
+    this.index = index || -1;
+    this.varname = varname;
+  }
+  static get name() {
+    return "ExpressionArgumentsError";
+  }
+};
+var ExpressionVariableError = class extends ExpressionError {
+  /** The associated variable name */
+  varname;
+  constructor(message, position, varname) {
+    super(message, position);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = "ExpressionVariableError";
+    this.varname = varname;
+  }
+  static get name() {
+    return "ExpressionVariableError";
+  }
+};
+var ExpressionSyntaxError = class extends ExpressionError {
+  /** The character associated with the error */
+  character;
+  constructor(message, position, character) {
+    super(message, position);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = "ExpressionSyntaxError";
+    this.character = character;
+  }
+  static get name() {
+    return "ExpressionSyntaxError";
+  }
+};
+
+// src/parse/lookup/token.ts
+var LookupToken = class extends BaseToken {
+  prefix;
+  value;
+  arguments;
+  constructor(options) {
+    super({
+      ...options,
+      type: "LOOKUP"
+    });
+    this.value = options.value;
+    this.prefix = options.prefix;
+    this.arguments = options.arguments;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      prefix: this.prefix,
+      value: this.value,
+      arguments: this.arguments ? this.arguments.toJSON() : void 0
+    };
+  }
+  async evaluate(options) {
+    if (!options.lookups) {
+      throw new ExpressionVariableError(`lookup map invalid`, this.position, this.value);
+    }
+    const lookup = options.lookups.get(this.prefix);
+    if (lookup == null) {
+      throw new ExpressionVariableError(`unknown lookup prefix`, this.position, this.prefix);
+    }
+    const variable = await lookup(options.data || {}, this.value);
+    if (variable == null) {
+      return;
+    }
+    if (options.preeval) {
+      await options.preeval(options.data || {}, variable);
+    }
+    if (variable.preeval) {
+      await variable.preeval(options.data || {}, variable);
+    }
+    let args = [];
+    if (this.arguments) {
+      args = await this.arguments.evaluate(options);
+    }
+    if (options.onlyValidate) {
+      return;
+    }
+    if (variable.argsCheck) {
+      await variable.argsCheck(options.data || {}, ...args);
+    }
+    return variable.evaluate(options.data || {}, ...args);
+  }
+};
+
+// src/parse/arguments/token.ts
+var ArgumentsToken = class extends BaseToken {
+  value;
+  constructor(options) {
+    super({
+      ...options,
+      type: "ARGUMENTS_LIST"
+    });
+    this.value = options.value || [];
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value.map((item) => item.toJSON())
+    };
+  }
+  async evaluate(options) {
+    return Promise.all(this.value.map((item) => item.evaluate(options)));
+  }
+};
+
+// src/parse/text/escape.ts
+var escape_default = (tokens, cursor, escapeChars) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value != "\\") {
+    return [false];
+  }
+  if (escapeChars == null) {
+    escapeChars = '"$[,]\\rnt`';
+  }
+  if (escapeChars.includes("`") && tokens[cursor + 1].value === "`" && tokens[cursor + 2].value === "`") {
+    return [true, cursor + 3, { position: cursor, value: "``" }];
+  }
+  if (!escapeChars.includes(tokens[cursor + 1].value)) {
+    return [true, cursor + 1, { position: cursor, value: "\\" }];
+  }
+  cursor += 1;
+  const token = { ...tokens[cursor] };
+  switch (token.value) {
+    case "n":
+      token.value = "\n";
+      break;
+    case "r":
+      token.value = "\r";
+      break;
+    case "t":
+      token.value = "	";
+      break;
+  }
+  return [true, cursor + 1, token];
+};
+
+// src/parse/text/quote.ts
+var quote_default = (tokens, cursor) => {
+  const count = tokens.length;
+  if (cursor >= count || tokens[cursor] == null || tokens[cursor].value !== '"') {
+    return [false];
+  }
+  const start = cursor;
+  cursor += 1;
+  let text = "";
+  while (cursor < count) {
+    if (tokens[cursor].value === '"') {
+      return [
+        true,
+        cursor + 1,
+        new TextToken({
+          position: start,
+          value: text
+        })
+      ];
+    }
+    const [tokenized, tokenizeCursor, tokenizeResult] = escape_default(tokens, cursor, '\\"nrt');
+    if (tokenized) {
+      cursor = tokenizeCursor;
+      text += tokenizeResult.value;
+      continue;
+    }
+    text += tokens[cursor].value;
+    cursor += 1;
+  }
+  throw new ExpressionSyntaxError("End quote missing", tokens[start].position);
+};
+
+// src/parse/if/token.ts
+var IfToken = class extends BaseToken {
+  value;
+  whenTrue;
+  whenFalse;
+  constructor(options) {
+    super({
+      position: options.position,
+      type: "IF"
+    });
+    this.value = options.value;
+    this.whenTrue = options.whenTrue;
+    this.whenFalse = options.whenFalse;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value.toJSON(),
+      whenTrue: this.whenTrue.toJSON(),
+      whenFalse: this.whenFalse ? this.whenFalse.toJSON() : void 0
+    };
+  }
+  async evaluate(options) {
+    const result = await this.value.evaluate(options);
+    if (options.onlyValidate) {
+      await this.whenTrue.evaluate(options);
+      if (this.whenFalse) {
+        await this.whenFalse.evaluate(options);
+      }
+    } else if (result) {
+      return this.whenTrue.evaluate(options);
+    }
+    if (this.whenFalse) {
+      return this.whenFalse.evaluate(options);
+    }
+  }
+};
+
+// src/parse/comparison/operators.ts
+var toNumber = (data, v1, v2) => {
+  if (v1 === "" || v2 === "") {
+    return [v1, v2];
+  }
+  const v1Num = Number(v1);
+  if (!Number.isFinite(v1Num)) {
+    return [v1, v2];
+  }
+  const v2Num = Number(v2);
+  if (!Number.isFinite(v2Num)) {
+    return [v1, v2];
+  }
+  return [v1Num, v2Num];
+};
+var isStrictEqual = (data, v1, v2) => {
+  [v1, v2] = toNumber(data, v1, v2);
+  return v1 === v2;
+};
+var isTruthy = (data, v1) => {
+  return v1 != null && v1 !== false && v1 !== 0 && v1 !== "";
+};
+var operators_default = /* @__PURE__ */ new Map([
+  ["istruthy", {
+    maxArgumentsCount: 1,
+    evaluate: isTruthy
+  }],
+  ["!istruthy", {
+    maxArgumentsCount: 1,
+    evaluate: (data, v1) => !isTruthy(data, v1)
+  }],
+  ["===", {
+    minArgumentsCount: 2,
+    evaluate: isStrictEqual
+  }],
+  ["!==", {
+    minArgumentsCount: 2,
+    evaluate: (data, v1, v2) => !isStrictEqual(data, v1, v2)
+  }],
+  ["<", {
+    minArgumentsCount: 2,
+    evaluate: (data, v1, v2) => {
+      [v1, v2] = toNumber(data, v1, v2);
+      if (typeof v1 !== "number" || typeof v2 !== "number") {
+        return false;
+      }
+      return v1 < v2;
+    }
+  }],
+  ["<=", {
+    minArgumentsCount: 2,
+    evaluate: (data, v1, v2) => {
+      [v1, v2] = toNumber(data, v1, v2);
+      if (typeof v1 !== "number" || typeof v2 !== "number") {
+        return false;
+      }
+      return v1 <= v2;
+    }
+  }],
+  [">", {
+    minArgumentsCount: 2,
+    evaluate: (data, v1, v2) => {
+      [v1, v2] = toNumber(data, v1, v2);
+      if (typeof v1 !== "number" || typeof v2 !== "number") {
+        return false;
+      }
+      return v1 > v2;
+    }
+  }],
+  [">=", {
+    minArgumentsCount: 2,
+    evaluate: (data, v1, v2) => {
+      [v1, v2] = toNumber(data, v1, v2);
+      if (typeof v1 !== "number" || typeof v2 !== "number") {
+        return false;
+      }
+      return v1 >= v2;
+    }
+  }]
+]);
+
+// src/parse/comparison/token.ts
+var ComparisonToken = class extends BaseToken {
+  value;
+  left;
+  right;
+  constructor(options) {
+    super({
+      ...options,
+      type: "COMPARISON"
+    });
+    this.value = options.value;
+    this.left = options.left;
+    this.right = options.right;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value,
+      left: this.left.toJSON(),
+      right: this.right ? this.right.toJSON() : void 0
+    };
+  }
+  async evaluate(options) {
+    if (!this.value || this.value === "") {
+      this.value = "istruthy";
+    }
+    const operator = operators_default.get(this.value);
+    if (operator == null) {
+      return false;
+    }
+    const left = await this.left.evaluate(options);
+    let right;
+    if (this.right) {
+      right = await this.right.evaluate(options);
+    }
+    if (options.onlyValidate) {
+      return;
+    }
+    return operator.evaluate(options.data || {}, left, right);
+  }
+};
+
+// src/parse/variable/token.ts
+var VariableToken = class extends BaseToken {
+  value;
+  arguments;
+  constructor(options) {
+    super({
+      ...options,
+      type: "VARIABLE"
+    });
+    this.value = options.value || "";
+    this.arguments = options.arguments;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value,
+      arguments: this.arguments ? this.arguments.toJSON() : void 0
+    };
+  }
+  async evaluate(options) {
+    if (!options.variables || !options.variables.has(this.value)) {
+      throw new Error("unknown variable");
+    }
+    const variable = options.variables.get(this.value);
+    if (options.preeval) {
+      await options.preeval(options.data || {}, variable);
+    }
+    if (variable.preeval) {
+      await variable.preeval(options.data || {}, variable);
+    }
+    let args = [];
+    if (this.arguments) {
+      args = await this.arguments.evaluate(options);
+    }
+    if (variable.argsCheck) {
+      await variable.argsCheck(options.data || {}, ...args);
+    }
+    if (options.onlyValidate) {
+      return;
+    }
+    return variable.evaluate(options.data || {}, ...args);
+  }
+};
+
+// src/parse/variable/tokenize.ts
+var tokenize_default2 = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value !== "$") {
+    return [false];
+  }
+  const start = cursor;
+  cursor += 1;
+  const name = tokens[cursor].value;
+  if (!/^[a-z][a-z\d]*/i.test(name)) {
+    return [false];
+  }
+  if (!options.variables.has(name)) {
+    throw new ExpressionVariableError("unknown variable", tokens[cursor].position, name);
+  }
+  cursor += 1;
+  const [tokenized, tCursor, tResult] = tokenize_default(tokens, cursor, options);
+  if (tokenized) {
+    cursor = tCursor;
+  }
+  return [
+    true,
+    cursor,
+    new VariableToken({
+      position: start,
+      value: name,
+      arguments: tResult
+    })
+  ];
+};
+
+// src/parse/whitespace/tokenize.ts
+var tokenize_default3 = ((tokens, cursor) => {
+  const count = tokens.length;
+  if (cursor >= count) {
+    return [false];
+  }
+  let ws = "";
+  let index = cursor;
+  while (index < count && (tokens[index].value === " " || tokens[index].value === "\n" || tokens[index].value === "\r" || tokens[index].value === "	" || tokens[index].value === "\b" || tokens[index].value === "\f")) {
+    ws += tokens[index].value;
+    index += 1;
+  }
+  if (cursor === index) {
+    return [false];
+  }
+  return [true, index, ws];
+});
+
+// src/parse/comparison/tokenize.ts
+var tokenizeOperator = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor >= count || tokens[cursor].value === "," || tokens[cursor].value === "]" || /^\s/.test(tokens[cursor].value)) {
+    return [false];
+  }
+  let operator = "";
+  if (tokens[cursor].value === "!") {
+    operator = "!";
+    cursor += 1;
+    if (cursor >= count || tokens[cursor].value === "," || tokens[cursor].value === "]" || /^\s/.test(tokens[cursor].value)) {
+      return [false];
+    }
+  }
+  if (/^[a-z]+$/i.test(tokens[cursor].value)) {
+    operator += tokens[cursor].value.toLowerCase();
+    cursor += 1;
+  } else {
+    let operatorAccumulator = operator;
+    let tmpCursor = cursor;
+    while (tmpCursor < count) {
+      if (!/^[\x21-\x2F\x3A-\x40\x5E-\x60]$/.test(tokens[tmpCursor].value)) {
+        break;
+      }
+      operatorAccumulator += tokens[tmpCursor].value;
+      tmpCursor += 1;
+      if (options.operators.has(operatorAccumulator)) {
+        operator = operatorAccumulator;
+        cursor = tmpCursor;
+      }
+    }
+  }
+  if (cursor >= count || !options.operators.has(operator) || tokens[cursor].value !== "," && tokens[cursor].value !== "]" && !/^\s+$/.test(tokens[cursor].value)) {
+    return [false];
+  }
+  const [wsRem, wsCursor] = tokenize_default3(tokens, cursor);
+  if (wsRem) {
+    cursor = wsCursor;
+  }
+  return [true, cursor, operator];
+};
+var tokenize_default6 = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor >= count || tokens[cursor].value === "," || tokens[cursor].value === "]") {
+    return [false];
+  }
+  const mergedOperators = new Map(operators_default);
+  if (options.comparisonOperators) {
+    options.comparisonOperators.forEach((operator2, key) => {
+      mergedOperators.set(key, operator2);
+    });
+  }
+  const start = tokens[cursor].position;
+  const consumeWS = () => {
+    const [wsRem, wsCursor, wsResult] = tokenize_default3(tokens, cursor);
+    if (wsRem) {
+      cursor = wsCursor;
+      return wsResult;
+    }
+    return "";
+  };
+  const left = new SequenceToken({ position: start });
+  let operator;
+  let right;
+  while (cursor < count) {
+    const position = cursor;
+    const ws = consumeWS();
+    if (cursor >= count || tokens[cursor].value === "," || tokens[cursor].value === "]") {
+      break;
+    }
+    if (left.value.length > 0 && operator == null && ws !== "") {
+      const [opTokenized, opCursor, opResult] = tokenizeOperator(tokens, cursor, { ...options, operators: mergedOperators });
+      if (opTokenized) {
+        if (left.value.length === 0) {
+          throw new ExpressionSyntaxError("left operand not specified", start);
+        }
+        cursor = opCursor;
+        operator = opResult;
+        right = new SequenceToken({ position: cursor });
+        continue;
+      }
+    }
+    const parts = right ? right : left;
+    if (ws !== "") {
+      parts.add(new TextToken({ position, value: ws }));
+    }
+    const [eTokenized, eCursor, eResult] = escape_default(tokens, cursor, '"$,\\`]');
+    if (eTokenized) {
+      parts.add(new TextToken({ position, value: eResult.value }));
+      cursor = eCursor;
+    }
+    let [tokenized, tCursor, tResult] = quote_default(tokens, cursor);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default5(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default4(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default2(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    parts.add(new TextToken(tokens[cursor]));
+    cursor += 1;
+  }
+  if (!left.value.length) {
+    return [false];
+  }
+  operator = operator || "istruthy";
+  if (operators_default.get(operator)?.maxArgumentsCount === 1 && right != null && (!(right instanceof SequenceToken) || right.value.length !== 0)) {
+    throw new ExpressionArgumentsError(`comparison operator ${operator} must not have a right-hand-side value`);
+  }
+  if (operators_default.get(operator)?.minArgumentsCount === 2 && (right == null || right instanceof SequenceToken && right.value.length === 0)) {
+    throw new ExpressionArgumentsError(`comparison operator ${operator} requires a right-hand-side value`);
+  }
+  return [
+    true,
+    cursor,
+    new ComparisonToken({
+      position: start,
+      value: operator,
+      left: left.unwrap,
+      right: right ? right.unwrap : void 0
+    })
+  ];
+};
+
+// src/parse/logic/operators.ts
+var not = (data, arg) => arg == null || arg === false || arg === 0 || arg === "";
+var operators_default2 = /* @__PURE__ */ new Map([
+  ["not", {
+    minArgumentsCount: 1,
+    maxArgumentsCount: 1,
+    evaluate: not
+  }],
+  ["and", {
+    minArgumentsCount: 1,
+    evaluate: (data, ...args) => {
+      if (args == null || !args.length) {
+        return false;
+      }
+      return !args.some((item) => not(data, item));
+    }
+  }],
+  ["or", {
+    minArgumentsCount: 1,
+    evaluate: (data, ...args) => {
+      if (args == null || !args.length) {
+        return false;
+      }
+      return args.some((item) => !not(data, item));
+    }
+  }]
+]);
+
+// src/parse/logic/token.ts
+var LogicToken = class extends BaseToken {
+  value;
+  arguments;
+  constructor(options) {
+    super({
+      ...options,
+      type: "LOGIC"
+    });
+    this.value = options.value;
+    this.arguments = options.arguments;
+  }
+  toJSON() {
+    return {
+      position: this.position,
+      type: this.type,
+      value: this.value,
+      arguments: this.arguments.toJSON()
+    };
+  }
+  async evaluate(options) {
+    let operator;
+    if (options.logicalOperators?.has(this.value)) {
+      operator = options.logicalOperators.get(this.value);
+    } else if (operators_default2.has(this.value)) {
+      operator = operators_default2.get(this.value);
+    } else {
+      return false;
+    }
+    const args = await this.arguments.evaluate(options);
+    if (operator.argsCheck) {
+      operator.argsCheck(options.data || {}, ...args);
+    }
+    if (options.onlyValidate) {
+      return;
+    }
+    return operator.evaluate(options.data || {}, ...args);
+  }
+};
+
+// src/parse/logic/tokenize.ts
+var tokenizeLogicOperator = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value !== "$") {
+    return [false];
+  }
+  const start = tokens[cursor].position;
+  cursor += 1;
+  const mergedOperators = new Map(operators_default2);
+  if (options.logicalOperators) {
+    options.logicalOperators.forEach((operator2, key) => {
+      mergedOperators.set(key, operator2);
+    });
+  }
+  let operator;
+  if (mergedOperators.has(tokens[cursor].value)) {
+    operator = tokens[cursor].value;
+    cursor += 1;
+    if (cursor >= count) {
+      return [false];
+    }
+  } else {
+    return [false];
+  }
+  if (tokens[cursor].value !== "[") {
+    throw new ExpressionSyntaxError("Logic Operators require atleast one argument", tokens[cursor].position);
+  }
+  const argsStart = tokens[cursor].position;
+  cursor += 1;
+  const consumeWS = (notEnd) => {
+    const [tokenized, tCursor, ws] = tokenize_default3(tokens, cursor);
+    if (tokenized) {
+      cursor = tCursor;
+    }
+    if (notEnd && cursor >= count) {
+      throw new ExpressionSyntaxError("unexpected end of expression");
+    }
+    return ws;
+  };
+  consumeWS(true);
+  const args = [];
+  while (cursor < count) {
+    consumeWS();
+    if (cursor >= count) {
+      break;
+    }
+    let [tokenize3, tCursor, tResult] = tokenizeLogicOperator(tokens, cursor, options);
+    if (!tokenize3) {
+      [tokenize3, tCursor, tResult] = tokenize_default6(tokens, cursor, options);
+    }
+    if (!tokenize3) {
+      throw new ExpressionArgumentsError("conditional expected", tokens[cursor].position, args.length);
+    }
+    args.push(tResult);
+    cursor = tCursor;
+    if (tokens[cursor].value === ",") {
+      cursor += 1;
+      continue;
+    }
+    if (tokens[cursor].value === "]") {
+      const opDef = operators_default2.get(operator);
+      if (opDef.minArgumentsCount != null && args.length < opDef.minArgumentsCount) {
+        throw new ExpressionArgumentsError(`$${operator} expects atleast ${opDef.minArgumentsCount} argument(s)`);
+      }
+      if (opDef.maxArgumentsCount != null && args.length > opDef.maxArgumentsCount) {
+        throw new ExpressionArgumentsError(`$${operator} expects at most ${opDef.maxArgumentsCount} argument(s)`);
+      }
+      return [
+        true,
+        cursor + 1,
+        new LogicToken({
+          position: start,
+          value: operator,
+          arguments: new ArgumentsToken({
+            position: argsStart,
+            value: args
+          })
+        })
+      ];
+    }
+    throw new ExpressionSyntaxError("unexpected token", tokens[cursor].position);
+  }
+  throw new ExpressionSyntaxError("unexpected end of expression", count);
+};
+var tokenize_default7 = tokenizeLogicOperator;
+
+// src/parse/if/tokenize.ts
+var tokenize_default4 = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value !== "$" || tokens[cursor + 1].value !== "if") {
+    return [false];
+  }
+  const start = tokens[cursor].position;
+  cursor += 2;
+  if (cursor >= count) {
+    throw new ExpressionArgumentsError("$if requires atleast 2 arguments", start, 0, "if");
+  }
+  if (tokens[cursor].value !== "[") {
+    throw new ExpressionArgumentsError("$if requires atleast 2 arguments", tokens[cursor].position, 0, "if");
+  }
+  cursor += 1;
+  const consumeWS = (notEnd) => {
+    const [tokenized, tCursor2, ws] = tokenize_default3(tokens, cursor);
+    if (tokenized) {
+      cursor = tCursor2;
+    }
+    if (notEnd && cursor >= count) {
+      throw new ExpressionSyntaxError("unexpected end of expression");
+    }
+    return ws;
+  };
+  consumeWS(true);
+  let [tokenize3, tCursor, tResult] = tokenize_default7(tokens, cursor, options);
+  if (!tokenize3) {
+    [tokenize3, tCursor, tResult] = tokenize_default6(tokens, cursor, options);
+    if (!tokenize3) {
+      throw new ExpressionArgumentsError("$if requires the first argument to be a conditional", tokens[cursor].position, 0, "if");
+    }
+  }
+  const condition = tResult;
+  cursor = tCursor;
+  if (cursor >= count) {
+    throw new ExpressionSyntaxError("unexpected end of expression");
+  }
+  if (tokens[cursor].value === "]") {
+    throw new ExpressionArgumentsError("$if requires atleast 2 arguments", tokens[cursor].position, 2, "if");
+  }
+  if (tokens[cursor].value !== ",") {
+    throw new ExpressionSyntaxError("expected end of conditional", tokens[cursor].position);
+  }
+  cursor += 1;
+  consumeWS(true);
+  if (cursor >= count) {
+    throw new ExpressionSyntaxError("unexpected end of expression");
+  }
+  const [wtTokenize, wtCursor, whenTrue] = argument_default(tokens, cursor, options);
+  if (!wtTokenize) {
+    throw new ExpressionArgumentsError("$if must have atleast a condition and 1 parameter", tokens[cursor].position, 1, "if");
+  } else {
+    cursor = wtCursor;
+    if (cursor >= count) {
+      throw new ExpressionSyntaxError("unexpected end of expression");
+    }
+  }
+  let wfTokenize, wfCursor, whenFalse;
+  if (tokens[cursor].value === ",") {
+    cursor += 1;
+    consumeWS(true);
+    if (tokens[cursor].value !== "]") {
+      [wfTokenize, wfCursor, whenFalse] = argument_default(tokens, cursor, options);
+      if (!wfTokenize) {
+        throw new ExpressionSyntaxError("expected 3rd parameter");
+      }
+      cursor = wfCursor;
+      if (cursor >= count) {
+        throw new ExpressionSyntaxError("unexpected end of expression");
+      }
+    }
+  }
+  if (tokens[cursor].value !== "]") {
+    throw new ExpressionSyntaxError("expected end of arguments list", tokens[cursor].position);
+  }
+  return [
+    true,
+    cursor + 1,
+    new IfToken({
+      position: start,
+      value: condition,
+      whenTrue,
+      whenFalse
+    })
+  ];
+};
+
+// src/parse/arguments/argument.ts
+var argument_default = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor >= count) {
+    return [false];
+  }
+  const start = tokens[cursor].position;
+  const consumeWS = (notEnd) => {
+    const [tokenized, tCursor, ws] = tokenize_default3(tokens, cursor);
+    if (tokenized) {
+      cursor = tCursor;
+    }
+    if (notEnd && cursor >= count) {
+      throw new ExpressionSyntaxError("unexpected end of expression");
+    }
+    return ws || "";
+  };
+  consumeWS();
+  if (cursor >= count) {
+    return [false];
+  }
+  const parts = new SequenceToken({ position: start });
+  while (cursor < count) {
+    const position = tokens[cursor].position;
+    const whitespace = consumeWS();
+    if (cursor >= count) {
+      break;
+    }
+    if (tokens[cursor].value === "]" || tokens[cursor].value === ",") {
+      return [true, cursor, parts.unwrap];
+    }
+    if (whitespace !== "") {
+      parts.add(new TextToken({ position, value: whitespace }));
+    }
+    const [eTokenized, eCursor, eResult] = escape_default(tokens, cursor, '"$,\\`]');
+    if (eTokenized) {
+      parts.add(new TextToken({ position, value: eResult.value }));
+      cursor = eCursor;
+    }
+    let [tokenized, tCursor, tResult] = block_default(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = quote_default(tokens, cursor);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default5(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default4(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default2(tokens, cursor, options);
+    if (tokenized) {
+      parts.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    parts.add(new TextToken(tokens[cursor]));
+    cursor += 1;
+  }
+  throw new ExpressionSyntaxError("unexpected end of arguments list");
+};
+
+// src/parse/arguments/tokenize.ts
+var tokenize_default = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor >= count || tokens[cursor].value !== "[") {
+    return [false];
+  }
+  const start = tokens[cursor].position;
+  cursor += 1;
+  const consumeWS = () => {
+    const [wsRem, wsCursor, wsResult] = tokenize_default3(tokens, cursor);
+    if (wsRem) {
+      cursor = wsCursor;
+      return wsResult;
+    }
+    return "";
+  };
+  consumeWS();
+  const args = [];
+  while (cursor < count) {
+    consumeWS();
+    if (cursor >= count) {
+      break;
+    }
+    const [aTokenized, aCursor, aResult] = argument_default(tokens, cursor, options);
+    if (!aTokenized) {
+      throw new ExpressionSyntaxError("encountered missing or invalid argument", tokens[cursor].position);
+    }
+    cursor = aCursor;
+    args.push(aResult);
+    if (cursor >= count) {
+      break;
+    }
+    if (tokens[cursor].value === "]") {
+      return [
+        true,
+        cursor + 1,
+        new ArgumentsToken({
+          position: start,
+          value: args
+        })
+      ];
+    }
+    if (tokens[cursor].value !== ",") {
+      throw new ExpressionSyntaxError("expected end of argument", tokens[cursor].position);
+    }
+    cursor += 1;
+  }
+  if (cursor >= count) {
+    throw new ExpressionSyntaxError("unexpected end of expression");
+  }
+  throw new ExpressionSyntaxError("unexpected end of arguments list", tokens[cursor].position);
+};
+
+// src/parse/lookup/tokenize.ts
+var tokenize_default5 = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value !== "$") {
+    return [false];
+  }
+  const start = tokens[cursor].position;
+  cursor += 1;
+  let prefixAccumulator = "";
+  let prefix = "";
+  let tmpCursor = cursor;
+  while (tmpCursor < count) {
+    const val = tokens[tmpCursor].value;
+    if (!/[\x21-\x47\x3A-\x40\x5B\x5D-\x60\x7B-\x7E]/.test(val)) {
+      break;
+    }
+    prefixAccumulator += val;
+    tmpCursor += 1;
+    if (options.lookups.has(prefixAccumulator)) {
+      prefix = prefixAccumulator;
+      cursor = tmpCursor;
+    }
+  }
+  if (cursor >= count || !prefix) {
+    return [false];
+  }
+  let name = "";
+  if (!/^[a-z]/i.test(tokens[cursor].value)) {
+    return [false];
+  }
+  while (cursor < count && (/^[a-z\d]+$/i.test(tokens[cursor].value) || tokens[cursor].value === "_" || tokens[cursor].value === "-")) {
+    name += tokens[cursor].value;
+    cursor += 1;
+  }
+  if (!/^[a-z][a-z\d_-]+/i.test(name)) {
+    return [false];
+  }
+  let args;
+  const [tokenized, tokenizedCursor, tokenizedResult] = tokenize_default(tokens, cursor, options);
+  if (tokenized) {
+    cursor = tokenizedCursor;
+    args = tokenizedResult;
+  }
+  return [
+    true,
+    cursor,
+    new LookupToken({
+      position: start,
+      prefix,
+      value: name,
+      arguments: args
+    })
+  ];
+};
+
+// src/parse/text/block.ts
+var block_default = (tokens, cursor, options) => {
+  const count = tokens.length;
+  if (cursor + 1 >= count || tokens[cursor].value !== "``") {
+    return [false];
+  }
+  cursor += 1;
+  const result = new SequenceToken({ position: tokens[cursor].position });
+  while (cursor < count) {
+    if (tokens[cursor].value === "``") {
+      return [true, cursor + 1, result.unwrap];
+    }
+    let [tokenized, tCursor, tResult] = tokenize_default5(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default4(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default2(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    result.add(new TextToken(tokens[cursor]));
+    cursor += 1;
+  }
+  return [false];
+};
+
+// src/parse/root/tokenize.ts
+var tokenize_default8 = (options) => {
+  const result = new RootToken(options);
+  const tokens = tokenize(options.expression);
+  const count = tokens.length;
+  let cursor = 0;
+  while (cursor < count) {
+    const [eTokenized, eCursor, eResult] = escape_default(tokens, cursor);
+    if (eTokenized) {
+      result.add(new TextToken(eResult));
+      cursor = eCursor;
+      continue;
+    }
+    let [tokenized, tCursor, tResult] = block_default(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default5(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default4(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    [tokenized, tCursor, tResult] = tokenize_default2(tokens, cursor, options);
+    if (tokenized) {
+      result.add(tResult);
+      cursor = tCursor;
+      continue;
+    }
+    result.add(new TextToken(tokens[cursor]));
+    cursor += 1;
+  }
+  return result;
+};
+
+// src/expressionish.ts
+var tokenize2 = (options) => {
+  if (options == null) {
+    throw new TypeError("options not specified");
+  }
+  if (options.variables == null) {
+    throw new TypeError("variables map is null");
+  }
+  if (!(options.variables instanceof Map)) {
+    throw new TypeError("variables map is not a Map instance");
+  }
+  if (options.lookups == null) {
+    options.lookups = /* @__PURE__ */ new Map();
+  } else if (!(options.lookups instanceof Map)) {
+    throw new TypeError("lookups option specified but is not a Map instance");
+  }
+  if (options.logicalOperators == null) {
+    options.logicalOperators = /* @__PURE__ */ new Map();
+  } else if (!(options.logicalOperators instanceof Map)) {
+    throw new TypeError("logical operators options specified but is not a Map instance");
+  }
+  if (options.comparisonOperators == null) {
+    options.comparisonOperators = /* @__PURE__ */ new Map();
+  } else if (!(options.comparisonOperators instanceof Map)) {
+    throw new TypeError("comparison operators options specified but is not a Map instance");
+  }
+  if (options.expression == null) {
+    throw new TypeError("expression not specified");
+  }
+  if (typeof options.expression !== "string") {
+    throw new TypeError("expression must be a string");
+  }
+  return tokenize_default8(options);
+};
+var evaluate = async (options) => tokenize2(options).evaluate({
+  onlyValidate: options.onlyValidate,
+  preeval: options.preeval,
+  data: options.data
+});
+export {
+  ArgumentsToken,
+  BaseToken,
+  ComparisonToken,
+  ExpressionArgumentsError,
+  ExpressionError,
+  ExpressionSyntaxError,
+  ExpressionVariableError,
+  IfToken,
+  LogicToken,
+  LookupToken,
+  RootToken,
+  SequenceToken,
+  TextToken,
+  VariableToken,
+  evaluate,
+  tokenize2 as tokenize
+};
+/*!
+The MIT License (MIT) @ Copyright (c) 2016 Justin Sippel, Vitaly Domnikov
+https://github.com/bluelovers/runes/blob/8013b6e4021a41d6b579d76b3332c87389c5f092/LICENSE
+*/
+//# sourceMappingURL=expressionish.mjs.map