@fedify/uri-template 2.0.0-pr.475.1

package/dist/match.js

@@ -0,0 +1,180 @@
+import { OP, looksLikePctTriplet, strictPercentDecode } from "./spec.js";
+
+//#region src/match.ts
+function decodeAccordingToPolicy(s, policy) {
+	if (policy === "opaque") return s;
+	if (policy === "cooked") return strictPercentDecode(s);
+	return {
+		raw: s,
+		decoded: strictPercentDecode(s)
+	};
+}
+/**
+* consume a percent triplet or a single char; used to advance safely
+*
+* Percent triplet handling policies:
+* - When advancing, treat "%XX" as a single atom to avoid slicing inside a byte.
+* - In strict mode, a bare '%' or bad hex after '%' fails the match.
+*/
+function advanceOne(url, i) {
+	if (i < url.length && url[i] === "%" && looksLikePctTriplet(url, i)) return i + 3;
+	return i + 1;
+}
+/**
+* Match a URL string against a compiled template and extract variables.
+*
+* @param ast - The parsed template AST to match against
+* @param url - The URL string to match
+* @param opts - Optional matching options
+* @returns An object with extracted variables if matched, null otherwise
+*
+* Encoding policies:
+* - "opaque"  -> return raw percent-encoded slices (byte-for-byte round-trip)
+* - "cooked"  -> decode %XX exactly once
+* - "lossless"-> { raw, decoded } pair
+*
+* Strictness:
+* - strict=true rejects bad percent triplets (e.g. "%GZ"), preventing
+*   ambiguous or lossy normalization early.
+*
+* @example
+* ```typescript
+* import { parse } from "./parser.ts";
+* import { match } from "./match.ts";
+*
+* const ast = parse("/repos{/owner,repo}{?q,lang}");
+* const result = match(ast, "/repos/alice/hello%2Fworld?q=a%20b&lang=en", { encoding: "opaque" });
+* // Returns: { vars: { owner: "alice", repo: "hello%2Fworld", q: "a%20b", lang: "en" } }
+* ```
+*
+* @example
+* ```typescript
+* import { parse } from "./parser.ts";
+* import { match } from "./match.ts";
+*
+* const ast = parse("/files{/path}");
+* const result = match(ast, "/files/a%2Fb", { encoding: "cooked" });
+* // Returns: { vars: { path: "a/b" } }
+* ```
+*/
+function match(ast, url, opts) {
+	const policy = opts?.encoding ?? "opaque";
+	const strict = opts?.strict ?? true;
+	let i = 0;
+	const varsOut = {};
+	const readLiteral = (lit) => {
+		if (url.slice(i, i + lit.length) !== lit) return false;
+		i += lit.length;
+		return true;
+	};
+	const nextIs = (s) => url.slice(i, i + s.length) === s;
+	for (const node of ast.nodes) {
+		if (node.kind === "literal") {
+			if (!readLiteral(node.value)) return null;
+			continue;
+		}
+		const spec = OP[node.op];
+		if (spec.first) {
+			if (!readLiteral(spec.first)) return null;
+		}
+		const takeUntil = (stopPred) => {
+			const start = i;
+			while (i < url.length && !stopPred(i)) {
+				if (strict && url[i] === "%" && !looksLikePctTriplet(url, i)) return "";
+				i = advanceOne(url, i);
+			}
+			return url.slice(start, i);
+		};
+		const emitScalar = (v, raw) => {
+			varsOut[v.name] = decodeAccordingToPolicy(raw, policy);
+		};
+		const splitItems = (raw) => {
+			if (raw.length === 0) return [""];
+			const sep = spec.itemSep;
+			const out = [];
+			let start = 0;
+			for (let j = 0; j <= raw.length;) {
+				if (j === raw.length || raw.slice(j, j + sep.length) === sep) {
+					out.push(raw.slice(start, j));
+					j += sep.length;
+					start = j;
+					continue;
+				}
+				j = advanceOne(raw, j);
+			}
+			return out;
+		};
+		const captureOneVar = (v, last, nextLiteral) => {
+			const stopPred = (j) => {
+				if (nextLiteral && url.slice(j, j + nextLiteral.length) === nextLiteral) return true;
+				if (!last && spec.itemSep && url.slice(j, j + spec.itemSep.length) === spec.itemSep) return true;
+				return false;
+			};
+			const raw = takeUntil(stopPred);
+			if (raw === "" && strict && i < url.length && url[i] !== spec.itemSep && nextLiteral === null) return false;
+			if (v.explode) {
+				const parts = splitItems(raw);
+				if (spec.named) varsOut[v.name] = parseExplodeNamedParts(v, parts, spec, policy);
+				else varsOut[v.name] = parts.map((p) => decodeAccordingToPolicy(p, policy));
+			} else if (spec.named) {
+				const [ok, val] = captureNamedNonExplode(v, raw, spec, policy);
+				if (!ok) return false;
+				varsOut[v.name] = val;
+			} else emitScalar(v, raw);
+			if (!last && spec.itemSep && nextIs(spec.itemSep)) i += spec.itemSep.length;
+			return true;
+		};
+		for (let idx = 0; idx < node.vars.length; idx++) {
+			const v = node.vars[idx];
+			const last = idx === node.vars.length - 1;
+			let nextLiteral = null;
+			const nodeIndex = ast.nodes.indexOf(node);
+			for (let k = nodeIndex + 1; k < ast.nodes.length; k++) {
+				const n = ast.nodes[k];
+				if (n.kind === "literal" && n.value.length > 0) {
+					nextLiteral = n.value;
+					break;
+				}
+				if (n.kind === "expression" && OP[n.op].first) {
+					nextLiteral = OP[n.op].first;
+					break;
+				}
+			}
+			if (!captureOneVar(v, last, nextLiteral)) return null;
+		}
+	}
+	return { vars: varsOut };
+}
+function captureNamedNonExplode(v, raw, spec, policy) {
+	const eq = raw.indexOf(spec.kvSep);
+	if (eq === -1) {
+		if (spec.first === ";") {
+			if (raw === v.name) return [true, decodeAccordingToPolicy("", policy)];
+		}
+		return [false, null];
+	}
+	const lhs = raw.slice(0, eq), rhs = raw.slice(eq + spec.kvSep.length);
+	if (lhs !== v.name) return [false, null];
+	return [true, decodeAccordingToPolicy(rhs, policy)];
+}
+function parseExplodeNamedParts(v, parts, spec, policy) {
+	const allVarName = parts.every((p) => p.startsWith(v.name + spec.kvSep));
+	if (allVarName) return parts.map((p) => {
+		const rhs = p.slice((v.name + spec.kvSep).length);
+		return decodeAccordingToPolicy(rhs, policy);
+	});
+	const obj = {};
+	for (const p of parts) {
+		const i = p.indexOf(spec.kvSep);
+		if (i < 0) {
+			obj[decodeAccordingToPolicy(p, policy)] = "";
+			continue;
+		}
+		const k = p.slice(0, i), val = p.slice(i + spec.kvSep.length);
+		obj[decodeAccordingToPolicy(k, policy)] = decodeAccordingToPolicy(val, policy);
+	}
+	return obj;
+}
+
+//#endregion
+export { match };

