@papra/search-parser 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Corentin THOMASSET
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,255 @@
+# @papra/search-parser
+
+A search query parser library for building GitHub-style search syntax with filters, logical operators, and full-text search.
+
+## Features
+
+- **Full-text search**: Extract search terms from queries
+- **Filters**: Support for field:value syntax with multiple operators (=, >, <, >=, <=)
+- **Logical operators**: AND, OR, NOT with proper precedence
+- **Grouping**: Parentheses for controlling evaluation order
+- **Negation**: Both `-filter:value` and `NOT filter:value` syntax
+- **Quoted values**: Support for spaces in filter values and search terms
+- **Escape sequences**: Escape quotes and colons with backslash
+- **Configurable limits**: Max depth and token count for safety
+- **Graceful error handling**: Best-effort parsing with issue reporting
+- **Zero dependencies**: No runtime dependencies
+- **Universal**: Works in Node.js, browsers, Deno, Cloudflare Workers, etc.
+- **Type-safe**: Fully typed with TypeScript
+
+## Installation
+
+```bash
+npm install @papra/search-parser
+# or
+pnpm add @papra/search-parser
+# or
+yarn add @papra/search-parser
+```
+
+## Usage
+
+```typescript
+import { parseSearchQuery } from '@papra/search-parser';
+
+// Simple full-text search
+const result1 = parseSearchQuery({ query: 'my invoice' });
+// {
+//   expression: { type: 'and', operands: [] },
+//   search: 'my invoice',
+//   issues: []
+// }
+
+// Filter with equality
+const result2 = parseSearchQuery({ query: 'tag:invoice' });
+// {
+//   expression: {
+//     type: 'filter',
+//     field: 'tag',
+//     operator: '=',
+//     value: 'invoice'
+//   },
+//   search: undefined,
+//   issues: []
+// }
+
+// Complex query with operators and grouping
+const result3 = parseSearchQuery({
+  query: '(tag:invoice OR tag:receipt) AND createdAt:>2024-01-01'
+});
+// {
+//   expression: {
+//     type: 'and',
+//     operands: [
+//       {
+//         type: 'or',
+//         operands: [
+//           { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
+//           { type: 'filter', field: 'tag', operator: '=', value: 'receipt' }
+//         ]
+//       },
+//       { type: 'filter', field: 'createdAt', operator: '>', value: '2024-01-01' }
+//     ]
+//   },
+//   search: undefined,
+//   issues: []
+// }
+```
+
+## Query Syntax
+
+### Full-text Search
+
+```
+my invoice
+"my special invoice"    # Quoted for multi-word terms
+"my \"special\" invoice" # Escaped quotes
+```
+
+### Filters
+
+```
+tag:invoice                # Equality (implicit)
+tag:=invoice               # Equality (explicit)
+createdAt:>2024-01-01      # Greater than
+createdAt:<2024-12-31      # Less than
+createdAt:>=2024-01-01     # Greater than or equal
+createdAt:<=2024-12-31     # Less than or equal
+```
+
+### Quoted Filter Values
+
+```
+tag:"my invoices"                  # Spaces in value
+tag:"my \"special\" invoices"      # Escaped quotes in value
+tag:my\:\:special\:\:tag          # Escaped colons in value
+```
+
+### Logical Operators
+
+```
+tag:invoice AND status:active      # Explicit AND
+tag:invoice status:active          # Implicit AND
+tag:invoice OR tag:receipt         # OR
+NOT tag:personal                   # NOT
+tag:invoice OR tag:receipt AND status:active  # Precedence: AND > OR
+```
+
+### Negation
+
+```
+-tag:personal                      # Minus prefix
+NOT tag:personal                   # NOT keyword
+NOT (tag:personal OR tag:private)  # Negated group
+```
+
+### Grouping
+
+```
+(tag:invoice OR tag:receipt)
+(tag:invoice OR tag:receipt) AND status:active
+```
+
+### Combining Filters and Search
+
+```
+tag:invoice my document            # Filter + search
+foo tag:invoice bar                # Search terms can be anywhere
+```
+
+### Escaping
+
+```
+tag\:invoice                       # Escape colon to prevent filter parsing
+                                   # Results in search text "tag:invoice"
+```
+
+## API
+
+### parseSearchQuery
+
+```typescript
+function parseSearchQuery(options: {
+  query: string;
+  maxDepth?: number;    // Default: 10
+  maxTokens?: number;   // Default: 200
+}): ParsedQuery;
+```
+
+## Operator Precedence
+
+From highest to lowest:
+
+1. **NOT** (highest)
+2. **AND**
+3. **OR** (lowest)
+
+Use parentheses to override precedence:
+
+```
+tag:invoice OR tag:receipt AND status:active
+# Parsed as: tag:invoice OR (tag:receipt AND status:active)
+
+(tag:invoice OR tag:receipt) AND status:active
+# Parsed as: (tag:invoice OR tag:receipt) AND status:active
+```
+
+## Error Handling
+
+### Issue Structure
+
+All parsing issues are returned with both a machine-readable error code and a human-readable message:
+
+```typescript
+type Issue = {
+  code: string;      // Machine-readable error code
+  message: string;   // Human-readable error message
+};
+```
+
+### Error Codes
+
+The library exports an `ERROR_CODES` constant with all available error codes:
+
+```typescript
+import { ERROR_CODES } from '@papra/search-parser';
+
+const result = parseSearchQuery({ query: '(tag:invoice' });
+
+// Check for specific error by code
+const hasUnmatchedParen = result.issues.some(
+  issue => issue.code === ERROR_CODES.UNMATCHED_OPENING_PARENTHESIS
+);
+```
+
+Available error codes are defined in [`src/errors.ts`](src/errors.ts).
+
+## Safety Features
+
+### Maximum Depth
+
+Prevents deeply nested expressions (e.g., excessive parentheses):
+
+```typescript
+parseSearchQuery({
+  query: '((((((((((tag:invoice))))))))))',
+  maxDepth: 5  // Will report issue if exceeded
+});
+```
+
+### Maximum Tokens
+
+Prevents excessively long queries:
+
+```typescript
+parseSearchQuery({
+  query: 'tag1:val1 tag2:val2 ... tag100:val100',
+  maxTokens: 50  // Will report issue if exceeded
+});
+```
+
+### Graceful Error Handling
+
+Malformed queries are handled gracefully with best-effort parsing:
+
+```typescript
+parseSearchQuery({ query: '(tag:invoice' });
+// {
+//   expression: { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
+//   search: undefined,
+//   issues: [
+//     {
+//       code: 'unmatched-opening-parenthesis',
+//       message: 'Unmatched opening parenthesis'
+//     }
+//   ]
+// }
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or pull request on GitHub.

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+//#region src/errors.d.ts
+declare const ERROR_CODES: {
+  MAX_TOKENS_EXCEEDED: string;
+  MAX_NESTING_DEPTH_EXCEEDED: string;
+  UNMATCHED_OPENING_PARENTHESIS: string;
+  UNMATCHED_CLOSING_PARENTHESIS: string;
+  UNCLOSED_QUOTED_STRING: string;
+  MISSING_OPERAND_FOR_NOT: string;
+};
+//#endregion
+//#region src/parser.types.d.ts
+type Issue = {
+  message: string;
+  code: string;
+};
+type ParsedQuery = {
+  expression: Expression;
+  issues: Issue[];
+};
+type Expression = AndExpression | OrExpression | NotExpression | FilterExpression | TextExpression | EmptyExpression;
+type EmptyExpression = {
+  type: 'empty';
+};
+type AndExpression = {
+  type: 'and';
+  operands: Expression[];
+};
+type OrExpression = {
+  type: 'or';
+  operands: Expression[];
+};
+type NotExpression = {
+  type: 'not';
+  operand: Expression;
+};
+type Operator = '>' | '<' | '>=' | '<=' | '=';
+type FilterExpression = {
+  type: 'filter';
+  field: string;
+  operator: Operator;
+  value: string;
+};
+type TextExpression = {
+  type: 'text';
+  value: string;
+};
+//#endregion
+//#region src/optimization.d.ts
+/**
+ * Simplifies an expression tree by applying optimization rules.
+ * - AND/OR expressions with a single child are replaced by that child.
+ * - NOT expressions with a NOT child are replaced by the grandchild (double negation).
+ * - Nested AND/OR expressions are flattened.
+ * - Redundant expressions are removed (duplicates, empty expressions).
+ * - Empty AND/OR expressions are converted to 'empty'.
+ */
+declare function simplifyExpression({
+  expression
+}: {
+  expression: Expression;
+}): {
+  expression: Expression;
+};
+//#endregion
+//#region src/parser.d.ts
+declare function parseSearchQuery({
+  query,
+  maxDepth,
+  maxTokens,
+  optimize
+}: {
+  query: string;
+  maxDepth?: number;
+  maxTokens?: number;
+  optimize?: boolean;
+}): ParsedQuery;
+//#endregion
+export { type AndExpression, ERROR_CODES, type EmptyExpression, type Expression, type FilterExpression, type Issue, type NotExpression, type Operator, type OrExpression, type ParsedQuery, type TextExpression, parseSearchQuery, simplifyExpression };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/parser.types.ts","../src/optimization.ts","../src/parser.ts"],"sourcesContent":[],"mappings":";cAAa;EAAA,mBAOZ,EAAA,MAAA;;;;ECPW,sBAAK,EAAA,MAAA;EAKL,uBAAW,EAAA,MAAA;CAAA;;;KALX,KAAA;EDAC,OAAA,EAAA,MAOZ;;;KCFW,WAAA;EALA,UAAK,EAMH,UANG;EAKL,MAAA,EAEF,KAFE,EAAW;CAAA;AACT,KAIF,UAAA,GACN,aALQ,GAMR,YANQ,GAOR,aAPQ,GAQR,gBARQ,GASR,cATQ,GAUR,eAVQ;AACJ,KAWE,eAAA,GAXF;EAAK,IAAA,EAAA,OAAA;AAGf,CAAA;AAAsB,KAYV,aAAA,GAZU;EAAA,IAChB,EAAA,KAAA;EAAa,QACb,EAYM,UAZN,EAAA;CAAY;AAEZ,KAaM,YAAA,GAbN;EAAgB,IAChB,EAAA,IAAA;EAAc,QACd,EAaM,UAbN,EAAA;AAAe,CAAA;AAET,KAcA,aAAA,GAde;EAIf,IAAA,EAAA,KAAA;EAKA,OAAA,EAOD,UAPa;AAKxB,CAAA;AAKY,KAAA,QAAA,GAAQ,GAAA,GAAA,GAAA,GAAA,IAAA,GAAA,IAAA,GAAA,GAAA;AAER,KAAA,gBAAA,GAAgB;EAOhB,IAAA,EAAA,QAAA;;YAJA;;AChCZ,CAAA;AAAkC,KDoCtB,cAAA,GCpCsB;EAAA,IAAG,EAAA,MAAA;EAAU,KAAkB,EAAA,MAAA;CAAU;;;AFV3E;;;;ACAA;AAKA;;;AAEU,iBCGM,kBAAA,CDHN;EAAA;AAGV,CAHU,EAAA;EAAK,UAAA,ECGkD,UDHlD;AAGf,CAAA,CAAA,EAAY;EAAU,UAAA,ECAwE,UDAxE;CAAA;;;ADVT,iBGMG,gBAAA,CHCf;EAAA,KAAA;EAAA,QAAA;EAAA,SAAA;EAAA;ACFD,CDEC,EAAA;;;;ECPW,QAAK,CAAA,EAAA,OAAA;AAKjB,CAAA,CAAA,EEaG,WFbS"}

package/dist/index.js

@@ -0,0 +1,419 @@
+//#region src/errors.ts
+const ERROR_CODES = {
+	MAX_TOKENS_EXCEEDED: "max-tokens-exceeded",
+	MAX_NESTING_DEPTH_EXCEEDED: "max-nesting-depth-exceeded",
+	UNMATCHED_OPENING_PARENTHESIS: "unmatched-opening-parenthesis",
+	UNMATCHED_CLOSING_PARENTHESIS: "unmatched-closing-parenthesis",
+	UNCLOSED_QUOTED_STRING: "unclosed-quoted-string",
+	MISSING_OPERAND_FOR_NOT: "missing-operand-for-not"
+};
+
+//#endregion
+//#region src/optimization.ts
+/**
+* Simplifies an expression tree by applying optimization rules.
+* - AND/OR expressions with a single child are replaced by that child.
+* - NOT expressions with a NOT child are replaced by the grandchild (double negation).
+* - Nested AND/OR expressions are flattened.
+* - Redundant expressions are removed (duplicates, empty expressions).
+* - Empty AND/OR expressions are converted to 'empty'.
+*/
+function simplifyExpression({ expression }) {
+	if (expression.type === "empty" || expression.type === "text" || expression.type === "filter") return { expression };
+	if (expression.type === "not") return simplifyNotExpression({ expression });
+	if (expression.type === "and" || expression.type === "or") return simplifyAndOrExpression({ expression });
+	return { expression };
+}
+function simplifyOperands({ operands }) {
+	const simplifiedOperands = operands.map((expression) => simplifyExpression({ expression }).expression);
+	return { simplifiedOperands };
+}
+function simplifyNotExpression({ expression }) {
+	const { expression: simplifiedOperandExpression } = simplifyExpression({ expression: expression.operand });
+	if (simplifiedOperandExpression.type === "not") return { expression: simplifiedOperandExpression.operand };
+	if (simplifiedOperandExpression.type === "empty") return { expression: { type: "empty" } };
+	return { expression: {
+		type: "not",
+		operand: simplifiedOperandExpression
+	} };
+}
+function simplifyAndOrExpression({ expression }) {
+	const { simplifiedOperands } = simplifyOperands({ operands: expression.operands });
+	const filteredOperands = simplifiedOperands.filter((op) => op.type !== "empty");
+	const { flattenedOperands } = flattenOperands({
+		type: expression.type,
+		operands: filteredOperands
+	});
+	const { deduplicatedOperands } = deduplicateOperands({ operands: flattenedOperands });
+	if (deduplicatedOperands.length === 0) return { expression: { type: "empty" } };
+	if (deduplicatedOperands.length === 1) return { expression: deduplicatedOperands[0] };
+	return { expression: {
+		type: expression.type,
+		operands: deduplicatedOperands
+	} };
+}
+function flattenOperands({ type, operands }) {
+	const flattenedOperands = [];
+	for (const operand of operands) if (operand.type === type) flattenedOperands.push(...operand.operands);
+	else flattenedOperands.push(operand);
+	return { flattenedOperands };
+}
+function deduplicateOperands({ operands }) {
+	const deduplicatedOperands = [];
+	for (const operand of operands) {
+		const isDuplicate = deduplicatedOperands.some((existing) => areExpressionsIdentical(existing, operand));
+		if (!isDuplicate) deduplicatedOperands.push(operand);
+	}
+	return { deduplicatedOperands };
+}
+function areExpressionsIdentical(a, b) {
+	if (a.type !== b.type) return false;
+	if (a.type === "empty" && b.type === "empty") return true;
+	if (a.type === "text" && b.type === "text") return a.value === b.value;
+	if (a.type === "filter" && b.type === "filter") return a.field === b.field && a.operator === b.operator && a.value === b.value;
+	if (a.type === "not" && b.type === "not") return areExpressionsIdentical(a.operand, b.operand);
+	if (a.type === "and" && b.type === "and" || a.type === "or" && b.type === "or") {
+		if (a.operands.length !== b.operands.length) return false;
+		for (let i = 0; i < a.operands.length; i++) if (!areExpressionsIdentical(a.operands[i], b.operands[i])) return false;
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/tokenizer.ts
+function tokenize({ query, maxTokens }) {
+	const tokens = [];
+	const issues = [];
+	let pos = 0;
+	const peek = () => query[pos];
+	const advance = () => query[pos++] || "";
+	const skipWhitespace = () => {
+		while (pos < query.length) {
+			const char = query[pos];
+			if (!char || !/\s/.test(char)) break;
+			pos++;
+		}
+	};
+	const readQuotedString = () => {
+		if (peek() !== "\"") return void 0;
+		advance();
+		let value = "";
+		let escaped = false;
+		while (pos < query.length) {
+			const char = peek();
+			if (!char) break;
+			if (escaped) {
+				value += char;
+				escaped = false;
+				advance();
+			} else if (char === "\\") {
+				escaped = true;
+				advance();
+			} else if (char === "\"") {
+				advance();
+				return value;
+			} else {
+				value += char;
+				advance();
+			}
+		}
+		issues.push({
+			code: ERROR_CODES.UNCLOSED_QUOTED_STRING,
+			message: "Unclosed quoted string"
+		});
+		return value;
+	};
+	const readUnquotedToken = (stopAtQuote = false) => {
+		let value = "";
+		while (pos < query.length) {
+			const char = peek();
+			if (!char || /\s/.test(char) || char === "(" || char === ")") break;
+			if (stopAtQuote && char === "\"") break;
+			value += advance();
+		}
+		return value;
+	};
+	const readFilterValue = () => {
+		skipWhitespace();
+		const quotedValue = readQuotedString();
+		if (quotedValue !== void 0) return quotedValue;
+		let value = "";
+		while (pos < query.length) {
+			const char = peek();
+			if (!char || /\s/.test(char) || char === "(" || char === ")") break;
+			if (char === "\\") {
+				advance();
+				if (pos < query.length) value += advance();
+			} else value += advance();
+		}
+		return value.replace(/\\:/g, ":");
+	};
+	const hasUnescapedColon = (str) => {
+		for (let i = 0; i < str.length; i++) if (str[i] === ":" && (i === 0 || str[i - 1] !== "\\")) return true;
+		return false;
+	};
+	const parseFilter = (token, negated) => {
+		if (!hasUnescapedColon(token)) return void 0;
+		let firstColonIndex = -1;
+		for (let i = 0; i < token.length; i++) if (token[i] === ":" && (i === 0 || token[i - 1] !== "\\")) {
+			firstColonIndex = i;
+			break;
+		}
+		if (firstColonIndex === -1) return void 0;
+		const field = token.slice(0, firstColonIndex).replace(/\\:/g, ":");
+		const afterColon = token.slice(firstColonIndex + 1);
+		let operator = "=";
+		let operatorLength = 0;
+		if (afterColon.startsWith(">=")) {
+			operator = ">=";
+			operatorLength = 2;
+		} else if (afterColon.startsWith("<=")) {
+			operator = "<=";
+			operatorLength = 2;
+		} else if (afterColon.startsWith(">")) {
+			operator = ">";
+			operatorLength = 1;
+		} else if (afterColon.startsWith("<")) {
+			operator = "<";
+			operatorLength = 1;
+		} else if (afterColon.startsWith("=")) {
+			operator = "=";
+			operatorLength = 1;
+		}
+		let value = afterColon.slice(operatorLength).replace(/\\:/g, ":");
+		if (!value) value = readFilterValue();
+		return {
+			type: "FILTER",
+			field,
+			operator,
+			value,
+			negated
+		};
+	};
+	while (pos < query.length) {
+		if (tokens.length >= maxTokens) {
+			issues.push({
+				code: ERROR_CODES.MAX_TOKENS_EXCEEDED,
+				message: `Maximum token limit of ${maxTokens} exceeded`
+			});
+			break;
+		}
+		skipWhitespace();
+		if (pos >= query.length) break;
+		const char = peek();
+		if (char === "(") {
+			advance();
+			tokens.push({ type: "LPAREN" });
+			continue;
+		}
+		if (char === ")") {
+			advance();
+			tokens.push({ type: "RPAREN" });
+			continue;
+		}
+		const nextChar = query[pos + 1];
+		if (char === "-" && nextChar && !/\s/.test(nextChar)) {
+			advance();
+			skipWhitespace();
+			const quotedValue$1 = readQuotedString();
+			const token$1 = quotedValue$1 !== void 0 ? quotedValue$1 : readUnquotedToken();
+			const filter = parseFilter(token$1, true);
+			if (filter) tokens.push(filter);
+			else {
+				const unescapedText$1 = token$1.replace(/\\(.)/g, "$1");
+				tokens.push({ type: "NOT" });
+				tokens.push({
+					type: "TEXT",
+					value: unescapedText$1
+				});
+			}
+			continue;
+		}
+		const quotedValue = readQuotedString();
+		const token = quotedValue !== void 0 ? quotedValue : readUnquotedToken(true);
+		if (!token) {
+			advance();
+			continue;
+		}
+		const upperToken = token.toUpperCase();
+		if (upperToken === "AND") {
+			tokens.push({ type: "AND" });
+			continue;
+		}
+		if (upperToken === "OR") {
+			tokens.push({ type: "OR" });
+			continue;
+		}
+		if (upperToken === "NOT") {
+			tokens.push({ type: "NOT" });
+			continue;
+		}
+		if (quotedValue === void 0) {
+			const filter = parseFilter(token, false);
+			if (filter) {
+				tokens.push(filter);
+				continue;
+			}
+		}
+		const unescapedText = token.replace(/\\(.)/g, "$1");
+		tokens.push({
+			type: "TEXT",
+			value: unescapedText
+		});
+	}
+	tokens.push({ type: "EOF" });
+	return {
+		tokens,
+		issues
+	};
+}
+
+//#endregion
+//#region src/parser.ts
+function parseSearchQuery({ query, maxDepth = 10, maxTokens = 200, optimize = false }) {
+	const { tokens, issues: tokenizerIssues } = tokenize({
+		query,
+		maxTokens
+	});
+	const { expression, issues: parserIssues } = parseExpression({
+		tokens,
+		maxDepth
+	});
+	const issues = [...tokenizerIssues, ...parserIssues];
+	if (!optimize) return {
+		expression,
+		issues
+	};
+	const { expression: optimizedExpression } = simplifyExpression({ expression });
+	return {
+		expression: optimizedExpression,
+		issues
+	};
+}
+function parseExpression({ tokens, maxDepth }) {
+	const parserIssues = [];
+	let currentTokenIndex = 0;
+	let currentDepth = 0;
+	const peek = () => tokens[currentTokenIndex] ?? { type: "EOF" };
+	const advance = () => tokens[currentTokenIndex++] ?? { type: "EOF" };
+	const checkDepth = () => {
+		if (currentDepth >= maxDepth) {
+			parserIssues.push({
+				code: ERROR_CODES.MAX_NESTING_DEPTH_EXCEEDED,
+				message: `Maximum nesting depth of ${maxDepth} exceeded`
+			});
+			return false;
+		}
+		return true;
+	};
+	function parsePrimaryExpression() {
+		const token = peek();
+		if (token.type === "LPAREN") {
+			advance();
+			if (!checkDepth()) return void 0;
+			currentDepth++;
+			const expr = parseOrExpression();
+			currentDepth--;
+			if (peek().type === "RPAREN") advance();
+			else parserIssues.push({
+				code: ERROR_CODES.UNMATCHED_OPENING_PARENTHESIS,
+				message: "Unmatched opening parenthesis"
+			});
+			return expr;
+		}
+		if (token.type === "FILTER") {
+			advance();
+			const filterExpr = {
+				type: "filter",
+				field: token.field,
+				operator: token.operator,
+				value: token.value
+			};
+			if (token.negated) return {
+				type: "not",
+				operand: filterExpr
+			};
+			return filterExpr;
+		}
+		if (token.type === "TEXT") {
+			advance();
+			return {
+				type: "text",
+				value: token.value
+			};
+		}
+		return void 0;
+	}
+	function parseUnaryExpression() {
+		if (peek().type === "NOT") {
+			advance();
+			if (!checkDepth()) return void 0;
+			currentDepth++;
+			const operand = parseUnaryExpression();
+			currentDepth--;
+			if (!operand) {
+				parserIssues.push({
+					code: ERROR_CODES.MISSING_OPERAND_FOR_NOT,
+					message: "NOT operator requires an operand"
+				});
+				return void 0;
+			}
+			return {
+				type: "not",
+				operand
+			};
+		}
+		return parsePrimaryExpression();
+	}
+	function parseAndExpression() {
+		const operands = [];
+		while (true) {
+			const next = peek();
+			if (next.type === "EOF" || next.type === "OR" || next.type === "RPAREN") break;
+			if (next.type === "AND") {
+				advance();
+				continue;
+			}
+			const expr = parseUnaryExpression();
+			if (expr) operands.push(expr);
+		}
+		if (operands.length === 0) return void 0;
+		if (operands.length === 1) return operands[0];
+		return {
+			type: "and",
+			operands
+		};
+	}
+	function parseOrExpression() {
+		const left = parseAndExpression();
+		if (!left) return void 0;
+		const operands = [left];
+		while (peek().type === "OR") {
+			advance();
+			const right = parseAndExpression();
+			if (right) operands.push(right);
+		}
+		if (operands.length === 1) return operands[0];
+		return {
+			type: "or",
+			operands
+		};
+	}
+	const expression = parseOrExpression();
+	while (peek().type === "RPAREN") {
+		parserIssues.push({
+			message: "Unmatched closing parenthesis",
+			code: ERROR_CODES.UNMATCHED_CLOSING_PARENTHESIS
+		});
+		advance();
+	}
+	return {
+		expression: expression ?? { type: "empty" },
+		issues: parserIssues
+	};
+}
+
+//#endregion
+export { ERROR_CODES, parseSearchQuery, simplifyExpression };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["flattenedOperands: Expression[]","deduplicatedOperands: Expression[]","a: Expression","b: Expression","tokens: Token[]","issues: Issue[]","str: string","token: string","negated: boolean","operator: Operator","quotedValue","token","unescapedText","parserIssues: Issue[]","filterExpr: Expression","operands: Expression[]"],"sources":["../src/errors.ts","../src/optimization.ts","../src/tokenizer.ts","../src/parser.ts"],"sourcesContent":["export const ERROR_CODES = {\n  MAX_TOKENS_EXCEEDED: 'max-tokens-exceeded',\n  MAX_NESTING_DEPTH_EXCEEDED: 'max-nesting-depth-exceeded',\n  UNMATCHED_OPENING_PARENTHESIS: 'unmatched-opening-parenthesis',\n  UNMATCHED_CLOSING_PARENTHESIS: 'unmatched-closing-parenthesis',\n  UNCLOSED_QUOTED_STRING: 'unclosed-quoted-string',\n  MISSING_OPERAND_FOR_NOT: 'missing-operand-for-not',\n};\n","import type { AndExpression, Expression, NotExpression, OrExpression } from './parser.types';\n\n/**\n * Simplifies an expression tree by applying optimization rules.\n * - AND/OR expressions with a single child are replaced by that child.\n * - NOT expressions with a NOT child are replaced by the grandchild (double negation).\n * - Nested AND/OR expressions are flattened.\n * - Redundant expressions are removed (duplicates, empty expressions).\n * - Empty AND/OR expressions are converted to 'empty'.\n */\nexport function simplifyExpression({ expression }: { expression: Expression }): { expression: Expression } {\n  if (\n    expression.type === 'empty'\n    || expression.type === 'text'\n    || expression.type === 'filter'\n  ) {\n    return { expression };\n  }\n\n  if (expression.type === 'not') {\n    return simplifyNotExpression({ expression });\n  }\n\n  if (expression.type === 'and' || expression.type === 'or') {\n    return simplifyAndOrExpression({ expression });\n  }\n\n  // This should never be reached, but hey, you never know\n  return { expression };\n}\n\nexport function simplifyOperands({ operands }: { operands: Expression[] }): { simplifiedOperands: Expression[] } {\n  const simplifiedOperands = operands.map(expression => simplifyExpression({ expression }).expression);\n\n  return { simplifiedOperands };\n}\n\nfunction simplifyNotExpression({ expression }: { expression: NotExpression }): { expression: Expression } {\n  const { expression: simplifiedOperandExpression } = simplifyExpression({ expression: expression.operand });\n\n  // NOT(NOT(A)) -> A\n  if (simplifiedOperandExpression.type === 'not') {\n    return { expression: simplifiedOperandExpression.operand };\n  }\n\n  // NOT(empty) -> empty\n  if (simplifiedOperandExpression.type === 'empty') {\n    return { expression: { type: 'empty' } };\n  }\n\n  return { expression: { type: 'not', operand: simplifiedOperandExpression } };\n}\n\nfunction simplifyAndOrExpression({ expression }: { expression: AndExpression | OrExpression }): { expression: Expression } {\n  const { simplifiedOperands } = simplifyOperands({ operands: expression.operands });\n  const filteredOperands = simplifiedOperands.filter(op => op.type !== 'empty');\n  const { flattenedOperands } = flattenOperands({ type: expression.type, operands: filteredOperands });\n  const { deduplicatedOperands } = deduplicateOperands({ operands: flattenedOperands });\n\n  if (deduplicatedOperands.length === 0) {\n    return { expression: { type: 'empty' } };\n  }\n\n  // AND(A) -> A, OR(A) -> A\n  if (deduplicatedOperands.length === 1) {\n    return { expression: deduplicatedOperands[0]! };\n  }\n\n  return {\n    expression: {\n      type: expression.type,\n      operands: deduplicatedOperands,\n    },\n  };\n}\n\nfunction flattenOperands({ type, operands }: { type: 'and' | 'or'; operands: Expression[] }): { flattenedOperands: Expression[] } {\n  const flattenedOperands: Expression[] = [];\n\n  for (const operand of operands) {\n    // When the operand is of the same type, inline its operands\n    // AND(A, AND(B, C)) -> AND(A, B, C)\n    if (operand.type === type) {\n      flattenedOperands.push(...operand.operands);\n    } else {\n      flattenedOperands.push(operand);\n    }\n  }\n\n  return { flattenedOperands };\n}\n\nfunction deduplicateOperands({ operands }: { operands: Expression[] }): { deduplicatedOperands: Expression[] } {\n  const deduplicatedOperands: Expression[] = [];\n\n  for (const operand of operands) {\n    const isDuplicate = deduplicatedOperands.some(existing => areExpressionsIdentical(existing, operand));\n    if (!isDuplicate) {\n      deduplicatedOperands.push(operand);\n    }\n  }\n\n  return { deduplicatedOperands };\n}\n\nexport function areExpressionsIdentical(a: Expression, b: Expression): boolean {\n  if (a.type !== b.type) {\n    return false;\n  }\n\n  if (a.type === 'empty' && b.type === 'empty') {\n    return true;\n  }\n\n  if (a.type === 'text' && b.type === 'text') {\n    return a.value === b.value;\n  }\n\n  if (a.type === 'filter' && b.type === 'filter') {\n    return a.field === b.field\n      && a.operator === b.operator\n      && a.value === b.value;\n  }\n\n  if (a.type === 'not' && b.type === 'not') {\n    return areExpressionsIdentical(a.operand, b.operand);\n  }\n\n  if ((a.type === 'and' && b.type === 'and') || (a.type === 'or' && b.type === 'or')) {\n    if (a.operands.length !== b.operands.length) {\n      return false;\n    }\n\n    for (let i = 0; i < a.operands.length; i++) {\n      if (!areExpressionsIdentical(a.operands[i]!, b.operands[i]!)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return false;\n}\n","import type { Issue, Operator } from './parser.types';\nimport { ERROR_CODES } from './errors';\n\nexport type Token\n  = | { type: 'LPAREN' }\n    | { type: 'RPAREN' }\n    | { type: 'AND' }\n    | { type: 'OR' }\n    | { type: 'NOT' }\n    | { type: 'FILTER'; field: string; operator: Operator; value: string; negated: boolean }\n    | { type: 'TEXT'; value: string }\n    | { type: 'EOF' };\n\nexport type TokenizeResult = {\n  tokens: Token[];\n  issues: Issue[];\n};\n\nexport function tokenize({ query, maxTokens }: { query: string; maxTokens: number }): TokenizeResult {\n  const tokens: Token[] = [];\n  const issues: Issue[] = [];\n  let pos = 0;\n\n  const peek = (): string | undefined => query[pos];\n  const advance = (): string => query[pos++] || '';\n\n  const skipWhitespace = (): void => {\n    while (pos < query.length) {\n      const char = query[pos];\n      if (!char || !/\\s/.test(char)) {\n        break;\n      }\n      pos++;\n    }\n  };\n\n  const readQuotedString = (): string | undefined => {\n    if (peek() !== '\"') {\n      return undefined;\n    }\n\n    advance(); // Skip opening quote\n    let value = '';\n    let escaped = false;\n\n    while (pos < query.length) {\n      const char = peek();\n\n      if (!char) {\n        break;\n      }\n\n      if (escaped) {\n        value += char;\n        escaped = false;\n        advance();\n      } else if (char === '\\\\') {\n        escaped = true;\n        advance();\n      } else if (char === '\"') {\n        advance(); // Skip closing quote\n        return value;\n      } else {\n        value += char;\n        advance();\n      }\n    }\n\n    issues.push({\n      code: ERROR_CODES.UNCLOSED_QUOTED_STRING,\n      message: 'Unclosed quoted string',\n    });\n    return value;\n  };\n\n  const readUnquotedToken = (stopAtQuote = false): string => {\n    let value = '';\n\n    while (pos < query.length) {\n      const char = peek();\n\n      if (!char || /\\s/.test(char) || char === '(' || char === ')') {\n        break;\n      }\n\n      // Stop at quote if requested (for filter field names before quoted values)\n      if (stopAtQuote && char === '\"') {\n        break;\n      }\n\n      // Keep backslashes in unquoted tokens so parseFilter can detect escaped colons\n      value += advance();\n    }\n\n    return value;\n  };\n\n  const readFilterValue = (): string => {\n    skipWhitespace();\n\n    // Check if value is quoted\n    const quotedValue = readQuotedString();\n    if (quotedValue !== undefined) {\n      return quotedValue;\n    }\n\n    // Read unquoted value (up to whitespace or special chars)\n    let value = '';\n    while (pos < query.length) {\n      const char = peek();\n\n      if (!char || /\\s/.test(char) || char === '(' || char === ')') {\n        break;\n      }\n\n      if (char === '\\\\') {\n        advance();\n        if (pos < query.length) {\n          value += advance();\n        }\n      } else {\n        value += advance();\n      }\n    }\n\n    return value.replace(/\\\\:/g, ':');\n  };\n\n  const hasUnescapedColon = (str: string): boolean => {\n    for (let i = 0; i < str.length; i++) {\n      if (str[i] === ':' && (i === 0 || str[i - 1] !== '\\\\')) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  const parseFilter = (token: string, negated: boolean): Token | undefined => {\n    // Check for unescaped colons\n    if (!hasUnescapedColon(token)) {\n      return undefined;\n    }\n\n    // Find first unescaped colon\n    let firstColonIndex = -1;\n    for (let i = 0; i < token.length; i++) {\n      if (token[i] === ':' && (i === 0 || token[i - 1] !== '\\\\')) {\n        firstColonIndex = i;\n        break;\n      }\n    }\n\n    if (firstColonIndex === -1) {\n      return undefined;\n    }\n\n    const field = token.slice(0, firstColonIndex).replace(/\\\\:/g, ':');\n    const afterColon = token.slice(firstColonIndex + 1);\n\n    // Check for operator at the start\n    let operator: Operator = '=';\n    let operatorLength = 0;\n\n    if (afterColon.startsWith('>=')) {\n      operator = '>=';\n      operatorLength = 2;\n    } else if (afterColon.startsWith('<=')) {\n      operator = '<=';\n      operatorLength = 2;\n    } else if (afterColon.startsWith('>')) {\n      operator = '>';\n      operatorLength = 1;\n    } else if (afterColon.startsWith('<')) {\n      operator = '<';\n      operatorLength = 1;\n    } else if (afterColon.startsWith('=')) {\n      operator = '=';\n      operatorLength = 1;\n    }\n\n    // If there's nothing after the operator in the token, read the value from input\n    let value = afterColon.slice(operatorLength).replace(/\\\\:/g, ':');\n\n    // If the value is empty and we still have input, this might be a case like \"tag:\" followed by a quoted string\n    if (!value) {\n      value = readFilterValue();\n    }\n\n    return { type: 'FILTER', field, operator, value, negated };\n  };\n\n  while (pos < query.length) {\n    if (tokens.length >= maxTokens) {\n      issues.push({\n        code: ERROR_CODES.MAX_TOKENS_EXCEEDED,\n        message: `Maximum token limit of ${maxTokens} exceeded`,\n      });\n      break;\n    }\n\n    skipWhitespace();\n\n    if (pos >= query.length) {\n      break;\n    }\n\n    const char = peek();\n\n    // Handle parentheses\n    if (char === '(') {\n      advance();\n      tokens.push({ type: 'LPAREN' });\n      continue;\n    }\n\n    if (char === ')') {\n      advance();\n      tokens.push({ type: 'RPAREN' });\n      continue;\n    }\n\n    // Handle negation prefix\n    const nextChar = query[pos + 1];\n    if (char === '-' && nextChar && !/\\s/.test(nextChar)) {\n      advance();\n      skipWhitespace();\n\n      // Read the next token (could be quoted or unquoted)\n      const quotedValue = readQuotedString();\n      const token = quotedValue !== undefined ? quotedValue : readUnquotedToken();\n\n      // Try to parse as filter\n      const filter = parseFilter(token, true);\n      if (filter) {\n        tokens.push(filter);\n      } else {\n        // If not a filter, treat as negated text search (which we'll handle as NOT operator)\n        const unescapedText = token.replace(/\\\\(.)/g, '$1');\n        tokens.push({ type: 'NOT' });\n        tokens.push({ type: 'TEXT', value: unescapedText });\n      }\n      continue;\n    }\n\n    // Read quoted or unquoted token\n    const quotedValue = readQuotedString();\n    const token = quotedValue !== undefined ? quotedValue : readUnquotedToken(true);\n\n    if (!token) {\n      advance(); // Skip invalid character\n      continue;\n    }\n\n    // Check for operators\n    const upperToken = token.toUpperCase();\n    if (upperToken === 'AND') {\n      tokens.push({ type: 'AND' });\n      continue;\n    }\n\n    if (upperToken === 'OR') {\n      tokens.push({ type: 'OR' });\n      continue;\n    }\n\n    if (upperToken === 'NOT') {\n      tokens.push({ type: 'NOT' });\n      continue;\n    }\n\n    // Try to parse as filter (only if not quoted)\n    if (quotedValue === undefined) {\n      const filter = parseFilter(token, false);\n      if (filter) {\n        tokens.push(filter);\n        continue;\n      }\n    }\n\n    // Otherwise, treat as text (unescape backslashes)\n    const unescapedText = token.replace(/\\\\(.)/g, '$1');\n    tokens.push({ type: 'TEXT', value: unescapedText });\n  }\n\n  tokens.push({ type: 'EOF' });\n\n  return { tokens, issues };\n}\n","import type { Expression, Issue, ParsedQuery } from './parser.types';\nimport type { Token } from './tokenizer';\nimport { ERROR_CODES } from './errors';\nimport { simplifyExpression } from './optimization';\nimport { tokenize } from './tokenizer';\n\nexport function parseSearchQuery(\n  {\n    query,\n    maxDepth = 10,\n    maxTokens = 200,\n    optimize = false,\n  }: {\n    query: string;\n    maxDepth?: number;\n    maxTokens?: number;\n    optimize?: boolean;\n  },\n): ParsedQuery {\n  const { tokens, issues: tokenizerIssues } = tokenize({ query, maxTokens });\n\n  const { expression, issues: parserIssues } = parseExpression({ tokens, maxDepth });\n\n  const issues = [...tokenizerIssues, ...parserIssues];\n\n  if (!optimize) {\n    return {\n      expression,\n      issues,\n    };\n  }\n\n  const { expression: optimizedExpression } = simplifyExpression({ expression });\n\n  return {\n    expression: optimizedExpression,\n    issues,\n  };\n}\n\nfunction parseExpression({ tokens, maxDepth }: { tokens: Token[]; maxDepth: number }): ParsedQuery {\n  const parserIssues: Issue[] = [];\n\n  let currentTokenIndex = 0;\n  let currentDepth = 0;\n\n  const peek = (): Token => tokens[currentTokenIndex] ?? { type: 'EOF' };\n  const advance = (): Token => tokens[currentTokenIndex++] ?? { type: 'EOF' };\n\n  const checkDepth = (): boolean => {\n    if (currentDepth >= maxDepth) {\n      parserIssues.push({\n        code: ERROR_CODES.MAX_NESTING_DEPTH_EXCEEDED,\n        message: `Maximum nesting depth of ${maxDepth} exceeded`,\n      });\n      return false;\n    }\n    return true;\n  };\n\n  // Parse primary expression (filter, parentheses, text)\n  function parsePrimaryExpression(): Expression | undefined {\n    const token = peek();\n\n    if (token.type === 'LPAREN') {\n      advance(); // Consume (\n\n      if (!checkDepth()) {\n        return undefined;\n      }\n\n      currentDepth++;\n      const expr = parseOrExpression();\n      currentDepth--;\n\n      if (peek().type === 'RPAREN') {\n        advance(); // Consume )\n      } else {\n        parserIssues.push({\n          code: ERROR_CODES.UNMATCHED_OPENING_PARENTHESIS,\n          message: 'Unmatched opening parenthesis',\n        });\n      }\n\n      return expr;\n    }\n\n    if (token.type === 'FILTER') {\n      advance();\n      const filterExpr: Expression = {\n        type: 'filter',\n        field: token.field,\n        operator: token.operator,\n        value: token.value,\n      };\n\n      if (token.negated) {\n        return { type: 'not', operand: filterExpr };\n      }\n\n      return filterExpr;\n    }\n\n    if (token.type === 'TEXT') {\n      advance();\n      return {\n        type: 'text',\n        value: token.value,\n      };\n    }\n\n    return undefined;\n  }\n\n  function parseUnaryExpression(): Expression | undefined {\n    if (peek().type === 'NOT') {\n      advance(); // Consume NOT\n\n      if (!checkDepth()) {\n        return undefined;\n      }\n\n      currentDepth++;\n      const operand = parseUnaryExpression();\n      currentDepth--;\n\n      if (!operand) {\n        parserIssues.push({\n          code: ERROR_CODES.MISSING_OPERAND_FOR_NOT,\n          message: 'NOT operator requires an operand',\n        });\n        return undefined;\n      }\n\n      return { type: 'not', operand };\n    }\n\n    return parsePrimaryExpression();\n  }\n\n  function parseAndExpression(): Expression | undefined {\n    const operands: Expression[] = [];\n\n    while (true) {\n      const next = peek();\n\n      // Stop if we hit EOF, OR operator, or closing paren\n      if (next.type === 'EOF' || next.type === 'OR' || next.type === 'RPAREN') {\n        break;\n      }\n\n      // Consume explicit AND operator\n      if (next.type === 'AND') {\n        advance();\n        continue;\n      }\n\n      const expr = parseUnaryExpression();\n      if (expr) {\n        operands.push(expr);\n      }\n    }\n\n    if (operands.length === 0) {\n      return undefined;\n    }\n\n    if (operands.length === 1) {\n      return operands[0];\n    }\n\n    return { type: 'and', operands };\n  };\n\n  function parseOrExpression(): Expression | undefined {\n    const left = parseAndExpression();\n    if (!left) {\n      return undefined;\n    }\n\n    const operands: Expression[] = [left];\n\n    while (peek().type === 'OR') {\n      advance(); // Consume OR\n      const right = parseAndExpression();\n      if (right) {\n        operands.push(right);\n      }\n    }\n\n    if (operands.length === 1) {\n      return operands[0];\n    }\n\n    return { type: 'or', operands };\n  };\n\n  const expression = parseOrExpression();\n\n  // Check for unmatched closing parentheses\n  while (peek().type === 'RPAREN') {\n    parserIssues.push({\n      message: 'Unmatched closing parenthesis',\n      code: ERROR_CODES.UNMATCHED_CLOSING_PARENTHESIS,\n    });\n    advance();\n  }\n\n  return {\n    expression: expression ?? { type: 'empty' },\n    issues: parserIssues,\n  };\n}\n"],"mappings":";AAAA,MAAa,cAAc;CACzB,qBAAqB;CACrB,4BAA4B;CAC5B,+BAA+B;CAC/B,+BAA+B;CAC/B,wBAAwB;CACxB,yBAAyB;AAC1B;;;;;;;;;;;;ACGD,SAAgB,mBAAmB,EAAE,YAAwC,EAA8B;AACzG,KACE,WAAW,SAAS,WACjB,WAAW,SAAS,UACpB,WAAW,SAAS,SAEvB,QAAO,EAAE,WAAY;AAGvB,KAAI,WAAW,SAAS,MACtB,QAAO,sBAAsB,EAAE,WAAY,EAAC;AAG9C,KAAI,WAAW,SAAS,SAAS,WAAW,SAAS,KACnD,QAAO,wBAAwB,EAAE,WAAY,EAAC;AAIhD,QAAO,EAAE,WAAY;AACtB;AAED,SAAgB,iBAAiB,EAAE,UAAsC,EAAwC;CAC/G,MAAM,qBAAqB,SAAS,IAAI,gBAAc,mBAAmB,EAAE,WAAY,EAAC,CAAC,WAAW;AAEpG,QAAO,EAAE,mBAAoB;AAC9B;AAED,SAAS,sBAAsB,EAAE,YAA2C,EAA8B;CACxG,MAAM,EAAE,YAAY,6BAA6B,GAAG,mBAAmB,EAAE,YAAY,WAAW,QAAS,EAAC;AAG1G,KAAI,4BAA4B,SAAS,MACvC,QAAO,EAAE,YAAY,4BAA4B,QAAS;AAI5D,KAAI,4BAA4B,SAAS,QACvC,QAAO,EAAE,YAAY,EAAE,MAAM,QAAS,EAAE;AAG1C,QAAO,EAAE,YAAY;EAAE,MAAM;EAAO,SAAS;CAA6B,EAAE;AAC7E;AAED,SAAS,wBAAwB,EAAE,YAA0D,EAA8B;CACzH,MAAM,EAAE,oBAAoB,GAAG,iBAAiB,EAAE,UAAU,WAAW,SAAU,EAAC;CAClF,MAAM,mBAAmB,mBAAmB,OAAO,QAAM,GAAG,SAAS,QAAQ;CAC7E,MAAM,EAAE,mBAAmB,GAAG,gBAAgB;EAAE,MAAM,WAAW;EAAM,UAAU;CAAkB,EAAC;CACpG,MAAM,EAAE,sBAAsB,GAAG,oBAAoB,EAAE,UAAU,kBAAmB,EAAC;AAErF,KAAI,qBAAqB,WAAW,EAClC,QAAO,EAAE,YAAY,EAAE,MAAM,QAAS,EAAE;AAI1C,KAAI,qBAAqB,WAAW,EAClC,QAAO,EAAE,YAAY,qBAAqB,GAAK;AAGjD,QAAO,EACL,YAAY;EACV,MAAM,WAAW;EACjB,UAAU;CACX,EACF;AACF;AAED,SAAS,gBAAgB,EAAE,MAAM,UAA0D,EAAuC;CAChI,MAAMA,oBAAkC,CAAE;AAE1C,MAAK,MAAM,WAAW,SAGpB,KAAI,QAAQ,SAAS,MACnB,kBAAkB,KAAK,GAAG,QAAQ,SAAS;MAE3C,kBAAkB,KAAK,QAAQ;AAInC,QAAO,EAAE,kBAAmB;AAC7B;AAED,SAAS,oBAAoB,EAAE,UAAsC,EAA0C;CAC7G,MAAMC,uBAAqC,CAAE;AAE7C,MAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,cAAc,qBAAqB,KAAK,cAAY,wBAAwB,UAAU,QAAQ,CAAC;AACrG,MAAI,CAAC,aACH,qBAAqB,KAAK,QAAQ;CAErC;AAED,QAAO,EAAE,qBAAsB;AAChC;AAED,SAAgB,wBAAwBC,GAAeC,GAAwB;AAC7E,KAAI,EAAE,SAAS,EAAE,KACf,QAAO;AAGT,KAAI,EAAE,SAAS,WAAW,EAAE,SAAS,QACnC,QAAO;AAGT,KAAI,EAAE,SAAS,UAAU,EAAE,SAAS,OAClC,QAAO,EAAE,UAAU,EAAE;AAGvB,KAAI,EAAE,SAAS,YAAY,EAAE,SAAS,SACpC,QAAO,EAAE,UAAU,EAAE,SAChB,EAAE,aAAa,EAAE,YACjB,EAAE,UAAU,EAAE;AAGrB,KAAI,EAAE,SAAS,SAAS,EAAE,SAAS,MACjC,QAAO,wBAAwB,EAAE,SAAS,EAAE,QAAQ;AAGtD,KAAK,EAAE,SAAS,SAAS,EAAE,SAAS,SAAW,EAAE,SAAS,QAAQ,EAAE,SAAS,MAAO;AAClF,MAAI,EAAE,SAAS,WAAW,EAAE,SAAS,OACnC,QAAO;AAGT,OAAK,IAAI,IAAI,GAAG,IAAI,EAAE,SAAS,QAAQ,IACrC,KAAI,CAAC,wBAAwB,EAAE,SAAS,IAAK,EAAE,SAAS,GAAI,CAC1D,QAAO;AAIX,SAAO;CACR;AAED,QAAO;AACR;;;;AC7HD,SAAgB,SAAS,EAAE,OAAO,WAAiD,EAAkB;CACnG,MAAMC,SAAkB,CAAE;CAC1B,MAAMC,SAAkB,CAAE;CAC1B,IAAI,MAAM;CAEV,MAAM,OAAO,MAA0B,MAAM;CAC7C,MAAM,UAAU,MAAc,MAAM,UAAU;CAE9C,MAAM,iBAAiB,MAAY;AACjC,SAAO,MAAM,MAAM,QAAQ;GACzB,MAAM,OAAO,MAAM;AACnB,OAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,KAAK,CAC3B;GAEF;EACD;CACF;CAED,MAAM,mBAAmB,MAA0B;AACjD,MAAI,MAAM,KAAK,KACb,QAAO;EAGT,SAAS;EACT,IAAI,QAAQ;EACZ,IAAI,UAAU;AAEd,SAAO,MAAM,MAAM,QAAQ;GACzB,MAAM,OAAO,MAAM;AAEnB,OAAI,CAAC,KACH;AAGF,OAAI,SAAS;IACX,SAAS;IACT,UAAU;IACV,SAAS;GACV,WAAU,SAAS,MAAM;IACxB,UAAU;IACV,SAAS;GACV,WAAU,SAAS,MAAK;IACvB,SAAS;AACT,WAAO;GACR,OAAM;IACL,SAAS;IACT,SAAS;GACV;EACF;EAED,OAAO,KAAK;GACV,MAAM,YAAY;GAClB,SAAS;EACV,EAAC;AACF,SAAO;CACR;CAED,MAAM,oBAAoB,CAAC,cAAc,UAAkB;EACzD,IAAI,QAAQ;AAEZ,SAAO,MAAM,MAAM,QAAQ;GACzB,MAAM,OAAO,MAAM;AAEnB,OAAI,CAAC,QAAQ,KAAK,KAAK,KAAK,IAAI,SAAS,OAAO,SAAS,IACvD;AAIF,OAAI,eAAe,SAAS,KAC1B;GAIF,SAAS,SAAS;EACnB;AAED,SAAO;CACR;CAED,MAAM,kBAAkB,MAAc;EACpC,gBAAgB;EAGhB,MAAM,cAAc,kBAAkB;AACtC,MAAI,gBAAgB,OAClB,QAAO;EAIT,IAAI,QAAQ;AACZ,SAAO,MAAM,MAAM,QAAQ;GACzB,MAAM,OAAO,MAAM;AAEnB,OAAI,CAAC,QAAQ,KAAK,KAAK,KAAK,IAAI,SAAS,OAAO,SAAS,IACvD;AAGF,OAAI,SAAS,MAAM;IACjB,SAAS;AACT,QAAI,MAAM,MAAM,QACd,SAAS,SAAS;GAErB,OACC,SAAS,SAAS;EAErB;AAED,SAAO,MAAM,QAAQ,QAAQ,IAAI;CAClC;CAED,MAAM,oBAAoB,CAACC,QAAyB;AAClD,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,IAC9B,KAAI,IAAI,OAAO,QAAQ,MAAM,KAAK,IAAI,IAAI,OAAO,MAC/C,QAAO;AAGX,SAAO;CACR;CAED,MAAM,cAAc,CAACC,OAAeC,YAAwC;AAE1E,MAAI,CAAC,kBAAkB,MAAM,CAC3B,QAAO;EAIT,IAAI,kBAAkB;AACtB,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAChC,KAAI,MAAM,OAAO,QAAQ,MAAM,KAAK,MAAM,IAAI,OAAO,OAAO;GAC1D,kBAAkB;AAClB;EACD;AAGH,MAAI,oBAAoB,GACtB,QAAO;EAGT,MAAM,QAAQ,MAAM,MAAM,GAAG,gBAAgB,CAAC,QAAQ,QAAQ,IAAI;EAClE,MAAM,aAAa,MAAM,MAAM,kBAAkB,EAAE;EAGnD,IAAIC,WAAqB;EACzB,IAAI,iBAAiB;AAErB,MAAI,WAAW,WAAW,KAAK,EAAE;GAC/B,WAAW;GACX,iBAAiB;EAClB,WAAU,WAAW,WAAW,KAAK,EAAE;GACtC,WAAW;GACX,iBAAiB;EAClB,WAAU,WAAW,WAAW,IAAI,EAAE;GACrC,WAAW;GACX,iBAAiB;EAClB,WAAU,WAAW,WAAW,IAAI,EAAE;GACrC,WAAW;GACX,iBAAiB;EAClB,WAAU,WAAW,WAAW,IAAI,EAAE;GACrC,WAAW;GACX,iBAAiB;EAClB;EAGD,IAAI,QAAQ,WAAW,MAAM,eAAe,CAAC,QAAQ,QAAQ,IAAI;AAGjE,MAAI,CAAC,OACH,QAAQ,iBAAiB;AAG3B,SAAO;GAAE,MAAM;GAAU;GAAO;GAAU;GAAO;EAAS;CAC3D;AAED,QAAO,MAAM,MAAM,QAAQ;AACzB,MAAI,OAAO,UAAU,WAAW;GAC9B,OAAO,KAAK;IACV,MAAM,YAAY;IAClB,SAAS,CAAC,uBAAuB,EAAE,UAAU,SAAS,CAAC;GACxD,EAAC;AACF;EACD;EAED,gBAAgB;AAEhB,MAAI,OAAO,MAAM,OACf;EAGF,MAAM,OAAO,MAAM;AAGnB,MAAI,SAAS,KAAK;GAChB,SAAS;GACT,OAAO,KAAK,EAAE,MAAM,SAAU,EAAC;AAC/B;EACD;AAED,MAAI,SAAS,KAAK;GAChB,SAAS;GACT,OAAO,KAAK,EAAE,MAAM,SAAU,EAAC;AAC/B;EACD;EAGD,MAAM,WAAW,MAAM,MAAM;AAC7B,MAAI,SAAS,OAAO,YAAY,CAAC,KAAK,KAAK,SAAS,EAAE;GACpD,SAAS;GACT,gBAAgB;GAGhB,MAAMC,gBAAc,kBAAkB;GACtC,MAAMC,UAAQD,kBAAgB,SAAYA,gBAAc,mBAAmB;GAG3E,MAAM,SAAS,YAAYC,SAAO,KAAK;AACvC,OAAI,QACF,OAAO,KAAK,OAAO;QACd;IAEL,MAAMC,kBAAgBD,QAAM,QAAQ,UAAU,KAAK;IACnD,OAAO,KAAK,EAAE,MAAM,MAAO,EAAC;IAC5B,OAAO,KAAK;KAAE,MAAM;KAAQ,OAAOC;IAAe,EAAC;GACpD;AACD;EACD;EAGD,MAAM,cAAc,kBAAkB;EACtC,MAAM,QAAQ,gBAAgB,SAAY,cAAc,kBAAkB,KAAK;AAE/E,MAAI,CAAC,OAAO;GACV,SAAS;AACT;EACD;EAGD,MAAM,aAAa,MAAM,aAAa;AACtC,MAAI,eAAe,OAAO;GACxB,OAAO,KAAK,EAAE,MAAM,MAAO,EAAC;AAC5B;EACD;AAED,MAAI,eAAe,MAAM;GACvB,OAAO,KAAK,EAAE,MAAM,KAAM,EAAC;AAC3B;EACD;AAED,MAAI,eAAe,OAAO;GACxB,OAAO,KAAK,EAAE,MAAM,MAAO,EAAC;AAC5B;EACD;AAGD,MAAI,gBAAgB,QAAW;GAC7B,MAAM,SAAS,YAAY,OAAO,MAAM;AACxC,OAAI,QAAQ;IACV,OAAO,KAAK,OAAO;AACnB;GACD;EACF;EAGD,MAAM,gBAAgB,MAAM,QAAQ,UAAU,KAAK;EACnD,OAAO,KAAK;GAAE,MAAM;GAAQ,OAAO;EAAe,EAAC;CACpD;CAED,OAAO,KAAK,EAAE,MAAM,MAAO,EAAC;AAE5B,QAAO;EAAE;EAAQ;CAAQ;AAC1B;;;;ACzRD,SAAgB,iBACd,EACE,OACA,WAAW,IACX,YAAY,KACZ,WAAW,OAMZ,EACY;CACb,MAAM,EAAE,QAAQ,QAAQ,iBAAiB,GAAG,SAAS;EAAE;EAAO;CAAW,EAAC;CAE1E,MAAM,EAAE,YAAY,QAAQ,cAAc,GAAG,gBAAgB;EAAE;EAAQ;CAAU,EAAC;CAElF,MAAM,SAAS,CAAC,GAAG,iBAAiB,GAAG,YAAa;AAEpD,KAAI,CAAC,SACH,QAAO;EACL;EACA;CACD;CAGH,MAAM,EAAE,YAAY,qBAAqB,GAAG,mBAAmB,EAAE,WAAY,EAAC;AAE9E,QAAO;EACL,YAAY;EACZ;CACD;AACF;AAED,SAAS,gBAAgB,EAAE,QAAQ,UAAiD,EAAe;CACjG,MAAMC,eAAwB,CAAE;CAEhC,IAAI,oBAAoB;CACxB,IAAI,eAAe;CAEnB,MAAM,OAAO,MAAa,OAAO,sBAAsB,EAAE,MAAM,MAAO;CACtE,MAAM,UAAU,MAAa,OAAO,wBAAwB,EAAE,MAAM,MAAO;CAE3E,MAAM,aAAa,MAAe;AAChC,MAAI,gBAAgB,UAAU;GAC5B,aAAa,KAAK;IAChB,MAAM,YAAY;IAClB,SAAS,CAAC,yBAAyB,EAAE,SAAS,SAAS,CAAC;GACzD,EAAC;AACF,UAAO;EACR;AACD,SAAO;CACR;CAGD,SAAS,yBAAiD;EACxD,MAAM,QAAQ,MAAM;AAEpB,MAAI,MAAM,SAAS,UAAU;GAC3B,SAAS;AAET,OAAI,CAAC,YAAY,CACf,QAAO;GAGT;GACA,MAAM,OAAO,mBAAmB;GAChC;AAEA,OAAI,MAAM,CAAC,SAAS,UAClB,SAAS;QAET,aAAa,KAAK;IAChB,MAAM,YAAY;IAClB,SAAS;GACV,EAAC;AAGJ,UAAO;EACR;AAED,MAAI,MAAM,SAAS,UAAU;GAC3B,SAAS;GACT,MAAMC,aAAyB;IAC7B,MAAM;IACN,OAAO,MAAM;IACb,UAAU,MAAM;IAChB,OAAO,MAAM;GACd;AAED,OAAI,MAAM,QACR,QAAO;IAAE,MAAM;IAAO,SAAS;GAAY;AAG7C,UAAO;EACR;AAED,MAAI,MAAM,SAAS,QAAQ;GACzB,SAAS;AACT,UAAO;IACL,MAAM;IACN,OAAO,MAAM;GACd;EACF;AAED,SAAO;CACR;CAED,SAAS,uBAA+C;AACtD,MAAI,MAAM,CAAC,SAAS,OAAO;GACzB,SAAS;AAET,OAAI,CAAC,YAAY,CACf,QAAO;GAGT;GACA,MAAM,UAAU,sBAAsB;GACtC;AAEA,OAAI,CAAC,SAAS;IACZ,aAAa,KAAK;KAChB,MAAM,YAAY;KAClB,SAAS;IACV,EAAC;AACF,WAAO;GACR;AAED,UAAO;IAAE,MAAM;IAAO;GAAS;EAChC;AAED,SAAO,wBAAwB;CAChC;CAED,SAAS,qBAA6C;EACpD,MAAMC,WAAyB,CAAE;AAEjC,SAAO,MAAM;GACX,MAAM,OAAO,MAAM;AAGnB,OAAI,KAAK,SAAS,SAAS,KAAK,SAAS,QAAQ,KAAK,SAAS,SAC7D;AAIF,OAAI,KAAK,SAAS,OAAO;IACvB,SAAS;AACT;GACD;GAED,MAAM,OAAO,sBAAsB;AACnC,OAAI,MACF,SAAS,KAAK,KAAK;EAEtB;AAED,MAAI,SAAS,WAAW,EACtB,QAAO;AAGT,MAAI,SAAS,WAAW,EACtB,QAAO,SAAS;AAGlB,SAAO;GAAE,MAAM;GAAO;EAAU;CACjC;CAED,SAAS,oBAA4C;EACnD,MAAM,OAAO,oBAAoB;AACjC,MAAI,CAAC,KACH,QAAO;EAGT,MAAMA,WAAyB,CAAC,IAAK;AAErC,SAAO,MAAM,CAAC,SAAS,MAAM;GAC3B,SAAS;GACT,MAAM,QAAQ,oBAAoB;AAClC,OAAI,OACF,SAAS,KAAK,MAAM;EAEvB;AAED,MAAI,SAAS,WAAW,EACtB,QAAO,SAAS;AAGlB,SAAO;GAAE,MAAM;GAAM;EAAU;CAChC;CAED,MAAM,aAAa,mBAAmB;AAGtC,QAAO,MAAM,CAAC,SAAS,UAAU;EAC/B,aAAa,KAAK;GAChB,SAAS;GACT,MAAM,YAAY;EACnB,EAAC;EACF,SAAS;CACV;AAED,QAAO;EACL,YAAY,cAAc,EAAE,MAAM,QAAS;EAC3C,QAAQ;CACT;AACF"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@papra/search-parser",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Search query parser library",
+  "author": "Corentin Thomasset <corentinth@proton.me> (https://corentin.tech)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/papra-hq/papra",
+    "directory": "packages/search-parser"
+  },
+  "bugs": {
+    "url": "https://github.com/papra-hq/papra/issues"
+  },
+  "keywords": [
+    "papra",
+    "search",
+    "parser",
+    "query",
+    "filter",
+    "operator"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@antfu/eslint-config": "^6.2.0",
+    "eslint": "^9.39.1",
+    "tsdown": "^0.13.4",
+    "typescript": "^5.9.3",
+    "vitest": "4.0.3"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "dev": "pnpm build:watch"
+  }
+}