@plitzi/sdk-shared 0.37.1 → 0.37.3

package/dist/helpers/keys.mjs

@@ -0,0 +1,91 @@
+//#region src/helpers/keys.ts
+var e = "onKey", t = [
+	"ctrl",
+	"alt",
+	"shift",
+	"meta"
+], n = {
+	ctrl: "ctrl",
+	control: "ctrl",
+	alt: "alt",
+	option: "alt",
+	shift: "shift",
+	meta: "meta",
+	cmd: "meta",
+	command: "meta",
+	mod: "mod"
+}, r = {
+	esc: "escape",
+	space: "space",
+	spacebar: "space",
+	plus: "+",
+	minus: "-",
+	up: "arrowup",
+	down: "arrowdown",
+	left: "arrowleft",
+	right: "arrowright",
+	del: "delete",
+	return: "enter"
+}, i = /* @__PURE__ */ new Set([
+	"escape",
+	"enter",
+	"tab",
+	"space",
+	"backspace",
+	"delete",
+	"insert",
+	"arrowup",
+	"arrowdown",
+	"arrowleft",
+	"arrowright",
+	"home",
+	"end",
+	"pageup",
+	"pagedown",
+	...Array.from({ length: 12 }, (e, t) => `f${t + 1}`)
+]), a = (e, n) => [...t.filter((t) => e.has(t)), n].join("+"), o = (e, t) => {
+	let o = e.trim().toLowerCase();
+	if (!o) return { problem: "an empty shortcut (two commas in a row, or one at the end)" };
+	let s = o.endsWith("++") ? [...o.slice(0, -2).split("+"), "+"] : o.split("+"), c = o === "+" ? ["+"] : s.filter((e) => e !== ""), l = /* @__PURE__ */ new Set(), u = [];
+	for (let e of c) {
+		if (Object.hasOwn(n, e)) {
+			let r = n[e];
+			l.add(r === "mod" ? t ? "meta" : "ctrl" : r);
+			continue;
+		}
+		u.push(Object.hasOwn(r, e) ? r[e] : e);
+	}
+	if (u.length !== 1) return { problem: `"${e.trim()}" names ${u.length ? `${u.length} keys (${u.join(", ")})` : "no key, only modifiers"}: a shortcut is modifiers and ONE key, like "shift+f"` };
+	let [d] = u;
+	return d.length !== 1 && !i.has(d) ? { problem: `"${d}" in "${e.trim()}" is not a key: use one character ("f", "?", "+") or a key's name (${[...i].slice(0, 15).join(", ")}, f1…f12)` } : { combo: a(l, d) };
+}, s = (e, t = !1) => {
+	let n = e.split(",").map((e) => o(e, t));
+	return {
+		combos: n.flatMap((e) => e.combo ? [e.combo] : []),
+		problems: n.flatMap((e) => e.problem ? [e.problem] : [])
+	};
+}, c = (e) => {
+	let t = e.ctrlKey || e.altKey || e.metaKey, n = /^(?:Key|Digit)([A-Z0-9])$/.exec(e.code), r = t && n ? n[1] : e.key, i = r === " " ? "space" : r.toLowerCase(), o = i.length === 1 && !/[a-z0-9]/.test(i), s = /* @__PURE__ */ new Set();
+	return e.ctrlKey && s.add("ctrl"), e.altKey && s.add("alt"), e.shiftKey && !o && s.add("shift"), e.metaKey && s.add("meta"), a(s, i);
+}, l = /* @__PURE__ */ new Set([
+	"a",
+	"z",
+	"y",
+	"c",
+	"x",
+	"v"
+]), u = /* @__PURE__ */ new Set([
+	"arrowleft",
+	"arrowright",
+	"arrowup",
+	"arrowdown",
+	"home",
+	"end",
+	"backspace",
+	"delete"
+]), d = (e) => {
+	let t = e.split("+"), n = e.endsWith("++") ? "+" : t[t.length - 1];
+	return u.has(n) || l.has(n) && (e.includes("ctrl+") || e.includes("meta+"));
+};
+//#endregion
+export { e as KEY_TRIGGER, d as isFieldEditing, c as keyPressCombo, s as parseKeys };

