@plitzi/sdk-shared 0.37.2 → 0.37.3

package/dist/devTools/utils/PlitziConsole.mjs

@@ -1,6 +1,5 @@
-import { formatDate as e } from "../../helpers/formatDate.mjs";
 //#region src/devTools/utils/PlitziConsole.ts
-var t = class {
+var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}:${e(t.getMinutes())}:${e(t.getSeconds())}.${e(t.getMilliseconds(), 3)}`, n = () => typeof window < "u", r = class {
 	callbackInternal;
 	callbackAddProvider;
 	callbackRemoveProvider;
@@ -34,30 +33,31 @@ var t = class {
 	flush(e = !1) {
 		this.logsListened = [], e && (this.pendingLogs = []);
 	}
-	#n(e, t, n, r) {
-		let i = this.getTime(!0);
+	#n(e, t, r, i) {
+		if (!this.callbackInternal && !n()) return;
+		let a = this.getTime(!0);
 		if (!this.callbackInternal) {
 			this.pendingLogs.push({
 				logType: e,
 				category: t,
-				message: n,
-				params: r,
-				time: i
+				message: r,
+				params: i,
+				time: a
 			}), this.pendingLogs.length > this.pendingLimit && this.pendingLogs.shift();
 			return;
 		}
 		this.listening ? this.logsListened.push({
 			logType: e,
 			category: t,
-			message: n,
-			params: r,
-			time: i
+			message: r,
+			params: i,
+			time: a
 		}) : (this.#e.push({
 			logType: e,
 			category: t,
-			message: n,
-			params: r,
-			time: i
+			message: r,
+			params: i,
+			time: a
 		}), this.#r()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
 	}
 	#r() {
@@ -73,9 +73,9 @@ var t = class {
 	removeProviderMethod(e) {
 		typeof this.callbackRemoveProvider == "function" && this.callbackRemoveProvider(e);
 	}
-	getTime(t = !1) {
+	getTime(e = !1) {
 		let n = /* @__PURE__ */ new Date();
-		return t ? e(n, "HH:mm:ss.SSS") : n;
+		return e ? t(n) : n;
 	}
 	info(e, t, n) {
 		this.#n("info", e, t, n);
@@ -95,16 +95,16 @@ var t = class {
 	end() {
 		this.listening = !1, this.listeningCategory && this.logsListened.length > 0 && this.callbackInternal?.("info", this.listeningCategory, `${this.logsListened.length} Log${this.logsListened.length === 1 ? "" : "s"}`, { logs: this.logsListened }), this.logsListened = [], this.listeningCategory = void 0;
 	}
-}, n = new t();
-function r(e = "store") {
-	return ({ path: t, prevValue: r, nextValue: i }) => {
-		n.info("store", e, {
+}, i = new r();
+function a(e = "store") {
+	return ({ path: t, prevValue: n, nextValue: r }) => {
+		i.info("store", e, {
 			storeName: e,
 			path: t,
-			prev: r,
-			next: i
+			prev: n,
+			next: r
 		});
 	};
 }
 //#endregion
-export { r as createStoreDevToolsLogger, t as default, n as pConsole };
+export { a as createStoreDevToolsLogger, r as default, i as pConsole };

package/dist/helpers/cookies.d.ts

@@ -0,0 +1,10 @@
+/**
+ * One cookie's value out of a `Cookie` header — or out of `document.cookie`, which is written the same way.
+ *
+ * One function for both halves of the SDK, because the cookies it reads this way are the ones a server reads to render
+ * what the browser is about to hydrate: two parsers are two chances to disagree about a value, and a disagreement there
+ * is a page thrown away and drawn again. Undecodable values answer `undefined`, like absent ones.
+ */
+export declare const cookieFromHeader: (header: string | undefined, name: string) => string | undefined;
+/** `document.cookie`, or nothing where there is no document or it may not be read (a sandboxed frame throws). */
+export declare const documentCookies: () => string | undefined;

package/dist/helpers/cookies.mjs

@@ -0,0 +1,19 @@
+//#region src/helpers/cookies.ts
+var e = (e, t) => {
+	if (e) for (let n of e.split(";")) {
+		let e = n.indexOf("=");
+		if (e > -1 && n.slice(0, e).trim() === t) try {
+			return decodeURIComponent(n.slice(e + 1).trim());
+		} catch {
+			return;
+		}
+	}
+}, t = () => {
+	try {
+		return typeof document > "u" ? void 0 : document.cookie;
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { e as cookieFromHeader, t as documentCookies };

package/dist/helpers/fetchManifest.d.ts

@@ -1,2 +1,11 @@
+/**
+ * A plugin's `plugin-manifest.json`, or `undefined` when it cannot be had.
+ *
+ * Plugins live on hosts of their own — a CDN, a bucket, the builder's resources — so this is nearly always a
+ * cross-origin request, and it is kept a SIMPLE one: `Accept` says what is wanted, where the `Content-Type` this used to
+ * send (on a GET, with no body to describe) made the browser ask the host's permission first. A host that allows plain
+ * cross-origin reads — the usual CORS setting of a bucket — refused that preflight, and the element rendered "Not
+ * Found" with the manifest sitting right there.
+ */
 declare const fetchManifest: <T extends object>(manifestUrl: string) => Promise<T | undefined>;
 export default fetchManifest;

package/dist/helpers/fetchManifest.mjs

@@ -1,13 +1,10 @@
 //#region src/helpers/fetchManifest.ts
 var e = async (e) => {
-	let t;
 	try {
-		return t = await (await fetch(e, {
-			method: "GET",
-			headers: { "Content-Type": "application/json" }
-		})).json(), t;
+		let t = await fetch(e, { headers: { Accept: "application/json" } });
+		return t.ok ? await t.json() : void 0;
 	} catch {
-		return t;
+		return;
 	}
 };
 //#endregion

package/dist/helpers/formatDate.d.ts

@@ -25,7 +25,11 @@ export declare const parseDate: (date: string | number | Date) => Date;
  */
 export declare function formatDate(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
 export declare function formatDateUTC(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
-/** Formats a UTC timestamp/string to local timezone */
+/**
+ * Formats a UTC timestamp/string in the local timezone. A `Date` is an instant and `format` reads its local fields, so
+ * there is nothing to convert: moving it first is what printed the repeated hour at the end of daylight saving time an
+ * hour off.
+ */
 export declare function formatUTCToLocal(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
 /**
  * Returns the difference between two dates in milliseconds
@@ -52,5 +56,3 @@ export declare function getDurationMs(start: string | number | Date, end: string
 export declare function formatFromNow(date?: string | number | Date, locale?: SupportedLocale, options?: FormatDistanceToNowOptions): string;
 export declare function isValidFormat(formatStr: string): boolean;
 export declare const toUnixSeconds: (input: string | number | Date) => string;
-/** Strictly validates whether a string matches a given date-fns format. */
-export declare function isDate(value: string, formatStr: string): boolean;

package/dist/helpers/formatDate.mjs

@@ -1,58 +1,56 @@
-import { differenceInMilliseconds as e, format as t, formatDistanceToNow as n, getTime as r, isValid as i, parse as a, parseISO as o } from "date-fns";
-import { enUS as s, es as c, pt as l } from "date-fns/locale";
-import { toZonedTime as u } from "date-fns-tz";
+import { differenceInMilliseconds as e } from "date-fns/differenceInMilliseconds";
+import { format as t } from "date-fns/format";
+import { formatDistanceToNow as n } from "date-fns/formatDistanceToNow";
+import { getTime as r } from "date-fns/getTime";
+import { enUS as i } from "date-fns/locale/en-US";
+import { es as a } from "date-fns/locale/es";
+import { pt as o } from "date-fns/locale/pt";
+import { parseISO as s } from "date-fns/parseISO";
 //#region src/helpers/formatDate.ts
-var d = {
-	en: s,
-	es: c,
-	pt: l
-}, f = (e) => {
+var c = {
+	en: i,
+	es: a,
+	pt: o
+}, l = (e) => {
 	let t;
-	return t = typeof e == "number" ? e < 0xe8d4a51000 ? /* @__PURE__ */ new Date(e * 1e3) : new Date(e) : typeof e == "string" ? o(e) : e, t;
+	return t = typeof e == "number" ? e < 0xe8d4a51000 ? /* @__PURE__ */ new Date(e * 1e3) : new Date(e) : typeof e == "string" ? s(e) : e, t;
 };
-function p(e, n = "dd MMMM, yyyy", r = "en") {
+function u(e, n = "dd MMMM, yyyy", r = "en") {
 	if (!e) return "";
-	let i = f(e);
-	return t(i, n, { locale: d[r] });
+	let i = l(e);
+	return t(i, n, { locale: c[r] });
 }
-function m(e, n = "dd MMMM, yyyy", r = "en") {
+var d = (e) => {
+	let t = new Date(e.getUTCFullYear(), e.getUTCMonth(), e.getUTCDate(), e.getUTCHours(), e.getUTCMinutes(), e.getUTCSeconds(), e.getUTCMilliseconds());
+	return t.setFullYear(e.getUTCFullYear()), t;
+};
+function f(e, n = "dd MMMM, yyyy", r = "en") {
 	if (!e) return "";
-	let i = f(e);
-	return t(u(i, "UTC"), n, { locale: d[r] });
+	let i = l(e);
+	return t(d(i), n, { locale: c[r] });
 }
-function h(e, n = "dd MMMM, yyyy HH:mm", r = "en") {
-	if (!e) return "";
-	let i = f(e), a = Intl.DateTimeFormat().resolvedOptions().timeZone, o = u(i, a);
-	return t(o, n, { locale: d[r] });
+function p(e, n = "dd MMMM, yyyy HH:mm", r = "en") {
+	return e ? t(l(e), n, { locale: c[r] }) : "";
 }
-function g(t, n) {
-	let r = f(t), i = f(n);
+function m(t, n) {
+	let r = l(t), i = l(n);
 	return e(i, r);
 }
-function _(e, t = "en", r) {
+function h(e, t = "en", r) {
 	if (!e) return "";
-	let i = f(e);
+	let i = l(e);
 	return isNaN(i.getTime()) ? "" : n(i, {
 		...r,
-		locale: d[t]
+		locale: c[t]
 	});
 }
-function v(e) {
+function g(e) {
 	try {
 		return t(/* @__PURE__ */ new Date(), e), !0;
 	} catch {
 		return !1;
 	}
 }
-var y = (e) => Math.floor(r(f(e)) / 1e3).toString();
-function b(e, n) {
-	if (typeof e != "string") return !1;
-	try {
-		let r = a(e, n, /* @__PURE__ */ new Date());
-		return i(r) ? t(r, n) === e : !1;
-	} catch {
-		return !1;
-	}
-}
+var _ = (e) => Math.floor(r(l(e)) / 1e3).toString();
 //#endregion
-export { p as formatDate, m as formatDateUTC, _ as formatFromNow, h as formatUTCToLocal, g as getDurationMs, b as isDate, v as isValidFormat, f as parseDate, y as toUnixSeconds };
+export { u as formatDate, f as formatDateUTC, h as formatFromNow, p as formatUTCToLocal, m as getDurationMs, g as isValidFormat, l as parseDate, _ as toUnixSeconds };

package/dist/helpers/index.d.ts

@@ -1,8 +1,10 @@
 import { default as fetchManifest } from './fetchManifest';
 import { default as generateFacade } from './generateFacade';
 import { default as syntaxHighlight } from './syntaxHighlight';
+export * from './cookies';
 export * from './fetchManifest';
 export * from './formatDate';
+export * from './isDate';
 export * from './generateFacade';
 export * from './reducerOrigin';
 export * from './ruleEvaluator';

package/dist/helpers/index.mjs

@@ -1,15 +1,19 @@
 import { filters as e } from "./twigWrapper/filters/filters.mjs";
-import { processTwig as t } from "./twigWrapper/processTwig/processTwig.mjs";
-import { hasTemplateSyntax as n } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
-import { hasValidToken as r } from "./twigWrapper/tokens/hasValidToken.mjs";
-import { templateRootNames as i } from "./twigWrapper/templateRoots.mjs";
-import a from "./fetchManifest.mjs";
-import o from "./generateFacade.mjs";
-import s from "./syntaxHighlight.mjs";
-import { formatDate as c, formatDateUTC as l, formatFromNow as u, formatUTCToLocal as d, getDurationMs as f, isDate as p, isValidFormat as m, parseDate as h, toUnixSeconds as g } from "./formatDate.mjs";
-import { isUserEdit as _ } from "./reducerOrigin.mjs";
-import { evaluateRuleGroup as v } from "./ruleEvaluator.mjs";
-import { ParamsFromURL as y, delay as b, emptyObject as x, getDisplayName as S, getKeyDecoded as C, getPathsFromObeject as w, hexToRGB as T, isInViewport as E, makeId as D } from "./utils.mjs";
-import { disableReactDevTools as O } from "./security.mjs";
-import { createStripTypenameLink as k, stripTypenameDeep as A } from "./stripTypename.mjs";
-export { y as ParamsFromURL, k as createStripTypenameLink, b as delay, O as disableReactDevTools, x as emptyObject, v as evaluateRuleGroup, a as fetchManifest, e as filters, c as formatDate, l as formatDateUTC, u as formatFromNow, d as formatUTCToLocal, o as generateFacade, S as getDisplayName, f as getDurationMs, C as getKeyDecoded, w as getPathsFromObeject, n as hasTemplateSyntax, r as hasValidToken, T as hexToRGB, p as isDate, E as isInViewport, _ as isUserEdit, m as isValidFormat, D as makeId, h as parseDate, t as processTwig, A as stripTypenameDeep, s as syntaxHighlight, i as templateRootNames, g as toUnixSeconds };
+import { processTwig as t, processTwigParam as n, processTwigValue as r } from "./twigWrapper/processTwig/processTwig.mjs";
+import { hasTemplateSyntax as i } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as a } from "./twigWrapper/tokens/hasValidToken.mjs";
+import { MAX_PARAM_PASSES as o, resolveStepParam as s } from "./twigWrapper/processTwig/resolveStepParam.mjs";
+import { inspectTemplate as c } from "./twigWrapper/inspectTemplate.mjs";
+import { templatePaths as l, templateRootNames as u } from "./twigWrapper/templateRoots.mjs";
+import d from "./fetchManifest.mjs";
+import f from "./generateFacade.mjs";
+import p from "./syntaxHighlight.mjs";
+import { cookieFromHeader as m, documentCookies as h } from "./cookies.mjs";
+import { formatDate as g, formatDateUTC as _, formatFromNow as v, formatUTCToLocal as y, getDurationMs as b, isValidFormat as x, parseDate as S, toUnixSeconds as C } from "./formatDate.mjs";
+import { isDate as w } from "./isDate.mjs";
+import { isUserEdit as T } from "./reducerOrigin.mjs";
+import { evaluateRuleGroup as E } from "./ruleEvaluator.mjs";
+import { ParamsFromURL as D, delay as O, emptyObject as k, getDisplayName as A, getKeyDecoded as j, getPathsFromObeject as M, hexToRGB as N, isInViewport as P, makeId as F } from "./utils.mjs";
+import { disableReactDevTools as I } from "./security.mjs";
+import { createStripTypenameLink as L, stripTypenameDeep as R } from "./stripTypename.mjs";
+export { o as MAX_PARAM_PASSES, D as ParamsFromURL, m as cookieFromHeader, L as createStripTypenameLink, O as delay, I as disableReactDevTools, h as documentCookies, k as emptyObject, E as evaluateRuleGroup, d as fetchManifest, e as filters, g as formatDate, _ as formatDateUTC, v as formatFromNow, y as formatUTCToLocal, f as generateFacade, A as getDisplayName, b as getDurationMs, j as getKeyDecoded, M as getPathsFromObeject, i as hasTemplateSyntax, a as hasValidToken, N as hexToRGB, c as inspectTemplate, w as isDate, P as isInViewport, T as isUserEdit, x as isValidFormat, F as makeId, S as parseDate, t as processTwig, n as processTwigParam, r as processTwigValue, s as resolveStepParam, R as stripTypenameDeep, p as syntaxHighlight, l as templatePaths, u as templateRootNames, C as toUnixSeconds };

package/dist/helpers/isDate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A module of its own because `parse` is the heaviest thing in date-fns — it compiles every token parser the format
+ * language has, about 100 MB of memory on the way in — and nothing that formats a date should pay for it. Imported from
+ * `formatDate`, it was paid by every page server at start, for a function no renderer calls.
+ */
+/** Strictly validates whether a string matches a given date-fns format. */
+export declare function isDate(value: string, formatStr: string): boolean;

package/dist/helpers/isDate.mjs

@@ -0,0 +1,15 @@
+import { format as e } from "date-fns/format";
+import { isValid as t } from "date-fns/isValid";
+import { parse as n } from "date-fns/parse";
+//#region src/helpers/isDate.ts
+function r(r, i) {
+	if (typeof r != "string") return !1;
+	try {
+		let a = n(r, i, /* @__PURE__ */ new Date());
+		return t(a) ? e(a, i) === r : !1;
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { r as isDate };

package/dist/helpers/keys.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Keyboard shortcuts, as a space writes them: `'f'`, `'shift+f'`, `'mod+k'`, `'escape'`, several at once with commas
+ * (`'plus, ='`).
+ *
+ * Both halves of matching live here — reading what an author wrote and reading what a key press was — so they meet
+ * in one canonical form: modifiers in a fixed order, then the key, lower case (`ctrl+shift+f`). Authoring reads the
+ * first half to refuse a shortcut that could never fire; the element listening reads both.
+ */
+/** The trigger a shortcut starts: fired once per key press, with every shortcut it matched. */
+export declare const KEY_TRIGGER = "onKey";
+export type KeyTriggerPayload = {
+    /** The key pressed, canonical — `shift+f`. */
+    key: string;
+    /** Each `keys` param, exactly as written, that the press matched: the flows that run are the ones written so. */
+    shortcuts: string[];
+};
+export type ParsedKeys = {
+    /** Each shortcut, canonical: `ctrl+alt+shift+meta+key`, with only the modifiers it uses. */
+    combos: string[];
+    /** Each part that is not a shortcut, with why — empty when all of it is. */
+    problems: string[];
+};
+/** Every shortcut in what an author wrote, canonical, and what in it is not one. */
+export declare const parseKeys: (spec: string, isMac?: boolean) => ParsedKeys;
+export type KeyPress = Pick<KeyboardEvent, 'key' | 'code' | 'ctrlKey' | 'altKey' | 'shiftKey' | 'metaKey'>;
+/**
+ * A key press, in the form {@link parseKeys} writes.
+ *
+ * Two keyboard facts decide it. Shift is part of a LETTER's shortcut (`shift+f`), but a symbol is typed with whatever
+ * it takes — `+` is Shift+= on one keyboard and a key of its own on another — so for a symbol Shift is not counted.
+ * And with Alt, Ctrl or ⌘ held, `key` can be another character altogether (Option+F is `ƒ` on a Mac): the physical
+ * letter or digit is read from `code` instead.
+ */
+export declare const keyPressCombo: (press: KeyPress) => string;
+/**
+ * Whether a press, made in a text field, is the field's own editing — so a shortcut must not take it.
+ *
+ * With ⌘, Ctrl or Alt held a press in a field is otherwise a shortcut's, which is what lets `mod+k` open a palette
+ * from a search box. But `mod+a` in a title field is "select this text", not "select everything on the board", and
+ * `alt+backspace` deletes a word: a shortcut that took those would break typing wherever the page has one.
+ */
+export declare const isFieldEditing: (combo: string) => boolean;

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;