@plitzi/sdk-shared 0.32.5 → 0.32.6

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

@@ -0,0 +1,14 @@
+export declare class Cursor {
+    protected readonly src: string;
+    protected pos: number;
+    constructor(src: string);
+    protected eof(): boolean;
+    protected peek(): number;
+    protected at(offset: number): number;
+    protected skipWs(): void;
+    protected scanName(): string;
+    protected scanStringLiteral(): string;
+    protected scanNumber(): number;
+    protected matchKeyword(kw: string): boolean;
+    protected matchBinaryOp(): string | null;
+}

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

@@ -0,0 +1,63 @@
+import { Char as e, isDigit as t, isIdentPart as n, isIdentStart as r, isPathPart as i, isSpace as a } from "../charClass.mjs";
+//#region src/helpers/twigWrapper/Parser/Cursor.ts
+var o = class {
+	src;
+	pos = 0;
+	constructor(e) {
+		this.src = e;
+	}
+	eof() {
+		return this.pos >= this.src.length;
+	}
+	peek() {
+		return this.pos < this.src.length ? this.src.charCodeAt(this.pos) : -1;
+	}
+	at(e) {
+		let t = this.pos + e;
+		return t < this.src.length ? this.src.charCodeAt(t) : -1;
+	}
+	skipWs() {
+		for (; this.pos < this.src.length && a(this.src.charCodeAt(this.pos));) this.pos++;
+	}
+	scanName() {
+		let e = this.pos;
+		if (!this.eof() && r(this.src.charCodeAt(this.pos))) for (this.pos++; !this.eof() && i(this.src.charCodeAt(this.pos));) this.pos++;
+		return this.src.slice(e, this.pos);
+	}
+	scanStringLiteral() {
+		let t = this.src.charCodeAt(this.pos);
+		this.pos++;
+		let n = "";
+		for (; this.pos < this.src.length && this.src.charCodeAt(this.pos) !== t;) if (this.src.charCodeAt(this.pos) === e.Backslash && this.pos + 1 < this.src.length) {
+			this.pos++;
+			let r = this.src.charCodeAt(this.pos);
+			r === e.LowerN ? n += "\n" : r === e.LowerT ? n += "	" : r === e.LowerR ? n += "\r" : r === e.Backslash ? n += "\\" : r === t ? n += String.fromCharCode(r) : n += String.fromCharCode(e.Backslash) + String.fromCharCode(r), this.pos++;
+		} else n += this.src[this.pos], this.pos++;
+		return this.pos < this.src.length && this.pos++, n;
+	}
+	scanNumber() {
+		let n = this.pos;
+		for (this.src.charCodeAt(this.pos) === e.Minus && this.pos++; this.pos < this.src.length && t(this.src.charCodeAt(this.pos));) this.pos++;
+		if (this.src.charCodeAt(this.pos) === e.Dot) for (this.pos++; this.pos < this.src.length && t(this.src.charCodeAt(this.pos));) this.pos++;
+		return Number(this.src.slice(n, this.pos));
+	}
+	matchKeyword(e) {
+		let t = this.pos + e.length;
+		if (t > this.src.length) return !1;
+		for (let t = 0; t < e.length; t++) if (this.src.charCodeAt(this.pos + t) !== e.charCodeAt(t)) return !1;
+		return t < this.src.length && n(this.src.charCodeAt(t)) ? !1 : (this.pos = t, this.skipWs(), !0);
+	}
+	matchBinaryOp() {
+		this.skipWs();
+		let t = this.peek();
+		if (this.at(1) === e.Equals) {
+			if (t === e.Equals) return this.pos += 2, "==";
+			if (t === e.Bang) return this.pos += 2, "!=";
+			if (t === e.Greater) return this.pos += 2, ">=";
+			if (t === e.Less) return this.pos += 2, "<=";
+		}
+		return t === e.Greater ? (this.pos++, ">") : t === e.Less ? (this.pos++, "<") : null;
+	}
+};
+//#endregion
+export { o as Cursor };

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

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

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