package/dist/helpers/twigWrapper/AST.d.ts

@@ -47,7 +47,7 @@ export type ContinueNode = {
 export type Expression = LiteralNode | ArrayLiteralNode | ObjectLiteralNode | RangeNode | PathNode | IndexNode | FunctionNode | FilterExpression | ConcatNode | UnaryNode | BinaryNode | DefaultNode | TernaryNode | ArrowFunctionNode;
 export type LiteralNode = {
     readonly type: 'literal';
-    readonly value: string | number | boolean;
+    readonly value: string | number | boolean | null;
 };
 export type ArrayLiteralNode = {
     readonly type: 'array';
@@ -117,7 +117,7 @@ export type DefaultNode = {
 export type TernaryNode = {
     readonly type: 'ternary';
     readonly condition: Expression;
-    readonly trueExpr: Expression;
+    readonly trueExpr: Expression | null;
     readonly falseExpr: Expression;
 };
 export type ArrowFunctionNode = {

package/dist/helpers/twigWrapper/Evaluator/Evaluator.d.ts

@@ -1,7 +1,17 @@
-import { ASTNode } from '../AST';
+import { ASTNode, Expression } from '../AST';
 export type EvalResult = {
     readonly output: string;
     readonly variables: Record<string, unknown>;
     readonly hasSet: boolean;
 };
-export declare const evaluate: (nodes: readonly ASTNode[], context: Record<string, unknown>, keepEmptyTokens?: boolean) => EvalResult;
+/**
+ * Renders `nodes` against `context`.
+ *
+ * `jsonStrings` is for a template the author wrote as a JSON document — `{ "city": "{{ values.city }}" }`: a value
+ * printed inside one of its string literals is escaped for it, so a city typed with a quote or on two lines is still
+ * that document, not text the reader has to give up on. A value printed anywhere else is printed as always: it IS the
+ * JSON value there (`"seen": {{ count }}`).
+ */
+export declare const evaluate: (nodes: readonly ASTNode[], context: Record<string, unknown>, keepEmptyTokens?: boolean, jsonStrings?: boolean) => EvalResult;
+/** One expression's value, as it is — not rendered to text. What `processTwigValue` answers a `{{ expr }}` with. */
+export declare const evaluateExpression: (expression: Expression, context: Record<string, unknown>) => unknown;

package/dist/helpers/twigWrapper/Evaluator/Evaluator.mjs

@@ -1,21 +1,33 @@
 import { isTruthy as e, resolveCollection as t, resolveObjectEntries as n, valueIn as r } from "./helpers.mjs";
 import { ARROW_PARAMS as i, filters as a, isRawMarker as o, unwrapRaw as s } from "../filters/filters.mjs";
+import { serializeValue as c } from "../processTwig/helpers.mjs";
 //#region src/helpers/twigWrapper/Evaluator/Evaluator.ts
-var c = [], l = (e, t, n = !1) => {
-	let r = new u(t, n);
+var l = {
+	defined: (e) => e !== void 0,
+	null: (e) => e == null,
+	none: (e) => e == null,
+	empty: (e) => e == null || e === "" || e === !1 || Array.isArray(e) && e.length === 0 || typeof e == "object" && !Array.isArray(e) && Object.keys(e).length === 0,
+	iterable: (e) => Array.isArray(e) || typeof e == "object" && !!e,
+	even: (e) => typeof e == "number" && e % 2 == 0,
+	odd: (e) => typeof e == "number" && Math.abs(e % 2) === 1
+}, u = (e) => e.type === "path" || e.type === "filter" && u(e.subject), d = (e, t) => t == null || t === "" && u(e), f = (e) => e.type === "path" && e.segments.length === 1 ? e.segments[0] : e.type === "literal" && e.value === null ? "null" : void 0, p = [], m = (e, t, n = !1, r = !1) => {
+	let i = new g(t, n, r);
 	return {
-		output: r.evalNodes(e),
-		variables: r.variables,
-		hasSet: r.hasSet
+		output: i.evalNodes(e),
+		variables: i.variables,
+		hasSet: i.hasSet
 	};
-}, u = class l {
+}, h = (e, t) => new g(t).evalExpression(e), g = class u {
 	variables;
 	keepEmptyTokens;
+	jsonStrings;
+	inString = !1;
+	escaping = !1;
 	breakFlag = !1;
 	continueFlag = !1;
 	hasSet = !1;
-	constructor(e, t = !1) {
-		this.variables = { ...e }, this.keepEmptyTokens = t;
+	constructor(e, t = !1, n = !1) {
+		this.variables = { ...e }, this.keepEmptyTokens = t, this.jsonStrings = n;
 	}
 	evalNodes(e) {
 		let t = e.length;
@@ -27,8 +39,8 @@ var c = [], l = (e, t, n = !1) => {
 	}
 	evalNode(e) {
 		switch (e.type) {
-			case "text": return e.value;
-			case "variable": return this.evalVariable(e);
+			case "text": return this.jsonStrings && this.followQuotes(e.value), e.value;
+			case "variable": return this.jsonStrings && this.inString ? JSON.stringify(this.evalVariable(e)).slice(1, -1) : this.evalVariable(e);
 			case "if": return this.evalIf(e);
 			case "for": return this.evalFor(e);
 			case "set": return this.evalSet(e);
@@ -39,7 +51,13 @@ var c = [], l = (e, t, n = !1) => {
 	}
 	evalVariable(e) {
 		let t = this.evalExpression(e.expression);
-		return this.keepEmptyTokens && (t == null || t === "") ? e.source : o(t) ? String(s(t)) : typeof t == "function" ? "" : t != null && typeof t != "object" ? String(t) : e.raw ? t == null ? "" : String(t) : typeof t == "object" && t ? JSON.stringify(t) : "";
+		return this.keepEmptyTokens && d(e.expression, t) ? e.source : o(t) ? String(s(t)) : typeof t == "function" ? "" : t != null && typeof t != "object" ? String(t) : e.raw ? t == null ? "" : String(t) : typeof t == "object" && t ? JSON.stringify(t) : "";
+	}
+	followQuotes(e) {
+		for (let t = 0; t < e.length; t++) {
+			let n = e[t];
+			this.escaping ? this.escaping = !1 : this.inString && n === "\\" ? this.escaping = !0 : n === "\"" && (this.inString = !this.inString);
+		}
 	}
 	evalIf(t) {
 		if (e(this.evalExpression(t.condition))) return this.evalNodes(t.body);
@@ -94,7 +112,7 @@ var c = [], l = (e, t, n = !1) => {
 		let n = e;
 		for (let e of t) {
 			let t = a[e.name];
-			t !== void 0 && (n = t(n, e.args.length === 0 ? c : this.evalArgs(e.args)));
+			t !== void 0 && (n = t(n, e.args.length === 0 ? p : this.evalArgs(e.args)));
 		}
 		return n;
 	}
@@ -135,13 +153,16 @@ var c = [], l = (e, t, n = !1) => {
 			case "unary": return t.operator === "-" ? -Number(this.evalExpression(t.operand)) : !e(this.evalExpression(t.operand));
 			case "binary": return this.evalBinary(t.operator, t.left, t.right);
 			case "default": return this.evalExpression(t.value) ?? this.evalExpression(t.defaultExpr);
-			case "ternary": return e(this.evalExpression(t.condition)) ? this.evalExpression(t.trueExpr) : this.evalExpression(t.falseExpr);
+			case "ternary": {
+				let n = this.evalExpression(t.condition);
+				return e(n) ? t.trueExpr ? this.evalExpression(t.trueExpr) : n : this.evalExpression(t.falseExpr);
+			}
 			case "arrow": return this.createArrowFunction(t.params, t.body);
 		}
 	}
 	createArrowFunction(e, t) {
 		let n = { ...this.variables }, r = this.keepEmptyTokens, a = (...i) => {
-			let a = new l(n, r);
+			let a = new u(n, r);
 			for (let t = 0; t < e.length; t++) a.variables[e[t]] = i[t];
 			return a.evalExpression(t);
 		};
@@ -200,28 +221,45 @@ var c = [], l = (e, t, n = !1) => {
 		return a;
 	}
 	evalBinary(t, n, i) {
+		let a = f(i);
+		if ((t === "is" || t === "is not") && a !== void 0) {
+			let e = l[a];
+			if (e) {
+				let r = e(this.evalExpression(n));
+				return t === "is" ? r : !r;
+			}
+		}
 		if (t === "or") return e(this.evalExpression(n)) || e(this.evalExpression(i));
 		if (t === "and") return e(this.evalExpression(n)) && e(this.evalExpression(i));
-		let a = this.evalExpression(n), o = this.evalExpression(i), s = typeof a == "number" && typeof o == "number";
+		let o = this.evalExpression(n), s = this.evalExpression(i), u = typeof o == "number" && typeof s == "number";
 		switch (t) {
-			case "+": return s ? a + o : Number(a) + Number(o);
-			case "-": return s ? a - o : Number(a) - Number(o);
-			case "*": return s ? a * o : Number(a) * Number(o);
-			case "/": return s ? a / o : Number(a) / Number(o);
-			case "%": return s ? a % o : Number(a) % Number(o);
-			case "==": return a === o || String(a) === String(o);
-			case "!=": return a !== o && String(a) !== String(o);
-			case ">": return s ? a > o : Number(a) > Number(o);
-			case "<": return s ? a < o : Number(a) < Number(o);
-			case ">=": return s ? a >= o : Number(a) >= Number(o);
-			case "<=": return s ? a <= o : Number(a) <= Number(o);
-			case "in": return r(a, o);
-			case "not in": return !r(a, o);
-			case "is": return a === o;
-			case "is not": return a !== o;
+			case "+": return u ? o + s : Number(o) + Number(s);
+			case "-": return u ? o - s : Number(o) - Number(s);
+			case "*": return u ? o * s : Number(o) * Number(s);
+			case "/": return u ? o / s : Number(o) / Number(s);
+			case "//": return Math.floor(Number(o) / Number(s));
+			case "**": return Number(o) ** Number(s);
+			case "starts with": return typeof o == "string" && o.startsWith(c(s));
+			case "ends with": return typeof o == "string" && o.endsWith(c(s));
+			case "%": return u ? o % s : Number(o) % Number(s);
+			case "==": return o === s || String(o) === String(s);
+			case "!=": return o !== s && String(o) !== String(s);
+			case ">": return u ? o > s : Number(o) > Number(s);
+			case "<": return u ? o < s : Number(o) < Number(s);
+			case ">=": return u ? o >= s : Number(o) >= Number(s);
+			case "<=": return u ? o <= s : Number(o) <= Number(s);
+			case "in": return r(o, s);
+			case "not in": return !r(o, s);
+			case "same as": return o === s;
+			case "divisible by": {
+				let e = Number(s);
+				return e !== 0 && Number.isFinite(e) && Number(o) % e === 0;
+			}
+			case "is": return o === s;
+			case "is not": return o !== s;
 			default: return !1;
 		}
 	}
 };
 //#endregion
-export { l as evaluate };
+export { m as evaluate, h as evaluateExpression };

package/dist/helpers/twigWrapper/Evaluator/index.d.ts

@@ -1,2 +1,2 @@
-export { evaluate } from './Evaluator';
+export { evaluate, evaluateExpression } from './Evaluator';
 export type { EvalResult } from './Evaluator';

package/dist/helpers/twigWrapper/Evaluator/index.mjs

@@ -1,2 +1,2 @@
-import { evaluate as e } from "./Evaluator.mjs";
-export { e as evaluate };
+import { evaluate as e, evaluateExpression as t } from "./Evaluator.mjs";
+export { e as evaluate, t as evaluateExpression };

package/dist/helpers/twigWrapper/Parser/ExpressionParser.d.ts

@@ -1,3 +1,3 @@
 import { Expression, FilterCall } from '../AST';
-export declare const parseExpression: (expr: string) => Expression;
-export declare const parseApplyFilters: (expr: string) => FilterCall[];
+export declare const parseExpression: (expr: string, issues?: string[]) => Expression;
+export declare const parseApplyFilters: (expr: string, issues?: string[]) => FilterCall[];

package/dist/helpers/twigWrapper/Parser/ExpressionParser.mjs

@@ -1,20 +1,54 @@
 import { Char as e, isDigit as t } from "../charClass.mjs";
 import { Cursor as n } from "./Cursor.mjs";
 //#region src/helpers/twigWrapper/Parser/ExpressionParser.ts
-var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a = class extends n {
+var r = (e, t) => {
+	let n = new s(e, t), r = n.parseTernary();
+	return n.expectEnd(), r;
+}, i = (e, t) => {
+	let n = new s(e, t), r = n.parseApplyChain();
+	return n.expectEnd(), r;
+}, a = ["same as", "divisible by"], o = "`matches` is not supported: templates evaluate no regular expressions. Use `starts with`, `ends with` or `in`.", s = class extends n {
+	issues;
+	constructor(e, t) {
+		super(e), this.issues = t;
+	}
+	report(e) {
+		this.issues?.push(e);
+	}
+	expectEnd() {
+		this.skipWs(), this.eof() || this.report(`Unexpected "${this.src.slice(this.pos).trim()}" in "${this.src.trim()}"`);
+	}
+	expectChar(e, t) {
+		if (this.skipWs(), this.peek() === e) {
+			this.pos++;
+			return;
+		}
+		this.report(`Missing ${t} in "${this.src.trim()}"`);
+	}
 	parseTernary() {
 		let t = this.parseOr();
-		if (this.skipWs(), this.peek() === e.Question) {
-			this.pos++, this.skipWs();
-			let n = this.parseOr();
-			if (this.skipWs(), this.peek() === e.Colon) return this.pos++, this.skipWs(), {
-				type: "ternary",
-				condition: t,
-				trueExpr: n,
-				falseExpr: this.parseTernary()
-			};
-		}
-		return t;
+		if (this.skipWs(), this.peek() !== e.Question) return t;
+		if (this.pos++, this.skipWs(), this.peek() === e.Colon) return this.pos++, this.skipWs(), {
+			type: "ternary",
+			condition: t,
+			trueExpr: null,
+			falseExpr: this.parseTernary()
+		};
+		let n = this.parseOr();
+		return this.skipWs(), this.peek() === e.Colon ? (this.pos++, this.skipWs(), {
+			type: "ternary",
+			condition: t,
+			trueExpr: n,
+			falseExpr: this.parseTernary()
+		}) : {
+			type: "ternary",
+			condition: t,
+			trueExpr: n,
+			falseExpr: {
+				type: "literal",
+				value: ""
+			}
+		};
 	}
 	parseOr() {
 		let e = this.parseAnd();
@@ -47,9 +81,27 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 		let e = this.parseConcat();
 		for (this.skipWs(); !this.eof();) {
 			if (this.matchKeyword("is")) {
-				this.skipWs(), e = {
+				this.skipWs();
+				let t = this.matchKeyword("not");
+				this.skipWs();
+				let n = this.matchWordedTest();
+				if (n) {
+					let r = {
+						type: "binary",
+						operator: n,
+						left: e,
+						right: this.parseConcat()
+					};
+					e = t ? {
+						type: "unary",
+						operator: "not",
+						operand: r
+					} : r, this.skipWs();
+					continue;
+				}
+				e = {
 					type: "binary",
-					operator: this.matchKeyword("not") ? "is not" : "is",
+					operator: t ? "is not" : "is",
 					left: e,
 					right: this.parseConcat()
 				}, this.skipWs();
@@ -69,7 +121,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 				return this.pos = this.src.length, {
 					type: "unary",
 					operator: "not",
-					operand: r(t)
+					operand: r(t, this.issues)
 				};
 			}
 			if (this.matchKeyword("in")) {
@@ -81,7 +133,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 				}, this.skipWs();
 				continue;
 			}
-			let t = this.matchBinaryOp();
+			let t = this.matchAffixTest();
 			if (t) {
 				e = {
 					type: "binary",
@@ -91,10 +143,48 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 				}, this.skipWs();
 				continue;
 			}
+			if (this.matchKeyword("matches")) {
+				this.report(o), e = {
+					type: "binary",
+					operator: "matches",
+					left: e,
+					right: this.parseConcat()
+				}, this.skipWs();
+				continue;
+			}
+			let n = this.matchBinaryOp();
+			if (n) {
+				e = {
+					type: "binary",
+					operator: n,
+					left: e,
+					right: this.parseConcat()
+				}, this.skipWs();
+				continue;
+			}
 			break;
 		}
 		return e;
 	}
+	matchWordedTest() {
+		let e = this.pos;
+		for (let t of a) {
+			let [n, r] = t.split(" ");
+			if (this.matchKeyword(n)) {
+				if (this.skipWs(), this.matchKeyword(r)) return t;
+				this.pos = e;
+			}
+		}
+		return null;
+	}
+	matchAffixTest() {
+		let e = this.pos;
+		for (let t of ["starts", "ends"]) if (this.matchKeyword(t)) {
+			if (this.matchKeyword("with")) return t === "starts" ? "starts with" : "ends with";
+			this.pos = e;
+		}
+		return null;
+	}
 	parseConcat() {
 		let t = this.parseAdditive();
 		for (this.skipWs(); this.peek() === e.Tilde;) {
@@ -122,15 +212,27 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 		return t;
 	}
 	parseMultiplicative() {
-		let t = this.parseDefault();
+		let t = this.parsePower();
 		this.skipWs();
-		for (let n = this.peek(); n === e.Star || n === e.Slash || n === e.Percent; n = this.peek()) this.pos++, t = {
+		for (let n = this.peek(); (n === e.Star || n === e.Slash || n === e.Percent) && (n !== e.Star || this.at(1) !== e.Star); n = this.peek()) {
+			let r = n === e.Slash && this.at(1) === e.Slash;
+			this.pos += r ? 2 : 1, t = {
+				type: "binary",
+				operator: r ? "//" : n === e.Star ? "*" : n === e.Slash ? "/" : "%",
+				left: t,
+				right: this.parsePower()
+			}, this.skipWs();
+		}
+		return t;
+	}
+	parsePower() {
+		let t = this.parseDefault();
+		return this.skipWs(), this.peek() !== e.Star || this.at(1) !== e.Star ? t : (this.pos += 2, {
 			type: "binary",
-			operator: n === e.Star ? "*" : n === e.Slash ? "/" : "%",
+			operator: "**",
 			left: t,
-			right: this.parseDefault()
-		}, this.skipWs();
-		return t;
+			right: this.parsePower()
+		});
 	}
 	parseDefault() {
 		if (this.skipWs(), this.peek() === e.Minus && t(this.at(1))) return this.maybeTrailingFilters({
@@ -163,18 +265,25 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 			});
 			this.pos = t;
 			let r = this.parseTernary();
-			return this.skipWs(), this.peek() === e.RParen && this.pos++, this.maybeTrailingFilters(r);
+			return this.expectChar(e.RParen, "a closing \")\""), this.maybeTrailingFilters(this.parseAccessChain(r, null));
 		}
-		return n === e.SingleQuote || n === e.DoubleQuote ? this.maybeTrailingFilters({
+		if (n === e.SingleQuote || n === e.DoubleQuote) return this.maybeTrailingFilters({
 			type: "literal",
 			value: this.scanStringLiteral()
-		}) : t(n) ? this.maybeTrailingFilters({
+		});
+		if (t(n)) return this.maybeTrailingFilters({
 			type: "literal",
 			value: this.scanNumber()
-		}) : n === e.LBracket ? (this.pos++, this.maybeTrailingFilters({
-			type: "array",
-			elements: this.parseArgList(e.RBracket)
-		})) : n === e.LBrace ? (this.pos++, this.maybeTrailingFilters(this.parseObjectLiteral())) : this.parsePathOrFunctionOrArrow();
+		});
+		if (n === e.LBracket) {
+			this.pos++;
+			let t = {
+				type: "array",
+				elements: this.parseArgList(e.RBracket)
+			};
+			return this.maybeTrailingFilters(this.parseAccessChain(t, null));
+		}
+		return n === e.LBrace ? (this.pos++, this.maybeTrailingFilters(this.parseAccessChain(this.parseObjectLiteral(), null))) : this.parsePathOrFunctionOrArrow();
 	}
 	tryParseArrowParams() {
 		let t = this.pos, n = [];
@@ -191,7 +300,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 	}
 	parsePathOrFunctionOrArrow() {
 		let t = this.scanName();
-		if (!t) return this.pos++, {
+		if (!t) return this.report(this.eof() ? `Missing a value at the end of "${this.src.trim()}"` : `Unexpected "${this.src.slice(this.pos).trim()}" in "${this.src.trim()}"`), this.pos++, {
 			type: "literal",
 			value: ""
 		};
@@ -199,6 +308,10 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 			type: "literal",
 			value: t === "true"
 		});
+		if (t === "null" || t === "none") return this.maybeTrailingFilters({
+			type: "literal",
+			value: null
+		});
 		if (this.skipWs(), this.peek() === e.Equals && this.at(1) === e.Greater) return this.pos += 2, this.maybeTrailingFilters({
 			type: "arrow",
 			params: [t],
@@ -244,7 +357,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 			if (t !== e.LBracket) break;
 			this.pos++;
 			let n = this.parseTernary();
-			if (this.skipWs(), this.peek() === e.RBracket && this.pos++, i && n.type === "literal" && typeof n.value != "boolean") {
+			if (this.expectChar(e.RBracket, "a closing \"]\""), i && n.type === "literal" && (typeof n.value == "string" || typeof n.value == "number")) {
 				i.push(String(n.value));
 				continue;
 			}
@@ -278,7 +391,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 				value: this.parseTernary()
 			}), this.skipWs(), this.peek() === e.Comma && (this.pos++, this.skipWs());
 		}
-		return this.peek() === e.RBrace && this.pos++, {
+		return this.expectChar(e.RBrace, "a closing \"}\""), {
 			type: "object",
 			entries: t
 		};
@@ -306,7 +419,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 	parseArgList(t) {
 		let n = [];
 		for (this.skipWs(); !this.eof() && this.peek() !== t;) n.push(this.parseTernary()), this.skipWs(), this.peek() === e.Comma && (this.pos++, this.skipWs());
-		return this.peek() === t && this.pos++, n;
+		return this.expectChar(t, t === e.RParen ? "a closing \")\"" : "a closing \"]\""), n;
 	}
 	parseTrailingFilters() {
 		let t = [];
@@ -321,7 +434,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 	}
 	readFilter() {
 		let t = this.scanName();
-		return this.skipWs(), this.peek() === e.LParen ? (this.pos++, {
+		return t || this.report(`A "|" with no filter name after it in "${this.src.trim()}"`), this.skipWs(), this.peek() === e.LParen ? (this.pos++, {
 			name: t,
 			args: this.parseArgList(e.RParen)
 		}) : {

package/dist/helpers/twigWrapper/Parser/Parser.d.ts

@@ -1,3 +1,4 @@
 import { Token } from '../Lexer';
 import { ParseResult } from './types';
-export declare const parse: (tokens: readonly Token[], keepEmptyTokens?: boolean) => ParseResult;
+/** `issues`, when given, collects what the expression grammar read past rather than understood — see `inspectTemplate`. */
+export declare const parse: (tokens: readonly Token[], keepEmptyTokens?: boolean, issues?: string[]) => ParseResult;