package/dist/match.spec.cjs

@@ -0,0 +1,109 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_compile = require('./compile.cjs');
+const node_assert_strict = require_rolldown_runtime.__toESM(require("node:assert/strict"));
+const node_test = require_rolldown_runtime.__toESM(require("node:test"));
+
+//#region src/match.spec.ts
+(0, node_test.describe)("encoding modes", () => {
+	(0, node_test.test)("opaque vs cooked vs lossless — path segment", () => {
+		const t = require_compile.compile("/files{/path}");
+		const url = "/files/a%2Fb";
+		const mOpaque = t.match(url, { encoding: "opaque" });
+		const mCooked = t.match(url, { encoding: "cooked" });
+		const mLoss = t.match(url, { encoding: "lossless" });
+		if (!mOpaque || !mCooked || !mLoss) throw new Error("match failed");
+		(0, node_assert_strict.deepStrictEqual)(mOpaque.vars.path, "a%2Fb");
+		(0, node_assert_strict.deepStrictEqual)(mCooked.vars.path, "a/b");
+		(0, node_assert_strict.deepStrictEqual)(mLoss.vars.path.raw, "a%2Fb");
+		(0, node_assert_strict.deepStrictEqual)(mLoss.vars.path.decoded, "a/b");
+	});
+	(0, node_test.test)("opaque vs cooked vs lossless — query (named, non-explode)", () => {
+		const t = require_compile.compile("/s{?q}");
+		const url = "/s?q=a%20b";
+		const mo = t.match(url, { encoding: "opaque" });
+		const mc = t.match(url, { encoding: "cooked" });
+		const ml = t.match(url, { encoding: "lossless" });
+		if (!mo || !mc || !ml) throw new Error("match failed");
+		(0, node_assert_strict.deepStrictEqual)(mo.vars.q, "a%20b");
+		(0, node_assert_strict.deepStrictEqual)(mc.vars.q, "a b");
+		(0, node_assert_strict.deepStrictEqual)(ml.vars.q.raw, "a%20b");
+		(0, node_assert_strict.deepStrictEqual)(ml.vars.q.decoded, "a b");
+	});
+	(0, node_test.test)("opaque vs cooked — fragment (# operator)", () => {
+		const t = require_compile.compile("{#frag}");
+		const url = "#a%2Fb%23c";
+		const mo = t.match(url, { encoding: "opaque" });
+		const mc = t.match(url, { encoding: "cooked" });
+		if (!mo || !mc) throw new Error("match failed");
+		(0, node_assert_strict.deepStrictEqual)(mo.vars.frag, "a%2Fb%23c");
+		(0, node_assert_strict.deepStrictEqual)(mc.vars.frag, "a/b#c");
+	});
+});
+(0, node_test.describe)("round-trip behavior", () => {
+	(0, node_test.test)("round-trip: opaque always byte-equal; cooked not guaranteed on non-canonical URLs", () => {
+		{
+			const t1 = require_compile.compile("/repos{/owner,repo}{?q,lang}");
+			const url1 = "/repos/alice/hello%2Fworld?q=a%20b&lang=en";
+			const m1 = t1.match(url1, { encoding: "opaque" });
+			if (!m1) throw new Error("opaque match failed");
+			(0, node_assert_strict.deepStrictEqual)(t1.expand(m1.vars), url1);
+		}
+		{
+			const t2 = require_compile.compile("/files{/path}");
+			const url2 = "/files/a%252Fb";
+			const m2 = t2.match(url2, { encoding: "cooked" });
+			if (!m2) throw new Error("cooked match failed");
+			(0, node_assert_strict.notDeepStrictEqual)(t2.expand(m2.vars), url2);
+		}
+	});
+	(0, node_test.test)("semantic round-trip holds for cooked", () => {
+		const t = require_compile.compile("/u{/id}{?q}");
+		const vars = {
+			id: "a/b",
+			q: "x y"
+		};
+		const url = t.expand(vars);
+		const mc = t.match(url, { encoding: "cooked" });
+		if (!mc) throw new Error("cooked match failed");
+		(0, node_assert_strict.deepStrictEqual)(mc.vars, vars);
+	});
+});
+(0, node_test.describe)("lossless mode", () => {
+	(0, node_test.test)("lossless returns both forms and can re-expand either (non-canonical source)", () => {
+		const t = require_compile.compile("/doc{/path}{?q}");
+		const nonCanonicalUrl = "/doc/a%252Fb?q=x%2520y";
+		const ml = t.match(nonCanonicalUrl, { encoding: "lossless" });
+		if (!ml) throw new Error("lossless match failed");
+		const { path, q } = ml.vars;
+		(0, node_assert_strict.deepStrictEqual)(path.raw, "a%252Fb");
+		(0, node_assert_strict.deepStrictEqual)(path.decoded, "a%2Fb");
+		(0, node_assert_strict.deepStrictEqual)(q.raw, "x%2520y");
+		(0, node_assert_strict.deepStrictEqual)(q.decoded, "x%20y");
+		const urlFromRaw = t.expand({
+			path: path.raw,
+			q: q.raw
+		});
+		const urlFromDec = t.expand({
+			path: path.decoded,
+			q: q.decoded
+		});
+		(0, node_assert_strict.deepStrictEqual)(urlFromRaw, nonCanonicalUrl);
+		(0, node_assert_strict.notDeepStrictEqual)(urlFromDec, nonCanonicalUrl);
+	});
+});
+(0, node_test.describe)("strict mode", () => {
+	(0, node_test.test)("strict mode: bad percent triplet fails; non-strict tolerates", () => {
+		const t = require_compile.compile("/x{/id}");
+		const malformedPctTriplet = "/x/%GZ";
+		const mStrict = t.match(malformedPctTriplet, { encoding: "opaque" });
+		(0, node_assert_strict.deepStrictEqual)(mStrict, null);
+		const mLenient = t.match(malformedPctTriplet, {
+			encoding: "opaque",
+			strict: false
+		});
+		if (!mLenient) throw new Error("lenient match unexpectedly failed");
+		(0, node_assert_strict.deepStrictEqual)(mLenient.vars.id, "%GZ");
+	});
+});
+
+//#endregion

