@andrew_l/search-query-language 0.3.22 → 0.4.1

package/dist/index.mjs

@@ -1,713 +1,510 @@
-import { assert, isFunction, arrayable, isNumber, withCache, isString } from '@andrew_l/toolkit';
-import mongoose, { isObjectIdOrHexString } from 'mongoose';
-
-class TokenType {
-  label;
-  keyword;
-  constructor(label, options) {
-    this.label = label;
-    this.keyword = options?.keyword;
-  }
-}
-
+import { arrayable, assert, isFunction, isNumber, isString, withCache } from "@andrew_l/toolkit";
+import mongoose, { isObjectIdOrHexString } from "mongoose";
+var TokenType = class {
+	label;
+	keyword;
+	constructor(label, options) {
+		this.label = label;
+		this.keyword = options?.keyword;
+	}
+};
 const NODE = Object.freeze({
-  PROGRAM: "program",
-  IDENTIFIER: "identifier",
-  LITERAL: "literal",
-  LOGICAL_EXPRESSION: "logical-expression",
-  BINARY_EXPRESSION: "binary-expression"
+	PROGRAM: "program",
+	IDENTIFIER: "identifier",
+	LITERAL: "literal",
+	LOGICAL_EXPRESSION: "logical-expression",
+	BINARY_EXPRESSION: "binary-expression"
 });
 const KEYWORDS = {};
 const TOKEN = Object.freeze({
-  /**
-   * Start of File token.
-   */
-  SOF: new TokenType("sof"),
-  /**
-   * End of File token.
-   */
-  EOF: new TokenType("eof"),
-  /**
-   * Number token.
-   */
-  NUM: new TokenType("num"),
-  /**
-   * String token.
-   */
-  STRING: new TokenType("string"),
-  /**
-   * Identifier token.
-   */
-  NAME: new TokenType("identifier"),
-  /**
-   * Parenthesis token.
-   */
-  PAREN_L: new TokenType("("),
-  /**
-   * Parenthesis token.
-   */
-  PAREN_R: new TokenType(")"),
-  /**
-   * Logical operator token.
-   */
-  LOGICAL_OR: kw("OR"),
-  /**
-   * Logical operator token.
-   */
-  LOGICAL_AND: kw("AND"),
-  /**
-   * Equality operator token.
-   */
-  EQUALITY: new TokenType("=/!="),
-  /**
-   * Relational operator token.
-   */
-  RELATIONAL: new TokenType("</>/<=/>="),
-  /**
-   * Minus operator token.
-   */
-  MINUS: new TokenType("-"),
-  /**
-   * Null literal token.
-   */
-  NULL: kw("null"),
-  /**
-   * True literal tokens.
-   */
-  TRUE: kw("true"),
-  /**
-   * False literal tokens.
-   */
-  FALSE: kw("false")
+	SOF: new TokenType("sof"),
+	EOF: new TokenType("eof"),
+	NUM: new TokenType("num"),
+	STRING: new TokenType("string"),
+	NAME: new TokenType("identifier"),
+	PAREN_L: new TokenType("("),
+	PAREN_R: new TokenType(")"),
+	LOGICAL_OR: kw("OR"),
+	LOGICAL_AND: kw("AND"),
+	EQUALITY: new TokenType("=/!="),
+	RELATIONAL: new TokenType("</>/<=/>="),
+	MINUS: new TokenType("-"),
+	NULL: kw("null"),
+	TRUE: kw("true"),
+	FALSE: kw("false")
 });
 function kw(name, options = {}) {
-  options.keyword = name;
-  return KEYWORDS[name] = new TokenType(name, options);
-}
-
-class Token {
-  type;
-  value;
-  start;
-  end;
-  constructor(p) {
-    this.type = p.type;
-    this.value = p.value;
-    this.start = p.start;
-    this.end = p.end;
-  }
-}
-
-class Tokenizer {
-  input;
-  pos;
-  length;
-  state;
-  prev;
-  constructor(input) {
-    this.input = input;
-    this.length = input.length;
-    this.pos = 0;
-    this.state = {
-      start: 0,
-      end: 0,
-      type: TOKEN.SOF,
-      value: null
-    };
-    this.prev = { ...this.state };
-  }
-  [Symbol.iterator]() {
-    return {
-      next: () => {
-        let token = this.getToken();
-        return {
-          done: token.type === TOKEN.EOF,
-          value: token
-        };
-      }
-    };
-  }
-  /**
-   * Get the next token.
-   */
-  getToken() {
-    this.nextToken();
-    const token = new Token(this.state);
-    return token;
-  }
-  nextToken() {
-    this.skipSpace();
-    this.state.start = this.pos;
-    if (this.pos >= this.length) return this.finishToken(TOKEN.EOF);
-    this.readToken(this.charCodeAtPos());
-  }
-  skipSpace() {
-    let ch;
-    while (this.pos < this.length) {
-      ch = this.charCodeAtPos();
-      if (ch === 32 || ch === 160) {
-        this.pos++;
-      } else {
-        break;
-      }
-    }
-  }
-  finishToken(type, value) {
-    Object.assign(this.prev, this.state);
-    this.state.end = this.pos;
-    this.state.type = type;
-    this.state.value = value;
-  }
-  finishOp(type, size) {
-    let str = this.input.slice(this.pos, this.pos + size);
-    this.pos += size;
-    return this.finishToken(type, str);
-  }
-  readToken(code) {
-    if (isIdentifierStart(code)) {
-      return this.readWord();
-    }
-    return this.getTokenFromCode(code);
-  }
-  getTokenFromCode(code) {
-    switch (code) {
-      case 40:
-        ++this.pos;
-        return this.finishToken(TOKEN.PAREN_L);
-      case 41:
-        ++this.pos;
-        return this.finishToken(TOKEN.PAREN_R);
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        return this.readNumber();
-      case 45:
-        ++this.pos;
-        return this.finishToken(TOKEN.MINUS);
-      case 61:
-      case 33:
-        return this.readEquality(code);
-      case 60:
-      case 62:
-        return this.readLtGt();
-      case 34:
-        return this.readString();
-    }
-    this.raise(
-      this.pos,
-      "Unexpected character '" + String.fromCharCode(code) + "'"
-    );
-  }
-  charCodeAtPos() {
-    return this.input.charCodeAt(this.pos);
-  }
-  readEquality(code) {
-    let next = this.input.charCodeAt(this.pos + 1);
-    if (code === 33) {
-      if (next === 61) return this.finishOp(TOKEN.EQUALITY, 2);
-    } else {
-      return this.finishOp(TOKEN.EQUALITY, 1);
-    }
-  }
-  readLtGt() {
-    let next = this.input.charCodeAt(this.pos + 1);
-    let size = 1;
-    if (next === 61) size = 2;
-    return this.finishOp(TOKEN.RELATIONAL, size);
-  }
-  readInt() {
-    const radix = 10;
-    let start = this.pos;
-    let code = 0;
-    let total = 0;
-    for (; ; ) {
-      code = this.input.charCodeAt(this.pos);
-      if (code >= 48 && code <= 57) {
-        total = total * radix + (code - 48);
-        this.pos++;
-      } else {
-        break;
-      }
-    }
-    if (this.pos === start) return null;
-    return total;
-  }
-  raise(pos, message) {
-    throw new SyntaxError(`${message} (${pos})`);
-  }
-  readString() {
-    let out = "";
-    let chunkStart = ++this.pos;
-    let ch;
-    for (; ; ) {
-      if (this.pos >= this.length) {
-        this.raise(this.state.start, "Unterminated string constant");
-      }
-      ch = this.input.charCodeAt(this.pos);
-      if (ch === 34) break;
-      if (ch === 92) {
-        out += this.input.slice(chunkStart, this.pos);
-        out += this.readEscapedChar();
-        chunkStart = this.pos;
-      }
-      ++this.pos;
-    }
-    out += this.input.slice(chunkStart, this.pos++);
-    return this.finishToken(TOKEN.STRING, out);
-  }
-  readWord() {
-    let chunkStart = this.pos;
-    let ch;
-    let cmp = isIdentifierStart;
-    while (this.pos < this.input.length) {
-      ch = this.charCodeAtPos();
-      if (!cmp(ch)) break;
-      cmp = isIdentifierChar;
-      this.pos++;
-    }
-    const word = this.input.slice(chunkStart, this.pos);
-    let type = TOKEN.NAME;
-    if (word in KEYWORDS) {
-      type = KEYWORDS[word];
-    }
-    return this.finishToken(type, word);
-  }
-  readEscapedChar() {
-    let ch = this.input.charCodeAt(++this.pos);
-    ++this.pos;
-    return String.fromCharCode(ch);
-  }
-  readNumber() {
-    let start = this.pos;
-    if (this.readInt() === null) this.raise(start, "Invalid number");
-    let next = this.input.charCodeAt(this.pos);
-    if (next === 46) {
-      ++this.pos;
-      this.readInt();
-      next = this.input.charCodeAt(this.pos);
-    }
-    let val = Number(this.input.slice(start, this.pos));
-    return this.finishToken(TOKEN.NUM, val);
-  }
+	options.keyword = name;
+	return KEYWORDS[name] = new TokenType(name, options);
 }
