@dxos/echo-query 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,641 @@
+import { LRParser } from "@lezer/lr";
+import { Filter } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/parser/gen/query.ts
+var spec_Identifier = {
+	__proto__: null,
+	type: 26,
+	NOT: 86,
+	not: 86,
+	"!": 86,
+	AND: 88,
+	and: 88,
+	OR: 90,
+	or: 90
+};
+var parser = LRParser.deserialize({
+	version: 14,
+	states: "(jOVQPOOOnQPO'#ClOOQO'#Cd'#CdOOQO'#Cf'#CfOyQPO'#ChO!OQPO'#CrO!WQPO'#CkOOQO'#Cc'#CcOOQO'#Cz'#CzOOQO'#DW'#DWOVQPO'#DWQ!]QPOOOVQPO'#DWO!mQPO,58xO!rQPO'#DQO!wQPO,59WO#PQPO,59SO#UQPO'#CtOOQO,59^,59^O#ZQPO,59^O#cQQO,59VO#wQPO,59rOOQO'#C{'#C{OOQO'#C|'#C|OOQO'#C}'#C}OVQPO,59rOVQPO,59rOVQPO,59rO$rQPO,59rOVQPO1G.dOOQO,59l,59lOOQO-E7O-E7OOOQO1G.n1G.nO#cQQO,59`O%VQPO'#DRO%[QPO1G.xOOQO1G.x1G.xO%dQQO'#CwOOQO'#Cn'#CnOOQO1G.q1G.qO%kQPO1G/^O&RQPO1G/^O&iQPO1G/^OOQO1G/^1G/^O'PQPO7+$OOOQO1G.z1G.zOOQO,59m,59mOOQO-E7P-E7POOQO7+$d7+$dOOQO,59c,59cO'dQPO,59cOOQO<<Gj<<GjO#cQQO'#DSO'lQPO1G.}OOQO1G.}1G.}OOQO,59n,59nOOQO-E7Q-E7QOOQO7+$i7+$i",
+	stateData: "'t~OyOS~ORPOT[OXQOZRO]SOgTO{WO~OS]Oa^O^`X~O^`O~ORaOjbO~O^dO~OrhOshO|fO}gO~PVOTmO~ORnO~Oa^O^`a~ORpO~O^qO~OirOjtO~OZvOcvOdvOevOgTOluO~O{WORzaTzaXzaZza]zagzarzaszawza|za}zaUza~OU{OrhOshO|fO}gO~PVORaO~OirOj!QO~Om!RO~P#cOrzisziwzi|zi}ziUzi~PVO|fOrzisziwzi}ziUzi~PVO|fO}gOrzisziwziUzi~PVOU!TOrhOshO|fO}gO~PVOi!UOm!WO~Oi!UOm!ZO~O",
+	goto: "%h{PP|PPPP|!]P!]P!]PP!]!lP!{PPP#XP#nPP#hPP#t$U$]$cPP$h$n$tPPP$zkXOYZ[ijklmxyz|kVOYZ[ijklmxyz|kUOYZ[ijklmxyz|QwdQ}qQ!SuR!X!UjVOYZ[ijklmxyz|Xvdqu!UQcTR!OrmYOYZ[eijklmxyz|ZiZlyz|XjZlz|VkZl|Q_PRo_QscR!PsQ!V!SR!Y!VQZO`eYZelxyz|Ql[QxiQyjQzkR|m",
+	nodeNames: "⚠ Query Assignment Identifier = ( ) Filter TagFilter Tag TextFilter String TypeFilter TypeKeyword : PropertyFilter PropertyPath . Value Number Boolean Null ObjectLiteral { ObjectProperty , } ArrayLiteral [ ] Not And Or Relation ArrowRight ArrowLeft",
+	maxTerm: 45,
+	skippedNodes: [0],
+	repeatNodeCount: 3,
+	tokenData: "3P~RsX^#`pq#`rs$Tst%qwx&ixy(Qyz(V|}([}!O(a!O!P*Q!Q![(j![!]*V!^!_*[!_!`*g!c!}*l!}#O+W#P#Q+]#R#S*l#T#Y*l#Y#Z+b#Z#b*l#b#c.q#c#h*l#h#i1c#i#o*l#o#p2u#q#r2z#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~#eYy~X^#`pq#`#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~$WVOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k<%lO$T~$rOZ~~$uRO;'S$T;'S;=`%O;=`O$T~%RWOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k;=`<%l$T<%lO$T~%nP;=`<%l$T~%tT}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&YTX~}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&lVOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z<%lO&i~'URO;'S&i;'S;=`'_;=`O&i~'bWOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z;=`<%l&i<%lO&i~'}P;=`<%l&i~(VOT~~([OU~~(aOi~~(dQ!Q![(j!`!a){~(oSc~!O!P({!Q![(j!g!h)a#X#Y)a~)OP!Q![)R~)WRc~!Q![)R!g!h)a#X#Y)a~)dR{|)m}!O)m!Q![)s~)pP!Q![)s~)xPc~!Q![)s~*QOr~~*VOa~~*[O^~~*_P}!O*b~*gOs~~*lOS~P*qVRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*l~+]Ol~~+bOm~R+gWRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#U,P#U#o*lR,UXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a,q#a#o*lR,vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#g*l#g#h-c#h#o*lR-hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#X*l#X#Y.T#Y#o*lR.[VdQRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR.vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j/c#j#o*lR/hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0T#a#o*lR0YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0u#a#o*lR0|VRPeQ}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR1hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#f*l#f#g2T#g#o*lR2YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j-c#j#o*l~2zOg~~3POj~",
+	tokenizers: [0, 1],
+	topRules: { "Query": [0, 1] },
+	specialized: [{
+		term: 3,
+		get: (value) => spec_Identifier[value] || -1
+	}],
+	tokenPrec: 0
+});
+//#endregion
+//#region src/parser/gen/query.terms.ts
+var query_terms_exports = /* @__PURE__ */ __exportAll({
+	And: () => 31,
+	ArrayLiteral: () => 27,
+	ArrowLeft: () => 35,
+	ArrowRight: () => 34,
+	Assignment: () => 2,
+	Boolean: () => 20,
+	Filter: () => 7,
+	Identifier: () => 3,
+	Not: () => 30,
+	Null: () => 21,
+	Number: () => 19,
+	ObjectLiteral: () => 22,
+	ObjectProperty: () => 24,
+	Or: () => 32,
+	PropertyFilter: () => 15,
+	PropertyPath: () => 16,
+	Query: () => 1,
+	Relation: () => 33,
+	String: () => 11,
+	Tag: () => 9,
+	TagFilter: () => 8,
+	TextFilter: () => 10,
+	TypeFilter: () => 12,
+	TypeKeyword: () => 13,
+	Value: () => 18
+});
+//#endregion
+//#region src/parser/gen/index.ts
+var QueryDSL;
+(function(_QueryDSL) {
+	_QueryDSL.Parser = parser;
+	_QueryDSL.Node = query_terms_exports;
+	_QueryDSL.Tokens = [
+		"type:",
+		"AND",
+		"OR",
+		"NOT"
+	];
+})(QueryDSL || (QueryDSL = {}));
+//#endregion
+//#region src/parser/query-builder.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo-query/src/parser/query-builder.ts";
+/**
+* Stateless query builder that parses DSL trees into filters.
+*
+* NOTE: QueryBuilder was largely developed using Claude Sonnet 4.5 (in Windsurf)..
+* To modify the functionality, create a minimal breaking test and direct the LLM to fix either the grammar or builder.
+*/
+var QueryBuilder = class {
+	_tags;
+	_parser = QueryDSL.Parser.configure({ strict: true });
+	constructor(_tags) {
+		this._tags = _tags;
+	}
+	/**
+	* Check valid input.
+	*/
+	validate(input) {
+		try {
+			return this._parser.parse(normalizeInput(input)).cursor().node.name === "Query";
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Build a query from the input string.
+	*/
+	build(input) {
+		try {
+			const normalized = normalizeInput(input);
+			const tree = this._parser.parse(normalized);
+			return this.buildQuery(tree, normalized);
+		} catch {
+			return {};
+		}
+	}
+	/**
+	* Build a query from a parsed DSL tree.
+	*/
+	buildQuery(tree, input) {
+		const cursor = tree.cursor();
+		if (cursor.node.name !== "Query") return {};
+		const children = [];
+		if (cursor.firstChild()) {
+			do
+				children.push({
+					name: cursor.node.name,
+					from: cursor.from,
+					to: cursor.to
+				});
+			while (cursor.nextSibling());
+			cursor.parent();
+		}
+		if (children.some((child) => child.name === "Assignment")) return this._parseAssignment(cursor, input);
+		const hasOperator = children.some((child) => child.name === "And" || child.name === "Or");
+		const hasMultipleExpressions = children.filter((child) => child.name === "Filter" || child.name === "Not" || child.name === "(").length > 1;
+		if (hasOperator || hasMultipleExpressions) return { filter: this._parseBinaryExpression(cursor, input) };
+		if (!cursor.firstChild()) return { filter: Filter.nothing() };
+		return { filter: this._parseExpression(cursor, input) };
+	}
+	/**
+	* Parse an assignment node.
+	*/
+	_parseAssignment(cursor, input) {
+		if (!cursor.firstChild()) return {};
+		let name;
+		let filter;
+		do
+			if (cursor.node.name === "Assignment") {
+				const assignmentText = this._getNodeText(cursor, input);
+				if (cursor.firstChild()) {
+					name = this._getNodeText(cursor, input);
+					const openParenIndex = assignmentText.indexOf("(");
+					const closeParenIndex = assignmentText.lastIndexOf(")");
+					if (openParenIndex !== -1 && closeParenIndex !== -1 && closeParenIndex > openParenIndex) {
+						const subInput = assignmentText.slice(openParenIndex + 1, closeParenIndex).trim();
+						const subTree = this._parser.parse(subInput);
+						filter = this.buildQuery(subTree, subInput).filter;
+					}
+					cursor.parent();
+				}
+				break;
+			}
+		while (cursor.nextSibling());
+		cursor.parent();
+		return {
+			filter,
+			name
+		};
+	}
+	/**
+	* Parse an expression node.
+	*/
+	_parseExpression(cursor, input) {
+		switch (cursor.node.name) {
+			case "Filter": return this._parseFilter(cursor, input);
+			case "Not": {
+				cursor.nextSibling();
+				const notFilter = this._parseExpression(cursor, input);
+				return notFilter ? Filter.not(notFilter) : void 0;
+			}
+			case "And":
+			case "Or":
+				cursor.parent();
+				return this._parseBinaryExpression(cursor, input);
+			case "(": {
+				cursor.nextSibling();
+				const parenFilter = this._parseExpression(cursor, input);
+				cursor.nextSibling();
+				return parenFilter;
+			}
+			default: {
+				const savedPos = cursor.from;
+				if (cursor.firstChild()) {
+					let hasOperator = false;
+					let expressionCount = 0;
+					do {
+						if (cursor.node.name === "And" || cursor.node.name === "Or") {
+							hasOperator = true;
+							break;
+						}
+						if (cursor.node.name === "Filter" || cursor.node.name === "Not" || cursor.node.name === "(") expressionCount++;
+					} while (cursor.nextSibling());
+					hasOperator = hasOperator || expressionCount > 1;
+					cursor.parent();
+					cursor.firstChild();
+					while (cursor.from !== savedPos && cursor.nextSibling());
+					if (hasOperator) {
+						cursor.parent();
+						return this._parseBinaryExpression(cursor, input);
+					} else {
+						const result = this._parseExpression(cursor, input);
+						cursor.parent();
+						return result;
+					}
+				}
+				return Filter.nothing();
+			}
+		}
+	}
+	/**
+	* Parse a binary expression (AND/OR).
+	*/
+	_parseBinaryExpression(cursor, input) {
+		const filters = [];
+		let operator = null;
+		if (cursor.firstChild()) {
+			do {
+				const nodeName = cursor.node.name;
+				if (nodeName === "And" || nodeName === "Or") operator = nodeName.toLowerCase();
+				else if (nodeName === "(") {
+					const savedPos = cursor.from;
+					cursor.nextSibling();
+					let hasBinaryOp = false;
+					do
+						if (cursor.node.name === "And" || cursor.node.name === "Or") {
+							hasBinaryOp = true;
+							break;
+						}
+					while (cursor.nextSibling() && cursor.node.name !== ")");
+					cursor.parent();
+					cursor.firstChild();
+					while (cursor.from !== savedPos && cursor.nextSibling());
+					cursor.nextSibling();
+					if (hasBinaryOp) {
+						let depth = 1;
+						const exprStart = cursor.from;
+						let exprEnd = cursor.to;
+						while (cursor.nextSibling() && depth > 0) if (cursor.node.name === "(") depth++;
+						else if (cursor.node.name === ")") {
+							depth--;
+							if (depth === 0) exprEnd = cursor.from;
+						}
+						const subInput = input.slice(exprStart, exprEnd);
+						const subTree = this._parser.parse(subInput);
+						const subResult = this.buildQuery(subTree, subInput);
+						if (subResult.filter) filters.push(subResult.filter);
+					} else {
+						const subFilter = this._parseExpression(cursor, input);
+						if (subFilter) filters.push(subFilter);
+						while (cursor.nextSibling() && cursor.node.name !== ")");
+					}
+				} else if (nodeName !== ")") {
+					const subFilter = this._parseExpression(cursor, input);
+					if (subFilter) filters.push(subFilter);
+				}
+			} while (cursor.nextSibling());
+			cursor.parent();
+		}
+		if (filters.length === 0) return Filter.nothing();
+		if (filters.length === 1) return filters[0];
+		return operator === "or" ? Filter.or(...filters) : Filter.and(...filters);
+	}
+	/**
+	* Parse a Filter node.
+	*/
+	_parseFilter(cursor, input) {
+		if (!cursor.firstChild()) return Filter.nothing();
+		let result = void 0;
+		switch (cursor.node.name) {
+			case "TagFilter":
+				if (this._tags) result = this._parseTagFilter(cursor, input);
+				break;
+			case "TextFilter":
+				result = this._parseTextFilter(cursor, input);
+				break;
+			case "TypeFilter":
+				result = this._parseTypeFilter(cursor, input);
+				break;
+			case "ObjectLiteral":
+				result = this._parseObjectLiteral(cursor, input);
+				break;
+			case "PropertyFilter":
+				result = this._parsePropertyFilter(cursor, input);
+				break;
+			default: result = Filter.nothing();
+		}
+		cursor.parent();
+		return result;
+	}
+	/**
+	* Parse a TypeFilter node (type:typename).
+	*/
+	_parseTypeFilter(cursor, input) {
+		cursor.firstChild();
+		cursor.nextSibling();
+		cursor.nextSibling();
+		const typename = this._getNodeText(cursor, input);
+		cursor.parent();
+		const uri = /^[a-z][a-z0-9+.-]*:/i.test(typename) ? typename : `dxn:${typename}`;
+		return Filter.type(uri);
+	}
+	/**
+	* Parse a TextFilter node (quoted string).
+	*/
+	_parseTextFilter(cursor, input) {
+		cursor.firstChild();
+		const text = this._getNodeText(cursor, input);
+		cursor.parent();
+		return Filter.text(unescapeStringLiteral(text.slice(1, -1)));
+	}
+	/**
+	* Parse an ObjectLiteral node.
+	*/
+	_parseObjectLiteral(cursor, input) {
+		const props = {};
+		if (cursor.firstChild()) {
+			do
+				if (cursor.node.name === "ObjectProperty") {
+					const { key, value } = this._parseObjectProperty(cursor, input);
+					if (key) props[key] = Filter.eq(value);
+				}
+			while (cursor.nextSibling());
+			cursor.parent();
+		}
+		return Filter.props(props);
+	}
+	/**
+	* Parse an ObjectProperty node.
+	*/
+	_parseObjectProperty(cursor, input) {
+		let key = null;
+		let value = null;
+		if (cursor.firstChild()) {
+			if (cursor.node.name === "Identifier") key = this._getNodeText(cursor, input);
+			cursor.nextSibling();
+			cursor.nextSibling();
+			if (cursor.node.name === "Value" && cursor.firstChild()) {
+				value = this._parseValue(cursor, input);
+				cursor.parent();
+			}
+			cursor.parent();
+		}
+		return {
+			key,
+			value
+		};
+	}
+	/**
+	* Parse a PropertyFilter node (property:value).
+	*/
+	_parsePropertyFilter(cursor, input) {
+		let path = null;
+		let value = null;
+		if (cursor.firstChild()) {
+			if (cursor.node.name === "PropertyPath") path = this._parsePropertyPath(cursor, input);
+			cursor.nextSibling();
+			cursor.nextSibling();
+			if (cursor.node.name === "Value" && cursor.firstChild()) {
+				value = this._parseValue(cursor, input);
+				cursor.parent();
+			}
+			cursor.parent();
+		}
+		if (!path) return Filter.nothing();
+		return Filter.props({ [path]: value });
+	}
+	/**
+	* Parse a PropertyPath node (supports dot notation).
+	*/
+	_parsePropertyPath(cursor, input) {
+		const parts = [];
+		if (cursor.firstChild()) {
+			do
+				if (cursor.node.name === "Identifier") parts.push(this._getNodeText(cursor, input));
+			while (cursor.nextSibling());
+			cursor.parent();
+		}
+		return parts.join(".");
+	}
+	/**
+	* Parse a TagFilter node (#tag).
+	*/
+	_parseTagFilter(cursor, input) {
+		invariant(this._tags, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 476,
+			S: this,
+			A: ["this._tags", ""]
+		});
+		const str = this._getNodeText(cursor, input).slice(1).toLowerCase();
+		const [key] = Object.entries(this._tags).find(([, value]) => value.label.toLowerCase() === str) ?? [];
+		return key ? Filter.tag(key) : void 0;
+	}
+	/**
+	* Parse a Value node.
+	*/
+	_parseValue(cursor, input) {
+		switch (cursor.node.name) {
+			case "String": return unescapeStringLiteral(this._getNodeText(cursor, input).slice(1, -1));
+			case "Number": return Number(this._getNodeText(cursor, input));
+			case "Boolean": return this._getNodeText(cursor, input) === "true";
+			case "Null": return null;
+			case "ObjectLiteral": {
+				const props = {};
+				if (cursor.firstChild()) {
+					do
+						if (cursor.node.name === "ObjectProperty") {
+							const { key, value } = this._parseObjectProperty(cursor, input);
+							if (key) props[key] = value;
+						}
+					while (cursor.nextSibling());
+					cursor.parent();
+				}
+				return props;
+			}
+			case "ArrayLiteral": {
+				const array = [];
+				if (cursor.firstChild()) {
+					do
+						if (cursor.node.name === "Value" && cursor.firstChild()) {
+							array.push(this._parseValue(cursor, input));
+							cursor.parent();
+						}
+					while (cursor.nextSibling());
+					cursor.parent();
+				}
+				return array;
+			}
+			default: return null;
+		}
+	}
+	/**
+	* Get the text content of the current node.
+	*/
+	_getNodeText(cursor, input) {
+		return input.slice(cursor.from, cursor.to);
+	}
+};
+var KEYWORDS = /* @__PURE__ */ new Set([
+	"AND",
+	"OR",
+	"NOT"
+]);
+var VALUE_LITERALS = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null"
+]);
+var SPECIAL_CHARS = /[\s(){}\[\],"']/;
+var PROPERTY_KEY = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;
+var NUMBER_LITERAL = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var URL_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"ftp",
+	"ftps",
+	"file",
+	"mailto",
+	"tel",
+	"sms",
+	"data",
+	"javascript",
+	"ws",
+	"wss",
+	"ssh",
+	"git"
+]);
+/**
+* Normalize raw user input into a form the lezer grammar can parse.
+* - Bare text fragments (e.g. `foo`) are wrapped in quotes so they parse as TextFilter.
+* - Property values that aren't already quoted/numeric/boolean (e.g. `from:rich@dxos.org`) are quoted.
+* - Tags, type filters, operators, parens, braces, quoted strings, and assignments pass through unchanged.
+*/
+var normalizeInput = (input) => {
+	const out = [];
+	let pos = 0;
+	while (pos < input.length) {
+		const currentChar = input[pos];
+		if (/\s/.test(currentChar)) {
+			out.push(currentChar);
+			pos++;
+			continue;
+		}
+		const prevChar = pos > 0 ? input[pos - 1] : "";
+		if (currentChar === "\"" || currentChar === "'" && (pos === 0 || !/[a-zA-Z0-9_]/.test(prevChar))) {
+			const quoteChar = currentChar;
+			let scanIndex = pos + 1;
+			while (scanIndex < input.length && input[scanIndex] !== quoteChar) if (input[scanIndex] === "\\" && scanIndex + 1 < input.length) scanIndex += 2;
+			else scanIndex++;
+			out.push(input.slice(pos, Math.min(scanIndex + 1, input.length)));
+			pos = scanIndex + 1;
+			continue;
+		}
+		if (currentChar === "{" || currentChar === "[") {
+			const closeChar = currentChar === "{" ? "}" : "]";
+			let depth = 1;
+			let scanIndex = pos + 1;
+			while (scanIndex < input.length && depth > 0) {
+				const innerChar = input[scanIndex];
+				if (innerChar === "\"" || innerChar === "'") {
+					const quoteChar = innerChar;
+					scanIndex++;
+					while (scanIndex < input.length && input[scanIndex] !== quoteChar) if (input[scanIndex] === "\\" && scanIndex + 1 < input.length) scanIndex += 2;
+					else scanIndex++;
+					scanIndex++;
+				} else if (innerChar === currentChar) {
+					depth++;
+					scanIndex++;
+				} else if (innerChar === closeChar) {
+					depth--;
+					scanIndex++;
+				} else scanIndex++;
+			}
+			out.push(input.slice(pos, scanIndex));
+			pos = scanIndex;
+			continue;
+		}
+		if (currentChar === "(" || currentChar === ")" || currentChar === "=" || currentChar === "," || currentChar === "}" || currentChar === "]") {
+			out.push(currentChar);
+			pos++;
+			continue;
+		}
+		if (currentChar === "-" && input[pos + 1] === ">" || currentChar === "<" && input[pos + 1] === "-") {
+			out.push(input.slice(pos, pos + 2));
+			pos += 2;
+			continue;
+		}
+		if (currentChar === "!") {
+			out.push(currentChar);
+			pos++;
+			continue;
+		}
+		if (currentChar === "#") {
+			let scanIndex = pos + 1;
+			while (scanIndex < input.length && /[a-zA-Z0-9_-]/.test(input[scanIndex])) scanIndex++;
+			out.push(input.slice(pos, scanIndex));
+			pos = scanIndex;
+			continue;
+		}
+		let scanIndex = pos;
+		while (scanIndex < input.length) {
+			const innerChar = input[scanIndex];
+			if (innerChar === "\"") break;
+			if (innerChar === "'" && scanIndex > pos && !/[a-zA-Z0-9_]/.test(input[scanIndex - 1])) break;
+			if (innerChar === "'" && scanIndex === pos) break;
+			if (innerChar !== "'" && SPECIAL_CHARS.test(innerChar)) break;
+			if (innerChar === "-" && input[scanIndex + 1] === ">") break;
+			if (innerChar === "<" && input[scanIndex + 1] === "-") break;
+			scanIndex++;
+		}
+		if (scanIndex === pos) {
+			out.push(currentChar);
+			pos++;
+			continue;
+		}
+		const token = input.slice(pos, scanIndex);
+		pos = scanIndex;
+		if (KEYWORDS.has(token.toUpperCase())) {
+			out.push(token);
+			continue;
+		}
+		const colonIdx = token.indexOf(":");
+		if (colonIdx > 0) {
+			const key = token.slice(0, colonIdx);
+			const rest = token.slice(colonIdx + 1);
+			if (key === "type") {
+				out.push(token);
+				continue;
+			}
+			if (!(URL_SCHEMES.has(key.toLowerCase()) || rest.startsWith("//")) && PROPERTY_KEY.test(key)) {
+				if (rest.length === 0) {
+					out.push(token);
+					continue;
+				}
+				const firstValueChar = rest[0];
+				if (firstValueChar === "\"" || firstValueChar === "'") {
+					out.push(token);
+					continue;
+				}
+				if (firstValueChar === "{" || firstValueChar === "[") {
+					out.push(token);
+					continue;
+				}
+				if (VALUE_LITERALS.has(rest) || NUMBER_LITERAL.test(rest)) {
+					out.push(token);
+					continue;
+				}
+				out.push(`${key}:"${escapeStringLiteral(rest)}"`);
+				continue;
+			}
+		}
+		if (PROPERTY_KEY.test(token)) {
+			let lookahead = pos;
+			while (lookahead < input.length && /\s/.test(input[lookahead])) lookahead++;
+			if (input[lookahead] === "=") {
+				out.push(token);
+				continue;
+			}
+		}
+		out.push(`"${escapeStringLiteral(token)}"`);
+	}
+	return out.join("");
+};
+/** Escape a raw value into a string literal body (without surrounding quotes). */
+var escapeStringLiteral = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+/** Decode `\\` and `\"` escapes inside a string literal body. */
+var unescapeStringLiteral = (literalBody) => {
+	let out = "";
+	for (let i = 0; i < literalBody.length; i++) {
+		const ch = literalBody[i];
+		if (ch === "\\" && i + 1 < literalBody.length) {
+			out += literalBody[i + 1];
+			i++;
+		} else out += ch;
+	}
+	return out;
+};
+//#endregion
+export { QueryBuilder, QueryDSL, normalizeInput };
+
+//# sourceMappingURL=index.mjs.map