package/dist/match.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/match.spec.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/match.spec.js

@@ -0,0 +1,108 @@
+import { compile } from "./compile.js";
+import { deepStrictEqual, notDeepStrictEqual } from "node:assert/strict";
+import { describe, test } from "node:test";
+
+//#region src/match.spec.ts
+describe("encoding modes", () => {
+	test("opaque vs cooked vs lossless — path segment", () => {
+		const t = compile("/files{/path}");
+		const url = "/files/a%2Fb";
+		const mOpaque = t.match(url, { encoding: "opaque" });
+		const mCooked = t.match(url, { encoding: "cooked" });
+		const mLoss = t.match(url, { encoding: "lossless" });
+		if (!mOpaque || !mCooked || !mLoss) throw new Error("match failed");
+		deepStrictEqual(mOpaque.vars.path, "a%2Fb");
+		deepStrictEqual(mCooked.vars.path, "a/b");
+		deepStrictEqual(mLoss.vars.path.raw, "a%2Fb");
+		deepStrictEqual(mLoss.vars.path.decoded, "a/b");
+	});
+	test("opaque vs cooked vs lossless — query (named, non-explode)", () => {
+		const t = compile("/s{?q}");
+		const url = "/s?q=a%20b";
+		const mo = t.match(url, { encoding: "opaque" });
+		const mc = t.match(url, { encoding: "cooked" });
+		const ml = t.match(url, { encoding: "lossless" });
+		if (!mo || !mc || !ml) throw new Error("match failed");
+		deepStrictEqual(mo.vars.q, "a%20b");
+		deepStrictEqual(mc.vars.q, "a b");
+		deepStrictEqual(ml.vars.q.raw, "a%20b");
+		deepStrictEqual(ml.vars.q.decoded, "a b");
+	});
+	test("opaque vs cooked — fragment (# operator)", () => {
+		const t = compile("{#frag}");
+		const url = "#a%2Fb%23c";
+		const mo = t.match(url, { encoding: "opaque" });
+		const mc = t.match(url, { encoding: "cooked" });
+		if (!mo || !mc) throw new Error("match failed");
+		deepStrictEqual(mo.vars.frag, "a%2Fb%23c");
+		deepStrictEqual(mc.vars.frag, "a/b#c");
+	});
+});
+describe("round-trip behavior", () => {
+	test("round-trip: opaque always byte-equal; cooked not guaranteed on non-canonical URLs", () => {
+		{
+			const t1 = compile("/repos{/owner,repo}{?q,lang}");
+			const url1 = "/repos/alice/hello%2Fworld?q=a%20b&lang=en";
+			const m1 = t1.match(url1, { encoding: "opaque" });
+			if (!m1) throw new Error("opaque match failed");
+			deepStrictEqual(t1.expand(m1.vars), url1);
+		}
+		{
+			const t2 = compile("/files{/path}");
+			const url2 = "/files/a%252Fb";
+			const m2 = t2.match(url2, { encoding: "cooked" });
+			if (!m2) throw new Error("cooked match failed");
+			notDeepStrictEqual(t2.expand(m2.vars), url2);
+		}
+	});
+	test("semantic round-trip holds for cooked", () => {
+		const t = compile("/u{/id}{?q}");
+		const vars = {
+			id: "a/b",
+			q: "x y"
+		};
+		const url = t.expand(vars);
+		const mc = t.match(url, { encoding: "cooked" });
+		if (!mc) throw new Error("cooked match failed");
+		deepStrictEqual(mc.vars, vars);
+	});
+});
+describe("lossless mode", () => {
+	test("lossless returns both forms and can re-expand either (non-canonical source)", () => {
+		const t = compile("/doc{/path}{?q}");
+		const nonCanonicalUrl = "/doc/a%252Fb?q=x%2520y";
+		const ml = t.match(nonCanonicalUrl, { encoding: "lossless" });
+		if (!ml) throw new Error("lossless match failed");
+		const { path, q } = ml.vars;
+		deepStrictEqual(path.raw, "a%252Fb");
+		deepStrictEqual(path.decoded, "a%2Fb");
+		deepStrictEqual(q.raw, "x%2520y");
+		deepStrictEqual(q.decoded, "x%20y");
+		const urlFromRaw = t.expand({
+			path: path.raw,
+			q: q.raw
+		});
+		const urlFromDec = t.expand({
+			path: path.decoded,
+			q: q.decoded
+		});
+		deepStrictEqual(urlFromRaw, nonCanonicalUrl);
+		notDeepStrictEqual(urlFromDec, nonCanonicalUrl);
+	});
+});
+describe("strict mode", () => {
+	test("strict mode: bad percent triplet fails; non-strict tolerates", () => {
+		const t = compile("/x{/id}");
+		const malformedPctTriplet = "/x/%GZ";
+		const mStrict = t.match(malformedPctTriplet, { encoding: "opaque" });
+		deepStrictEqual(mStrict, null);
+		const mLenient = t.match(malformedPctTriplet, {
+			encoding: "opaque",
+			strict: false
+		});
+		if (!mLenient) throw new Error("lenient match unexpectedly failed");
+		deepStrictEqual(mLenient.vars.id, "%GZ");
+	});
+});
+
+//#endregion