@@ -0,0 +1,296 @@
+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 {
+	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;
+	}
+	parseOr() {
+		let e = this.parseAnd();
+		for (this.skipWs(); this.matchKeyword("or");) e = {
+			type: "binary",
+			operator: "or",
+			left: e,
+			right: this.parseAnd()
+		}, this.skipWs();
+		return e;
+	}
+	parseAnd() {
+		let e = this.parseNot();
+		for (this.skipWs(); this.matchKeyword("and");) e = {
+			type: "binary",
+			operator: "and",
+			left: e,
+			right: this.parseNot()
+		}, this.skipWs();
+		return e;
+	}
+	parseNot() {
+		return this.skipWs(), this.matchKeyword("not") ? {
+			type: "unary",
+			operator: "not",
+			operand: this.parseComparison()
+		} : this.parseComparison();
+	}
+	parseComparison() {
+		let e = this.parseConcat();
+		for (this.skipWs(); !this.eof();) {
+			if (this.matchKeyword("is")) {
+				this.skipWs(), e = {
+					type: "binary",
+					operator: this.matchKeyword("not") ? "is not" : "is",
+					left: e,
+					right: this.parseConcat()
+				}, this.skipWs();
+				continue;
+			}
+			if (this.matchKeyword("not")) {
+				if (this.skipWs(), this.matchKeyword("in")) {
+					e = {
+						type: "binary",
+						operator: "not in",
+						left: e,
+						right: this.parseConcat()
+					}, this.skipWs();
+					continue;
+				}
+				let t = this.src.slice(this.pos - 4);
+				return this.pos = this.src.length, {
+					type: "unary",
+					operator: "not",
+					operand: r(t)
+				};
+			}
+			if (this.matchKeyword("in")) {
+				e = {
+					type: "binary",
+					operator: "in",
+					left: e,
+					right: this.parseConcat()
+				}, this.skipWs();
+				continue;
+			}
+			let t = this.matchBinaryOp();
+			if (t) {
+				e = {
+					type: "binary",
+					operator: t,
+					left: e,
+					right: this.parseConcat()
+				}, this.skipWs();
+				continue;
+			}
+			break;
+		}
+		return e;
+	}
+	parseConcat() {
+		let t = this.parseAdditive();
+		for (this.skipWs(); this.peek() === e.Tilde;) {
+			this.pos++;
+			let e = this.parseAdditive();
+			t = t.type === "concat" ? {
+				type: "concat",
+				parts: [...t.parts, e]
+			} : {
+				type: "concat",
+				parts: [t, e]
+			}, this.skipWs();
+		}
+		return t;
+	}
+	parseAdditive() {
+		let t = this.parseMultiplicative();
+		this.skipWs();
+		for (let n = this.peek(); n === e.Plus || n === e.Minus; n = this.peek()) this.pos++, t = {
+			type: "binary",
+			operator: n === e.Plus ? "+" : "-",
+			left: t,
+			right: this.parseMultiplicative()
+		}, this.skipWs();
+		return t;
+	}
+	parseMultiplicative() {
+		let t = this.parseDefault();
+		this.skipWs();
+		for (let n = this.peek(); n === e.Star || n === e.Slash || n === e.Percent; n = this.peek()) this.pos++, t = {
+			type: "binary",
+			operator: n === e.Star ? "*" : n === e.Slash ? "/" : "%",
+			left: t,
+			right: this.parseDefault()
+		}, this.skipWs();
+		return t;
+	}
+	parseDefault() {
+		if (this.skipWs(), this.peek() === e.Minus && t(this.at(1))) return this.maybeTrailingFilters({
+			type: "literal",
+			value: this.scanNumber()
+		});
+		if (this.peek() === e.Minus) return this.pos++, {
+			type: "unary",
+			operator: "-",
+			operand: this.parseDefault()
+		};
+		let n = this.parseAtom();
+		for (this.skipWs(); this.peek() === e.Question && this.at(1) === e.Question;) this.pos += 2, this.skipWs(), n = {
+			type: "default",
+			value: n,
+			defaultExpr: this.parseAtom()
+		}, this.skipWs();
+		return n;
+	}
+	parseAtom() {
+		this.skipWs();
+		let n = this.peek();
+		if (n === e.LParen) {
+			this.pos++, this.skipWs();
+			let t = this.pos, n = this.tryParseArrowParams();
+			if (n !== null) return this.maybeTrailingFilters({
+				type: "arrow",
+				params: n,
+				body: this.parseTernary()
+			});
+			this.pos = t;
+			let r = this.parseTernary();
+			return this.skipWs(), this.peek() === e.RParen && this.pos++, this.maybeTrailingFilters(r);
+		}
+		return n === e.SingleQuote || n === e.DoubleQuote ? this.maybeTrailingFilters({
+			type: "literal",
+			value: this.scanStringLiteral()
+		}) : t(n) ? 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();
+	}
+	tryParseArrowParams() {
+		let t = this.pos, n = [];
+		for (this.skipWs(); this.peek() !== e.RParen;) {
+			let r = this.scanName();
+			if (!r) return this.pos = t, null;
+			if (n.push(r), this.skipWs(), this.peek() === e.Comma) {
+				this.pos++, this.skipWs();
+				continue;
+			}
+			break;
+		}
+		return this.skipWs(), this.peek() === e.RParen && (this.pos++, this.skipWs(), this.peek() === e.Equals && this.at(1) === e.Greater) ? (this.pos += 2, n) : (this.pos = t, null);
+	}
+	parsePathOrFunctionOrArrow() {
+		let t = this.scanName();
+		if (!t) return this.pos++, {
+			type: "literal",
+			value: ""
+		};
+		if (t === "true" || t === "false") return this.maybeTrailingFilters({
+			type: "literal",
+			value: t === "true"
+		});
+		if (this.skipWs(), this.peek() === e.Equals && this.at(1) === e.Greater) return this.pos += 2, this.maybeTrailingFilters({
+			type: "arrow",
+			params: [t],
+			body: this.parseTernary()
+		});
+		if (this.peek() === e.LParen) {
+			this.pos++;
+			let n = this.parseArgList(e.RParen);
+			return this.maybeTrailingFilters({
+				type: "function",
+				name: t,
+				args: n
+			});
+		}
+		let n = [t];
+		for (; this.peek() === e.Dot;) {
+			this.pos++;
+			let e = this.scanName();
+			e && n.push(e);
+		}
+		return this.maybeTrailingFilters({
+			type: "path",
+			segments: n
+		});
+	}
+	maybeTrailingFilters(t) {
+		return this.skipWs(), this.peek() === e.Pipe ? {
+			type: "filter",
+			subject: t,
+			filters: this.parseTrailingFilters()
+		} : t;
+	}
+	parseObjectLiteral() {
+		let t = [];
+		for (this.skipWs(); !this.eof() && this.peek() !== e.RBrace;) {
+			let n = this.parseObjectKey();
+			this.skipWs(), this.peek() === e.Colon && this.pos++, this.skipWs(), t.push({
+				key: n,
+				value: this.parseTernary()
+			}), this.skipWs(), this.peek() === e.Comma && (this.pos++, this.skipWs());
+		}
+		return this.peek() === e.RBrace && this.pos++, {
+			type: "object",
+			entries: t
+		};
+	}
+	parseObjectKey() {
+		let n = this.peek();
+		if (n === e.SingleQuote || n === e.DoubleQuote) return {
+			type: "literal",
+			value: this.scanStringLiteral()
+		};
+		if (t(n)) return {
+			type: "literal",
+			value: this.scanNumber()
+		};
+		if (n === e.LParen) {
+			this.pos++, this.skipWs();
+			let t = this.parseTernary();
+			return this.skipWs(), this.peek() === e.RParen && this.pos++, t;
+		}
+		return {
+			type: "literal",
+			value: this.scanName()
+		};
+	}
+	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;
+	}
+	parseTrailingFilters() {
+		let t = [];
+		for (; this.peek() === e.Pipe;) this.pos++, this.skipWs(), t.push(this.readFilter()), this.skipWs();
+		return t;
+	}
+	parseApplyChain() {
+		this.skipWs();
+		let t = [this.readFilter()];
+		for (this.skipWs(); this.peek() === e.Pipe;) this.pos++, this.skipWs(), t.push(this.readFilter()), this.skipWs();
+		return t;
+	}
+	readFilter() {
+		let t = this.scanName();
+		return this.skipWs(), this.peek() === e.LParen ? (this.pos++, {
+			name: t,
+			args: this.parseArgList(e.RParen)
+		}) : {
+			name: t,
+			args: []
+		};
+	}
+};
+//#endregion
+export { i as parseApplyFilters, r as parseExpression };

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