+var Token = class {
+	type;
+	value;
+	start;
+	end;
+	constructor(p) {
+		this.type = p.type;
+		this.value = p.value;
+		this.start = p.start;
+		this.end = p.end;
+	}
+};
+var Tokenizer = class {
+	input;
+	pos;
+	length;
+	state;
+	prev;
+	constructor(input) {
+		this.input = input;
+		this.length = input.length;
+		this.pos = 0;
+		this.state = {
+			start: 0,
+			end: 0,
+			type: TOKEN.SOF,
+			value: null
+		};
+		this.prev = { ...this.state };
+	}
+	[Symbol.iterator]() {
+		return { next: () => {
+			let token = this.getToken();
+			return {
+				done: token.type === TOKEN.EOF,
+				value: token
+			};
+		} };
+	}
+	getToken() {
+		this.nextToken();
+		return new Token(this.state);
+	}
+	nextToken() {
+		this.skipSpace();
+		this.state.start = this.pos;
+		if (this.pos >= this.length) return this.finishToken(TOKEN.EOF);
+		this.readToken(this.charCodeAtPos());
+	}
+	skipSpace() {
+		let ch;
+		while (this.pos < this.length) {
+			ch = this.charCodeAtPos();
+			if (ch === 32 || ch === 160) this.pos++;
+			else break;
+		}
+	}
+	finishToken(type, value) {
+		Object.assign(this.prev, this.state);
+		this.state.end = this.pos;
+		this.state.type = type;
+		this.state.value = value;
+	}
+	finishOp(type, size) {
+		let str = this.input.slice(this.pos, this.pos + size);
+		this.pos += size;
+		return this.finishToken(type, str);
+	}
+	readToken(code) {
+		if (isIdentifierStart(code)) return this.readWord();
+		return this.getTokenFromCode(code);
+	}
+	getTokenFromCode(code) {
+		switch (code) {
+			case 40:
+				++this.pos;
+				return this.finishToken(TOKEN.PAREN_L);
+			case 41:
+				++this.pos;
+				return this.finishToken(TOKEN.PAREN_R);
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57: return this.readNumber();
+			case 45:
+				++this.pos;
+				return this.finishToken(TOKEN.MINUS);
+			case 61:
+			case 33: return this.readEquality(code);
+			case 60:
+			case 62: return this.readLtGt();
+			case 34: return this.readString();
+		}
+		this.raise(this.pos, "Unexpected character '" + String.fromCharCode(code) + "'");
+	}
+	charCodeAtPos() {
+		return this.input.charCodeAt(this.pos);
+	}
+	readEquality(code) {
+		let next = this.input.charCodeAt(this.pos + 1);
+		if (code === 33) {
+			if (next === 61) return this.finishOp(TOKEN.EQUALITY, 2);
+		} else return this.finishOp(TOKEN.EQUALITY, 1);
+	}
+	readLtGt() {
+		let next = this.input.charCodeAt(this.pos + 1);
+		let size = 1;
+		if (next === 61) size = 2;
+		return this.finishOp(TOKEN.RELATIONAL, size);
+	}
+	readInt() {
+		const radix = 10;
+		let start = this.pos;
+		let code = 0;
+		let total = 0;
+		for (;;) {
+			code = this.input.charCodeAt(this.pos);
+			if (code >= 48 && code <= 57) {
+				total = total * radix + (code - 48);
+				this.pos++;
+			} else break;
+		}
+		if (this.pos === start) return null;
+		return total;
+	}
+	raise(pos, message) {
+		throw new SyntaxError(`${message} (${pos})`);
+	}
+	readString() {
+		let out = "";
+		let chunkStart = ++this.pos;
+		let ch;
+		for (;;) {
+			if (this.pos >= this.length) this.raise(this.state.start, "Unterminated string constant");
+			ch = this.input.charCodeAt(this.pos);
+			if (ch === 34) break;
+			if (ch === 92) {
+				out += this.input.slice(chunkStart, this.pos);
+				out += this.readEscapedChar();
+				chunkStart = this.pos;
+			}
+			++this.pos;
+		}
+		out += this.input.slice(chunkStart, this.pos++);
+		return this.finishToken(TOKEN.STRING, out);
+	}
+	readWord() {
+		let chunkStart = this.pos;
+		let ch;
+		let cmp = isIdentifierStart;
+		while (this.pos < this.input.length) {
+			ch = this.charCodeAtPos();
+			if (!cmp(ch)) break;
+			cmp = isIdentifierChar;
+			this.pos++;
+		}
+		const word = this.input.slice(chunkStart, this.pos);
+		let type = TOKEN.NAME;
+		if (word in KEYWORDS) type = KEYWORDS[word];
+		return this.finishToken(type, word);
+	}
+	readEscapedChar() {
+		let ch = this.input.charCodeAt(++this.pos);
+		++this.pos;
+		return String.fromCharCode(ch);
+	}
+	readNumber() {
+		let start = this.pos;
+		if (this.readInt() === null) this.raise(start, "Invalid number");
+		let next = this.input.charCodeAt(this.pos);
+		if (next === 46) {
+			++this.pos;
+			this.readInt();
+			next = this.input.charCodeAt(this.pos);
+		}
+		let val = Number(this.input.slice(start, this.pos));
+		return this.finishToken(TOKEN.NUM, val);
+	}
+};
 function isIdentifierStart(code) {
-  if (code < 65) return false;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  return false;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123) return true;
+	return false;
 }
 function isIdentifierChar(code) {
-  if (code < 48) return code === 46;
-  if (code < 58) return true;
-  if (code < 65) return false;
-  if (code < 91) return true;
-  if (code < 97) return code === 95;
-  if (code < 123) return true;
-  return false;
-}
-
-class Expression extends Tokenizer {
-  constructor(input) {
-    super(input);
-  }
-  /**
-   * Parse input into a program AST.
-   */
-  parse() {
-    let node = this.startNode(NODE.PROGRAM);
-    node.body = [];
-    this.nextToken();
-    return this.parseTopLevel(node);
-  }
-  finishNode(node) {
-    node.end = this.state.start;
-    return node;
-  }
-  parseTopLevel(node) {
-    while (this.state.type !== TOKEN.EOF) {
-      let stmt = this.parseExpression();
-      node.body.push(stmt);
-    }
-    this.nextToken();
-    return this.finishNode(node);
-  }
-  parseExpression() {
-    let left;
-    if (this.state.type === TOKEN.PAREN_L) {
-      this.nextToken();
-      left = this.parseExpression();
-      if (this.state.type !== TOKEN.PAREN_R) {
-        this.raise(this.pos, "Expected closing paren.");
-      }
-      this.nextToken();
-      if (this.state.type === TOKEN.EOF) {
-        return left;
-      }
-    } else {
-      left = this.parseExprAtom();
-    }
-    let node;
-    for (; ; ) {
-      node = this.parseExprOp(left);
-      node.start = left.start;
-      left = node;
-      if (this.state.type === TOKEN.EOF || this.state.type === TOKEN.PAREN_R)
-        break;
-    }
-    return node;
-  }
-  parseExprOp(left) {
-    const node = this.startNode(NODE.BINARY_EXPRESSION);
-    node.operator = this.state.value;
-    node.left = left;
-    switch (this.state.type) {
-      case TOKEN.LOGICAL_AND:
-      case TOKEN.LOGICAL_OR: {
-        if (!isNodeExpression(node.left)) {
-          this.raise(
-            node.left.start,
-            "Expected expression as left side of logical expression."
-          );
-        }
-        this.nextToken();
-        node.right = this.maybeLiteral() || this.parseExpression();
-        node.type = NODE.LOGICAL_EXPRESSION;
-        if (!isNodeExpression(node.right)) {
-          this.raise(
-            node.right.start,
-            `Unexpected ${node.right.type} as right side of logical expression.`
-          );
-        }
-        break;
-      }
-      case TOKEN.EQUALITY:
-      case TOKEN.RELATIONAL: {
-        this.nextToken();
-        if (node.left.type !== NODE.IDENTIFIER) {
-          this.raise(
-            node.start,
-            `Expected identifier as left side of binary expression.`
-          );
-        }
-        node.right = this.parseExprAtom();
-        if (node.right.type !== NODE.LITERAL) {
-          this.raise(
-            node.right.start,
-            "Expected literal as right side of binary expression."
-          );
-        }
-        break;
-      }
-      default: {
-        if (this.state.type === TOKEN.EOF) {
-          this.raise(
-            this.pos,
-            `Expected operator after ${this.prev.type.label}`
-          );
-        } else {
-          this.raise(this.pos, `Unexpected operator: ${this.state.type.label}`);
-        }
-      }
-    }
-    return this.finishNode(node);
-  }
-  maybeLiteral() {
-    switch (this.state.type) {
-      case TOKEN.MINUS: {
-        const start = this.state.start;
-        this.nextToken();
-        if (this.state.type !== TOKEN.NUM) {
-          this.raise(this.pos, `Expected number after minus operator`);
-        }
-        const node = this.maybeLiteral();
-        node.start = start;
-        node.raw = `-${node.raw}`;
-        node.value = node.value * -1;
-        return node;
-      }
-      case TOKEN.NUM:
-      case TOKEN.STRING: {
-        let node = this.startNode(NODE.LITERAL);
-        node.raw = this.input.slice(this.state.start, this.state.end);
-        node.value = this.state.value;
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      case TOKEN.NULL:
-      case TOKEN.TRUE:
-      case TOKEN.FALSE: {
-        let node = this.startNode(NODE.LITERAL);
-        node.raw = this.state.type.keyword;
-        node.value = this.state.type === TOKEN.NULL ? null : this.state.type === TOKEN.TRUE;
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      default: {
-        return null;
-      }
-    }
-  }
-  maybeIdentifier() {
-    switch (this.state.type) {
-      case TOKEN.NAME: {
-        let node = this.startNode(NODE.IDENTIFIER);
-        node.name = String(this.state.value);
-        this.nextToken();
-        return this.finishNode(node);
-      }
-      default:
-        return null;
-    }
-  }
-  parseExprAtom() {
-    const node = this.maybeIdentifier() || this.maybeLiteral();
-    if (!node) {
-      this.raise(this.pos, `Unexpected token ${this.state.type.label}.`);
-    }
-    return node;
-  }
-  startNode(type) {
-    const node = { type, start: this.state.start, end: 0 };
-    return node;
-  }
+	if (code < 48) return code === 46;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123) return true;
+	return false;
 }
+var Expression = class extends Tokenizer {
+	constructor(input) {
+		super(input);
+	}
+	parse() {
+		let node = this.startNode(NODE.PROGRAM);
+		node.body = [];
+		this.nextToken();
+		return this.parseTopLevel(node);
+	}
+	finishNode(node) {
+		node.end = this.state.start;
+		return node;
+	}
+	parseTopLevel(node) {
+		while (this.state.type !== TOKEN.EOF) {
+			let stmt = this.parseExpression();
+			node.body.push(stmt);
+		}
+		this.nextToken();
+		return this.finishNode(node);
+	}
+	parseExpression() {
+		let left;
+		if (this.state.type === TOKEN.PAREN_L) {
+			this.nextToken();
+			left = this.parseExpression();
+			if (this.state.type !== TOKEN.PAREN_R) this.raise(this.pos, "Expected closing paren.");
+			this.nextToken();
+			if (this.state.type === TOKEN.EOF) return left;
+		} else left = this.parseExprAtom();
+		let node;
+		for (;;) {
+			node = this.parseExprOp(left);
+			node.start = left.start;
+			left = node;
+			if (this.state.type === TOKEN.EOF || this.state.type === TOKEN.PAREN_R) break;
+		}
+		return node;
+	}
+	parseExprOp(left) {
+		const node = this.startNode(NODE.BINARY_EXPRESSION);
+		node.operator = this.state.value;
+		node.left = left;
+		switch (this.state.type) {
+			case TOKEN.LOGICAL_AND:
+			case TOKEN.LOGICAL_OR:
+				if (!isNodeExpression(node.left)) this.raise(node.left.start, "Expected expression as left side of logical expression.");
+				this.nextToken();
+				node.right = this.maybeLiteral() || this.parseExpression();
+				node.type = NODE.LOGICAL_EXPRESSION;
+				if (!isNodeExpression(node.right)) this.raise(node.right.start, `Unexpected ${node.right.type} as right side of logical expression.`);
+				break;
+			case TOKEN.EQUALITY:
+			case TOKEN.RELATIONAL:
+				this.nextToken();
+				if (node.left.type !== NODE.IDENTIFIER) this.raise(node.start, `Expected identifier as left side of binary expression.`);
+				node.right = this.parseExprAtom();
+				if (node.right.type !== NODE.LITERAL) this.raise(node.right.start, "Expected literal as right side of binary expression.");
+				break;
+			default: if (this.state.type === TOKEN.EOF) this.raise(this.pos, `Expected operator after ${this.prev.type.label}`);
+			else this.raise(this.pos, `Unexpected operator: ${this.state.type.label}`);
+		}
+		return this.finishNode(node);
+	}
+	maybeLiteral() {
+		switch (this.state.type) {
+			case TOKEN.MINUS: {
+				const start = this.state.start;
+				this.nextToken();
+				if (this.state.type !== TOKEN.NUM) this.raise(this.pos, `Expected number after minus operator`);
+				const node = this.maybeLiteral();
+				node.start = start;
+				node.raw = `-${node.raw}`;
+				node.value = node.value * -1;
+				return node;
+			}
+			case TOKEN.NUM:
+			case TOKEN.STRING: {
+				let node = this.startNode(NODE.LITERAL);
+				node.raw = this.input.slice(this.state.start, this.state.end);
+				node.value = this.state.value;
+				this.nextToken();
+				return this.finishNode(node);
+			}
+			case TOKEN.NULL:
+			case TOKEN.TRUE:
+			case TOKEN.FALSE: {
+				let node = this.startNode(NODE.LITERAL);
+				node.raw = this.state.type.keyword;
+				node.value = this.state.type === TOKEN.NULL ? null : this.state.type === TOKEN.TRUE;
+				this.nextToken();
+				return this.finishNode(node);
+			}
+			default: return null;
+		}
+	}
+	maybeIdentifier() {
+		switch (this.state.type) {
+			case TOKEN.NAME: {
+				let node = this.startNode(NODE.IDENTIFIER);
+				node.name = String(this.state.value);
+				this.nextToken();
+				return this.finishNode(node);
+			}
+			default: return null;
+		}
+	}
+	parseExprAtom() {
+		const node = this.maybeIdentifier() || this.maybeLiteral();
+		if (!node) this.raise(this.pos, `Unexpected token ${this.state.type.label}.`);
+		return node;
+	}
+	startNode(type) {
+		return {
+			type,
+			start: this.state.start,
+			end: 0
+		};
+	}
+};
 function isNodeExpression(node) {
-  return node.type === NODE.BINARY_EXPRESSION || node.type === NODE.LOGICAL_EXPRESSION;
+	return node.type === NODE.BINARY_EXPRESSION || node.type === NODE.LOGICAL_EXPRESSION;
 }
-
 function parseQuery(value) {
-  return new Expression(value).parse();
+	return new Expression(value).parse();
 }
-
 const OPERATOR_MAP = {
-  "=": "$eq",
-  "!=": "$ne",
-  ">": "$gt",
-  ">=": "$gte",
-  "<": "$lt",
-  "<=": "$lte"
+	"=": "$eq",
+	"!=": "$ne",
+	">": "$gt",
+	">=": "$gte",
+	"<": "$lt",
+	"<=": "$lte"
 };
 const NOOP_TRANSFORM = [];
 function parseToMongo(input, options = {}) {
-  const opts = mergeOptions(options);
-  if (input.trim() === "") {
-    assert.ok(opts.allowEmpty, "Search query cannot be empty.");
-    return {};
-  }
-  const result = {};
-  const ops = new OpsResource(opts.maxOps);
-  const exp = new Expression(input).parse();
-  for (const node of exp.body) {
-    Object.assign(result, reduceNode(node, opts, ops));
-  }
-  return result;
+	const opts = mergeOptions(options);
+	if (input.trim() === "") {
+		assert.ok(opts.allowEmpty, "Search query cannot be empty.");
+		return {};
+	}
+	const result = {};
+	const ops = new OpsResource(opts.maxOps);
+	const exp = new Expression(input).parse();
+	for (const node of exp.body) Object.assign(result, reduceNode(node, opts, ops));
+	return result;
 }
 function reduceNode(node, options, opsResource) {
-  switch (node.type) {
-    case NODE.BINARY_EXPRESSION: {
-      opsResource.assert();
-      assert.ok(
-        !options.allowedKeys || options.allowedKeys.has(node.left.name),
-        `The search key "${node.left.name}" is not allowed.`
-      );
-      const transform = options.transform?.[node.left.name] || options.transform?.["*"] || NOOP_TRANSFORM;
-      return {
-        [node.left.name]: node.operator === "=" ? callTransform(transform, node.right.value, node.left.name) : {
-          [OPERATOR_MAP[node.operator]]: callTransform(
-            transform,
-            node.right.value,
-            node.left.name
-          )
-        }
-      };
-    }
-    case NODE.LOGICAL_EXPRESSION: {
-      const op = node.operator === "AND" ? "$and" : "$or";
-      const right = reduceNode(node.right, options, opsResource);
-      if (node.right.type === NODE.LOGICAL_EXPRESSION && node.right.operator === node.operator) {
-        return {
-          [op]: [reduceNode(node.left, options, opsResource), ...right[op]]
-        };
-      }
-      return {
-        [op]: [reduceNode(node.left, options, opsResource), right]
-      };
-    }
-    default: {
-      assert.ok(false, `Unexpected ast node: ${node.type}`);
-    }
-  }
+	switch (node.type) {
+		case NODE.BINARY_EXPRESSION: {
+			opsResource.assert();
+			assert.ok(!options.allowedKeys || options.allowedKeys.has(node.left.name), `The search key "${node.left.name}" is not allowed.`);
+			const transform = options.transform?.[node.left.name] || options.transform?.["*"] || NOOP_TRANSFORM;
+			return { [node.left.name]: node.operator === "=" ? callTransform(transform, node.right.value, node.left.name) : { [OPERATOR_MAP[node.operator]]: callTransform(transform, node.right.value, node.left.name) } };
+		}
+		case NODE.LOGICAL_EXPRESSION: {
+			const op = node.operator === "AND" ? "$and" : "$or";
+			const right = reduceNode(node.right, options, opsResource);
+			if (node.right.type === NODE.LOGICAL_EXPRESSION && node.right.operator === node.operator) return { [op]: [reduceNode(node.left, options, opsResource), ...right[op]] };
+			return { [op]: [reduceNode(node.left, options, opsResource), right] };
+		}
+		default: assert.ok(false, `Unexpected ast node: ${node.type}`);
+	}
 }
 function mergeOptions(...options) {
-  const optsTransform = {};
-  const result = {
-    transform: optsTransform,
-    allowEmpty: false,
-    maxOps: Infinity
-  };
-  for (const { transform, allowedKeys, ...rest } of options) {
-    Object.assign(result, rest);
-    if (allowedKeys?.length) {
-      result.allowedKeys = new Set(allowedKeys);
-    }
-    if (Array.isArray(transform) || isFunction(transform)) {
-      optsTransform["*"] = optsTransform["*"] || [];
-      optsTransform["*"].push(...arrayable(transform));
-    } else if (transform) {
-      for (const [key, value] of Object.entries(transform)) {
-        optsTransform[key] = optsTransform[key] || [];
-        optsTransform[key].push(...arrayable(value));
-      }
-    }
-  }
-  return result;
-}
-class OpsResource {
-  constructor(max) {
-    this.max = max;
-    assert.ok(
-      max === Infinity || isNumber(max) && max > 0,
-      "maxOps must be a number greater than zero."
-    );
-    this.uses = 0;
-  }
-  uses;
-  assert() {
-    assert.ok(
-      ++this.uses <= this.max,
-      `Maximum search operations reached: ${this.max}`
-    );
-  }
+	const optsTransform = {};
+	const result = {
+		transform: optsTransform,
+		allowEmpty: false,
+		maxOps: Infinity
+	};
+	for (const { transform, allowedKeys, ...rest } of options) {
+		Object.assign(result, rest);
+		if (allowedKeys?.length) result.allowedKeys = new Set(allowedKeys);
+		if (Array.isArray(transform) || isFunction(transform)) {
+			optsTransform["*"] = optsTransform["*"] || [];
+			optsTransform["*"].push(...arrayable(transform));
+		} else if (transform) for (const [key, value] of Object.entries(transform)) {
+			optsTransform[key] = optsTransform[key] || [];
+			optsTransform[key].push(...arrayable(value));
+		}
+	}
+	return result;
 }
+var OpsResource = class {
+	max;
+	uses;
+	constructor(max) {
+		this.max = max;
+		assert.ok(max === Infinity || isNumber(max) && max > 0, "maxOps must be a number greater than zero.");
+		this.uses = 0;
+	}
+	assert() {
+		assert.ok(++this.uses <= this.max, `Maximum search operations reached: ${this.max}`);
+	}
+};
 function callTransform(fns, value, key) {
-  for (const fn of fns) {
-    value = fn(value, key);
-  }
-  return value;
+	for (const fn of fns) value = fn(value, key);
+	return value;
 }
-
 const MONGO_TRANSFORM = Object.freeze({
-  /**
-   * Ensures the value is not null.
-   * Throws an error if the value is null.
-   *
-   * @throws {Error} If the value is null.
-   */
-  NOT_NULLABLE: (value, key) => {
-    assert.ok(value !== null, `The search key "${key}" cannot be null.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a number.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid number.
-   */
-  NUMBER: (value, key) => {
-    if (value === null) return null;
-    assert.number(value, `The search key "${key}" is not valid number.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a string.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid string.
-   */
-  STRING: (value, key) => {
-    if (value === null) return null;
-    assert.string(value, `The search key "${key}" is not valid string.`);
-    return value;
-  },
-  /**
-   * Validates that the value is a boolean.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid boolean.
-   */
-  BOOLEAN: (value, key) => {
-    if (value === null) return null;
-    assert.boolean(value, `The search key "${key}" is not valid boolean.`);
-    return value;
-  },
-  /**
-   * Validates and converts the value to a MongoDB ObjectId.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid ObjectId.
-   */
-  OBJECT_ID: (value, key) => {
-    if (value === null) return null;
-    assert.ok(
-      isObjectIdOrHexString,
-      `The search key "${key}" is not valid object id.`
-    );
-    return new mongoose.Types.ObjectId(value);
-  },
-  /**
-   * Validates and converts the value to a Date.
-   * Supports string and number inputs for conversion.
-   * If the value is `null`, it returns `null` without throwing an error.
-   *
-   * @throws {Error} If the value is not a valid date.
-   */
-  DATE: (value, key) => {
-    if (value === null) return null;
-    const result = isString(value) ? new Date(value) : isNumber(value) ? new Date(value) : void 0;
-    assert.date(result, `The search key "${key}" is not valid date.`);
-    return result;
-  }
+	NOT_NULLABLE: ((value, key) => {
+		assert.ok(value !== null, `The search key "${key}" cannot be null.`);
+		return value;
+	}),
+	NUMBER: ((value, key) => {
+		if (value === null) return null;
+		assert.number(value, `The search key "${key}" is not valid number.`);
+		return value;
+	}),
+	STRING: ((value, key) => {
+		if (value === null) return null;
+		assert.string(value, `The search key "${key}" is not valid string.`);
+		return value;
+	}),
+	BOOLEAN: ((value, key) => {
+		if (value === null) return null;
+		assert.boolean(value, `The search key "${key}" is not valid boolean.`);
+		return value;
+	}),
+	OBJECT_ID: ((value, key) => {
+		if (value === null) return null;
+		assert.ok(isObjectIdOrHexString, `The search key "${key}" is not valid object id.`);
+		return new mongoose.Types.ObjectId(value);
+	}),
+	DATE: ((value, key) => {
+		if (value === null) return null;
+		const result = isString(value) ? new Date(value) : isNumber(value) ? new Date(value) : void 0;
+		assert.date(result, `The search key "${key}" is not valid date.`);
+		return result;
+	})
 });
 const INSTANCE_TO_TRANSFORM = {
-  Number: [MONGO_TRANSFORM.NUMBER],
-  Decimal128: [MONGO_TRANSFORM.NUMBER],
-  String: [MONGO_TRANSFORM.STRING],
-  UUID: [MONGO_TRANSFORM.STRING],
-  ObjectId: [MONGO_TRANSFORM.OBJECT_ID],
-  Boolean: [MONGO_TRANSFORM.BOOLEAN],
-  Date: [MONGO_TRANSFORM.DATE]
+	Number: [MONGO_TRANSFORM.NUMBER],
+	Decimal128: [MONGO_TRANSFORM.NUMBER],
+	String: [MONGO_TRANSFORM.STRING],
+	UUID: [MONGO_TRANSFORM.STRING],
+	ObjectId: [MONGO_TRANSFORM.OBJECT_ID],
+	Boolean: [MONGO_TRANSFORM.BOOLEAN],
+	Date: [MONGO_TRANSFORM.DATE]
 };
 function parseToMongoose(reference, input, options = {}) {
-  const opts = mergeOptions(
-    extractFromSchema("schema" in reference ? reference.schema : reference),
-    options
-  );
-  const result = {};
-  const ops = new OpsResource(opts.maxOps);
-  const exp = new Expression(input).parse();
-  for (const node of exp.body) {
-    Object.assign(result, reduceNode(node, opts, ops));
-  }
-  return result;
+	const opts = mergeOptions(extractFromSchema("schema" in reference ? reference.schema : reference), options);
+	const result = {};
+	const ops = new OpsResource(opts.maxOps);
+	const exp = new Expression(input).parse();
+	for (const node of exp.body) Object.assign(result, reduceNode(node, opts, ops));
+	return result;
 }
-const extractFromSchema = withCache(
-  { objectStrategy: "ref" },
-  (schema) => {
-    const allowedKeys = [];
-    const transform = {};
-    eachPath(schema, (path, type) => {
-      transform[path] = INSTANCE_TO_TRANSFORM[type.instance];
-      allowedKeys.push(path);
-    });
-    return { allowedKeys, transform };
-  }
-);
+const extractFromSchema = withCache({ objectStrategy: "ref" }, (schema) => {
+	const allowedKeys = [];
+	const transform = {};
+	eachPath(schema, (path, type) => {
+		transform[path] = INSTANCE_TO_TRANSFORM[type.instance];
+		allowedKeys.push(path);
+	});
+	return {
+		allowedKeys,
+		transform
+	};
+});
 function eachPath(schema, fn, prefix = "") {
-  schema.eachPath((path, type) => {
-    if (type.schema) {
-      eachPath(type.schema, fn, `${path}.`);
-    } else {
-      fn(`${prefix}${path}`, type);
-    }
-  });
+	schema.eachPath((path, type) => {
+		if (type.schema) eachPath(type.schema, fn, `${path}.`);
+		else fn(`${prefix}${path}`, type);
+	});
 }
-
 export { Expression, KEYWORDS, MONGO_TRANSFORM, NODE, TOKEN, Tokenizer, parseQuery, parseToMongo, parseToMongoose };
-//# sourceMappingURL=index.mjs.map
+
+//# sourceMappingURL=index.mjs.map