package/dist/parser.cjs

@@ -0,0 +1,102 @@
+const require_error = require('./error.cjs');
+
+//#region src/parser.ts
+/**
+* Parse a RFC 6570 URI template string into an AST.
+*
+* @param template - The URI template string to parse
+* @returns The parsed template AST
+* @throws {ParseError} If the template syntax is invalid
+*
+* @remarks
+* Parser guarantees:
+* - Balanced braces: every '{' has a matching '}' or throws ParseError
+* - Operator is one of "", "+", "#", ".", "/", ";", "?", "&"
+* - VarSpec list: "name[:prefix][*]" items separated by ','
+*
+* We avoid regex for correctness and slice the source directly to keep
+* raw segments intact for later matching.
+*
+* @example
+* ```typescript
+* const ast = parse("{+path}/here");
+* // Returns AST with expression (op: "+", vars: [{name: "path"}]) and literal ("/here") nodes
+* ```
+*
+* @example
+* ```typescript
+* const ast = parse("/repos{/owner,repo}{?q,lang}");
+* // Returns AST with literal and two expression nodes
+* ```
+*/
+function parse(template) {
+	const nodes = [];
+	let i = 0;
+	const pushLiteral = (start, end) => {
+		if (end > start) nodes.push({
+			kind: "literal",
+			value: template.slice(start, end),
+			start,
+			end
+		});
+	};
+	while (i < template.length) {
+		const litStart = i;
+		while (i < template.length && template[i] !== "{") i++;
+		pushLiteral(litStart, i);
+		if (i >= template.length) break;
+		const exprStart = i;
+		i++;
+		if (i >= template.length) throw new require_error.ParseError("Unclosed expression", exprStart);
+		const opChar = "+#./;?&".includes(template[i]) ? template[i++] : "";
+		const vars = [];
+		const readName = () => {
+			const start = i;
+			while (i < template.length && template[i] !== "}" && template[i] !== "," && template[i] !== ":" && template[i] !== "*") i++;
+			if (i === start) throw new require_error.ParseError("Empty variable name", i);
+			return template.slice(start, i);
+		};
+		while (true) {
+			const name = readName();
+			let explode = false;
+			let prefix;
+			if (template[i] === ":") {
+				i++;
+				const start = i;
+				while (i < template.length && /[0-9]/.test(template[i])) i++;
+				if (i === start) throw new require_error.ParseError("Expected prefix length", i);
+				prefix = parseInt(template.slice(start, i), 10);
+				if (!(prefix >= 0)) throw new require_error.ParseError("Invalid prefix length", start);
+			}
+			if (template[i] === "*") {
+				explode = true;
+				i++;
+			}
+			vars.push({
+				name,
+				explode,
+				prefix
+			});
+			if (template[i] === ",") {
+				i++;
+				continue;
+			}
+			if (template[i] === "}") {
+				i++;
+				break;
+			}
+			throw new require_error.ParseError("Unexpected character in expression", i);
+		}
+		nodes.push({
+			kind: "expression",
+			op: opChar,
+			vars,
+			start: exprStart,
+			end: i
+		});
+	}
+	return { nodes };
+}
+
+//#endregion
+exports.parse = parse;