@@ -0,0 +1,3 @@
+import { Token } from '../Lexer';
+import { ParseResult } from './types';
+export declare const parse: (tokens: readonly Token[], keepEmptyTokens?: boolean) => ParseResult;

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

@@ -0,0 +1,237 @@
+import { isSimpleIdentifier as e, isVariableName as t } from "../charClass.mjs";
+import { reconstructSource as n, reconstructToken as r } from "../Lexer/types.mjs";
+import { parseApplyFilters as i, parseExpression as a } from "./ExpressionParser.mjs";
+import { extractFirstWord as o, splitRange as s } from "./helpers.mjs";
+//#region src/helpers/twigWrapper/Parser/Parser.ts
+var c = (e, t = !1) => {
+	let n = new f(e, t), r = n.parseBody();
+	if (!n.error) {
+		let e = n.peek();
+		if (e && e.type === "tag") {
+			let t = o(e.content.trim());
+			l.has(t) && (n.error = `Orphan closing tag: {% ${t} %} without matching opening tag`);
+		}
+	}
+	return {
+		nodes: r,
+		error: n.error
+	};
+}, l = /* @__PURE__ */ new Set([
+	"endif",
+	"endfor",
+	"endset",
+	"endapply",
+	"else",
+	"elseif"
+]), u = () => ({
+	type: "if",
+	condition: {
+		type: "literal",
+		value: !1
+	},
+	body: [],
+	elseifClauses: [],
+	elseBody: null
+}), d = () => ({
+	type: "for",
+	valueVar: "_item",
+	keyVar: null,
+	collection: {
+		type: "literal",
+		value: ""
+	},
+	body: [],
+	elseBody: null
+}), f = class {
+	tokens;
+	keepEmptyTokens;
+	pos = 0;
+	error = null;
+	constructor(e, t = !1) {
+		this.tokens = e, this.keepEmptyTokens = t;
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	advance() {
+		let e = this.tokens[this.pos];
+		return e && this.pos++, e;
+	}
+	isTag(e) {
+		let t = this.peek();
+		if (!t || t.type !== "tag") return !1;
+		let n = t.content.trim();
+		return n === e || n.startsWith(e + " ") || n.startsWith(e + "	");
+	}
+	parseBody() {
+		let e = [];
+		for (; this.pos < this.tokens.length;) {
+			let t = this.peek();
+			if (!t || t.type === "tag" && l.has(o(t.content.trim()))) break;
+			let n = this.parseNode();
+			n && e.push(n);
+		}
+		return e;
+	}
+	parseNode() {
+		let e = this.peek();
+		return e ? e.type === "text" ? (this.advance(), {
+			type: "text",
+			value: e.value
+		}) : e.type === "variable" ? this.parseVariable() : this.parseTag() : null;
+	}
+	parseVariable() {
+		let t = this.advance();
+		if (!t || t.type !== "variable") return {
+			type: "variable",
+			raw: !1,
+			expression: {
+				type: "literal",
+				value: ""
+			},
+			source: ""
+		};
+		let r = t.content.trim(), i = this.keepEmptyTokens ? n(t.content, t.raw) : "";
+		if (e(r)) return {
+			type: "variable",
+			raw: t.raw,
+			expression: {
+				type: "path",
+				segments: [r]
+			},
+			source: i
+		};
+		let o = a(r);
+		return {
+			type: "variable",
+			raw: t.raw,
+			expression: o,
+			source: i
+		};
+	}
+	parseTag() {
+		let e = this.peek();
+		if (!e || e.type !== "tag") return null;
+		switch (o(e.content.trim())) {
+			case "if": return this.parseIf();
+			case "for": return this.parseFor();
+			case "set": return this.parseSet();
+			case "apply": return this.parseApply();
+			case "break": return this.advance(), { type: "break" };
+			case "continue": return this.advance(), { type: "continue" };
+			default: return this.advance(), null;
+		}
+	}
+	parseIf() {
+		this.advance();
+		let e = this.tokens[this.pos - 1];
+		if (e.type !== "tag") return this.error = "Malformed {% if %} tag", u();
+		let t = e.content.trim(), n = t.indexOf(" ") === -1 ? "" : t.slice(t.indexOf(" ") + 1).trim();
+		if (!n) return this.error = "Malformed {% if %} tag: missing condition", u();
+		let r = a(n), i = this.parseBody(), s = [], c = null, l = !1;
+		for (; this.peek();) {
+			let e = this.peek();
+			if (!e || e.type !== "tag") break;
+			let t = o(e.content.trim());
+			if (t === "elseif") {
+				this.advance();
+				let t = e.content.trim(), n = a(t.slice(t.indexOf(" ") + 1).trim()), r = this.parseBody();
+				s.push({
+					condition: n,
+					body: r
+				});
+			} else if (t === "else") this.advance(), c = this.parseBody();
+			else if (t === "endif") {
+				this.advance(), l = !0;
+				break;
+			} else break;
+		}
+		return l || (this.error = "Malformed {% if %} block: missing {% endif %}"), {
+			type: "if",
+			condition: r,
+			body: i,
+			elseifClauses: s,
+			elseBody: c
+		};
+	}
+	parseFor() {
+		let e = this.pos;
+		this.advance();
+		let n = this.tokens[this.pos - 1];
+		if (n.type !== "tag") return d();
+		let r = n.content.trim(), i = r.slice(r.indexOf(" ") + 1).trim(), c = /\sin\s/.exec(i);
+		if (!c) return this.error = "Invalid {% for %} syntax: missing the `in` keyword", d();
+		let l = i.slice(0, c.index).trim(), u = i.slice(c.index + c[0].length).trim(), f = s(u), p = f ? {
+			type: "range",
+			start: a(f[0]),
+			end: a(f[1])
+		} : a(u), m = l.indexOf(","), h = m === -1 ? null : l.slice(0, m).trim(), g = m === -1 ? l : l.slice(m + 1).trim();
+		if (!t(g)) return this.error = `Invalid {% for %} variable name: "${g}"`, d();
+		if (h !== null && !t(h)) return this.error = `Invalid {% for %} key variable name: "${h}"`, d();
+		let _ = this.parseBody(), v = null;
+		if (this.peek()) {
+			let e = this.peek();
+			e && e.type === "tag" && o(e.content.trim()) === "else" && (this.advance(), v = this.parseBody());
+		}
+		let y = this.peek();
+		y && y.type === "tag" && o(y.content.trim()) === "endfor" ? this.advance() : this.error = "Malformed {% for %} block: missing {% endfor %}";
+		let b = this.keepEmptyTokens ? this.reconstructRange(e, this.pos) : void 0;
+		return {
+			type: "for",
+			valueVar: g,
+			keyVar: h,
+			collection: p,
+			body: _,
+			elseBody: v,
+			source: b
+		};
+	}
+	reconstructRange(e, t) {
+		let n = "";
+		for (let i = e; i < t; i++) n += r(this.tokens[i]);
+		return n;
+	}
+	parseSet() {
+		this.advance();
+		let e = this.tokens[this.pos - 1];
+		if (e.type !== "tag") return {
+			type: "set",
+			name: "_unknown",
+			value: {
+				type: "literal",
+				value: ""
+			}
+		};
+		let t = e.content.trim(), n = t.slice(t.indexOf(" ") + 1).trim(), r = n.indexOf("=");
+		if (r === -1) {
+			let e = n.trim(), t = this.parseBody(), r = this.peek();
+			return r && r.type === "tag" && this.advance(), {
+				type: "set",
+				name: e,
+				value: t
+			};
+		}
+		return {
+			type: "set",
+			name: n.slice(0, r).trim(),
+			value: a(n.slice(r + 1).trim())
+		};
+	}
+	parseApply() {
+		this.advance();
+		let e = this.tokens[this.pos - 1];
+		if (e.type !== "tag") return {
+			type: "apply",
+			filters: [],
+			body: []
+		};
+		let t = e.content.trim(), n = i(t.slice(t.indexOf(" ") + 1).trim()), r = this.parseBody(), a = this.peek();
+		return a && a.type === "tag" && this.advance(), {
+			type: "apply",
+			filters: n,
+			body: r
+		};
+	}
+};
+//#endregion
+export { c as parse };

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

@@ -0,0 +1,2 @@
+export declare const extractFirstWord: (s: string) => string;
+export declare const splitRange: (s: string) => [string, string] | null;

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

@@ -0,0 +1,18 @@
+import { Char as e, isSpace as t } from "../charClass.mjs";
+//#region src/helpers/twigWrapper/Parser/helpers.ts
+var n = (e) => {
+	let n = 0;
+	for (; n < e.length && !t(e.charCodeAt(n));) n++;
+	return e.slice(0, n);
+}, r = (t) => {
+	let n = 0;
+	for (let r = 0; r + 1 < t.length; r++) {
+		let i = t.charCodeAt(r);
+		if (n !== 0) i === n && (n = 0);
+		else if (i === e.SingleQuote || i === e.DoubleQuote) n = i;
+		else if (i === e.Dot && t.charCodeAt(r + 1) === e.Dot) return [t.slice(0, r).trim(), t.slice(r + 2).trim()];
+	}
+	return null;
+};
+//#endregion
+export { n as extractFirstWord, r as splitRange };

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

@@ -0,0 +1,2 @@
+export { parse } from './Parser';
+export type { ParseResult } from './types';

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

@@ -0,0 +1,2 @@
+import { parse as e } from "./Parser.mjs";
+export { e as parse };

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

@@ -0,0 +1,5 @@
+import { ASTNode } from '../AST';
+export type ParseResult = {
+    readonly nodes: readonly ASTNode[];
+    readonly error: string | null;
+};

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

@@ -0,0 +1,17 @@
+import { ASTNode } from '../AST';
+import { Token } from '../Lexer';
+export type CacheEntry = {
+    tokens: readonly Token[];
+    hasTags: boolean;
+    allSimpleOrDotted: boolean;
+    nodes: readonly ASTNode[] | null;
+    nodesWithSource: readonly ASTNode[] | null;
+};
+export type CacheStats = {
+    hits: number;
+    misses: number;
+};
+export declare const getCacheStats: () => CacheStats;
+export declare const resetCacheStats: () => void;
+export declare const resolveTokens: (template: string) => CacheEntry | null;
+export declare const getNodes: (entry: CacheEntry, keepEmptyTokens: boolean) => readonly ASTNode[] | null;