package/dist/parser.d.cts

@@ -0,0 +1,35 @@
+import { TemplateAst } from "./ast.cjs";
+
+//#region src/parser.d.ts
+
+/**
+ * Parse a RFC 6570 URI template string into an AST.
+ *
+ * @param template - The URI template string to parse
+ * @returns The parsed template AST
+ * @throws {ParseError} If the template syntax is invalid
+ *
+ * @remarks
+ * Parser guarantees:
+ * - Balanced braces: every '{' has a matching '}' or throws ParseError
+ * - Operator is one of "", "+", "#", ".", "/", ";", "?", "&"
+ * - VarSpec list: "name[:prefix][*]" items separated by ','
+ *
+ * We avoid regex for correctness and slice the source directly to keep
+ * raw segments intact for later matching.
+ *
+ * @example
+ * ```typescript
+ * const ast = parse("{+path}/here");
+ * // Returns AST with expression (op: "+", vars: [{name: "path"}]) and literal ("/here") nodes
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const ast = parse("/repos{/owner,repo}{?q,lang}");
+ * // Returns AST with literal and two expression nodes
+ * ```
+ */
+declare function parse(template: string): TemplateAst;
+//#endregion
+export { parse };

package/dist/parser.d.ts

@@ -0,0 +1,35 @@
+import { TemplateAst } from "./ast.js";
+
+//#region src/parser.d.ts
+
+/**
+ * Parse a RFC 6570 URI template string into an AST.
+ *
+ * @param template - The URI template string to parse
+ * @returns The parsed template AST
+ * @throws {ParseError} If the template syntax is invalid
+ *
+ * @remarks
+ * Parser guarantees:
+ * - Balanced braces: every '{' has a matching '}' or throws ParseError
+ * - Operator is one of "", "+", "#", ".", "/", ";", "?", "&"
+ * - VarSpec list: "name[:prefix][*]" items separated by ','
+ *
+ * We avoid regex for correctness and slice the source directly to keep
+ * raw segments intact for later matching.
+ *
+ * @example
+ * ```typescript
+ * const ast = parse("{+path}/here");
+ * // Returns AST with expression (op: "+", vars: [{name: "path"}]) and literal ("/here") nodes
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const ast = parse("/repos{/owner,repo}{?q,lang}");
+ * // Returns AST with literal and two expression nodes
+ * ```
+ */
+declare function parse(template: string): TemplateAst;
+//#endregion
+export { parse };

package/dist/parser.js

@@ -0,0 +1,102 @@
+import { ParseError } from "./error.js";
+
+//#region src/parser.ts
+/**
+* Parse a RFC 6570 URI template string into an AST.
+*
+* @param template - The URI template string to parse
+* @returns The parsed template AST
+* @throws {ParseError} If the template syntax is invalid
+*
+* @remarks
+* Parser guarantees:
+* - Balanced braces: every '{' has a matching '}' or throws ParseError
+* - Operator is one of "", "+", "#", ".", "/", ";", "?", "&"
+* - VarSpec list: "name[:prefix][*]" items separated by ','
+*
+* We avoid regex for correctness and slice the source directly to keep
+* raw segments intact for later matching.
+*
+* @example
+* ```typescript
+* const ast = parse("{+path}/here");
+* // Returns AST with expression (op: "+", vars: [{name: "path"}]) and literal ("/here") nodes
+* ```
+*
+* @example
+* ```typescript
+* const ast = parse("/repos{/owner,repo}{?q,lang}");
+* // Returns AST with literal and two expression nodes
+* ```
+*/
+function parse(template) {
+	const nodes = [];
+	let i = 0;
+	const pushLiteral = (start, end) => {
+		if (end > start) nodes.push({
+			kind: "literal",
+			value: template.slice(start, end),
+			start,
+			end
+		});
+	};
+	while (i < template.length) {
+		const litStart = i;
+		while (i < template.length && template[i] !== "{") i++;
+		pushLiteral(litStart, i);
+		if (i >= template.length) break;
+		const exprStart = i;
+		i++;
+		if (i >= template.length) throw new ParseError("Unclosed expression", exprStart);
+		const opChar = "+#./;?&".includes(template[i]) ? template[i++] : "";
+		const vars = [];
+		const readName = () => {
+			const start = i;
+			while (i < template.length && template[i] !== "}" && template[i] !== "," && template[i] !== ":" && template[i] !== "*") i++;
+			if (i === start) throw new ParseError("Empty variable name", i);
+			return template.slice(start, i);
+		};
+		while (true) {
+			const name = readName();
+			let explode = false;
+			let prefix;
+			if (template[i] === ":") {
+				i++;
+				const start = i;
+				while (i < template.length && /[0-9]/.test(template[i])) i++;
+				if (i === start) throw new ParseError("Expected prefix length", i);
+				prefix = parseInt(template.slice(start, i), 10);
+				if (!(prefix >= 0)) throw new ParseError("Invalid prefix length", start);
+			}
+			if (template[i] === "*") {
+				explode = true;
+				i++;
+			}
+			vars.push({
+				name,
+				explode,
+				prefix
+			});
+			if (template[i] === ",") {
+				i++;
+				continue;
+			}
+			if (template[i] === "}") {
+				i++;
+				break;
+			}
+			throw new ParseError("Unexpected character in expression", i);
+		}
+		nodes.push({
+			kind: "expression",
+			op: opChar,
+			vars,
+			start: exprStart,
+			end: i
+		});
+	}
+	return { nodes };
+}
+
+//#endregion
+export { parse };