@fedify/uri-template 2.0.0-pr.475.1 → 2.3.0-dev.1137

package/dist/mod.cjs

@@ -0,0 +1,1901 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/router/errors.ts
+/**
+* Common base class for router-level errors.
+*/
+var RouterError = class extends Error {
+	/**
+	* @param message Human-readable summary.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "RouterError";
+	}
+};
+/**
+* Raised when a route template is not a path template.
+*/
+var RouteTemplatePathError = class extends RouterError {
+	template;
+	constructor(template) {
+		super("Path must start with a slash or a path expansion.");
+		this.template = template;
+		this.name = "RouteTemplatePathError";
+	}
+};
+/**
+* Raised when the same variable name appears in multiple variable
+* specifications whose modifiers imply contradictory `multiple` semantics
+* within a single route template (for example, `{x}` together with `{x*}`).
+*/
+var ConflictingVarSpecError = class extends RouterError {
+	template;
+	variable;
+	constructor(template, variable) {
+		super(`Variable "${variable}" has conflicting explode/prefix modifiers across the template "${template}".`);
+		this.template = template;
+		this.variable = variable;
+		this.name = "ConflictingVarSpecError";
+	}
+};
+/**
+* Raised under the default `exact` route option when the `variables` keys
+* do not exactly match the route template's variables: the set of supplied
+* keys must equal the set of template variables (no unknown keys, none
+* missing).  All mismatched names — both unknown and missing — are reported.
+*/
+var RouteTemplateOptionsNotMatchedError = class extends RouterError {
+	template;
+	variable;
+	constructor(template, variable) {
+		super(`Route options variables do not exactly match the template "${template}"; mismatched: ${variable.map((v) => `"${v}"`).join(", ")}.`);
+		this.template = template;
+		this.variable = variable;
+		this.name = "RouteTemplateOptionsNotMatchedError";
+	}
+};
+/**
+* Raised when a variable appears more than once in a route template while
+* its `duplicable` constraint is `false` (the default).
+*/
+var DuplicateRouteVariableError = class extends RouterError {
+	template;
+	variable;
+	constructor(template, variable) {
+		super(`Variable "${variable}" appears more than once in the template "${template}" but is not marked "duplicable: true".`);
+		this.template = template;
+		this.variable = variable;
+		this.name = "DuplicateRouteVariableError";
+	}
+};
+/**
+* Raised when a variable specification uses the explode (`*`) or prefix
+* (`:N`) modifier while the corresponding `explodable`/`prefixable`
+* constraint is `false` (the default).
+*/
+var DisallowedVarSpecModifierError = class extends RouterError {
+	template;
+	variable;
+	modifier;
+	constructor(template, variable, modifier) {
+		super(`Variable "${variable}" uses the ${modifier} modifier in the template "${template}" but is not marked "${modifier === "explode" ? "explodable" : "prefixable"}: true".`);
+		this.template = template;
+		this.variable = variable;
+		this.modifier = modifier;
+		this.name = "DisallowedVarSpecModifierError";
+	}
+};
+/**
+* Raised when a variable is used with an expression operator that is not in
+* its `operatables` allow-list.
+*/
+var DisallowedOperatorError = class extends RouterError {
+	template;
+	variable;
+	operator;
+	constructor(template, variable, operator) {
+		super(`Variable "${variable}" is used with the operator "${operator}" in the template "${template}", which is not in its "operatables" allow-list.`);
+		this.template = template;
+		this.variable = variable;
+		this.operator = operator;
+		this.name = "DisallowedOperatorError";
+	}
+};
+//#endregion
+//#region src/template/errors.ts
+/**
+* Errors raised when an RFC 6570 URI template fails to parse or expand.
+*
+* Parse-time hierarchy:
+*
+* ~~~~
+* TemplateParseError
+* ├── UnclosedExpressionError
+* ├── StrayClosingBraceError
+* ├── NestedOpeningBraceError
+* ├── EmptyExpressionError
+* ├── ReservedOperatorError
+* ├── UnknownOperatorError
+* ├── InvalidLiteralError
+* ├── InvalidVarSpecError
+* │   ├── EmptyVarNameError
+* │   ├── InvalidVarNameError
+* │   ├── InvalidPrefixError
+* │   └── TrailingCommaError
+* └── UnexpectedCharacterError
+* ~~~~
+*
+* Expansion-time hierarchy:
+*
+* ~~~~
+* TemplateExpansionError
+* └── PrefixModifierNotApplicableError
+* ~~~~
+*
+* Parse errors carry the original `template` and the 0-based `position` where
+* the offending input was located. Expansion errors carry the runtime variable
+* name whose value cannot be expanded.
+*
+* @module
+*/
+/**
+* Common base class for every parse-time error produced by the RFC 6570 parser.
+*/
+var TemplateParseError = class extends Error {
+	template;
+	position;
+	hint;
+	/**
+	* @param template     The full URI template string that was being parsed.
+	* @param position     0-based index into `template` where the problem was
+	*                     detected.  When the offending input spans a range,
+	*                     this is the start of that range.
+	* @param hint         Short, actionable instruction for the user.
+	* @param message      Human-readable summary.
+	*/
+	constructor(template, position, hint, message) {
+		super(`${message} (at position ${position}): ${hint}`);
+		this.template = template;
+		this.position = position;
+		this.hint = hint;
+		this.name = "TemplateParseError";
+	}
+};
+/**
+* Raised when an opening `{` has no matching `}` before the template ends.
+*
+* Fix: close the expression with `}` or pct-encode the literal `{` as `%7B`.
+* RFC 6570 does not define an escape syntax.
+*/
+var UnclosedExpressionError = class extends TemplateParseError {
+	constructor(template, position) {
+		super(template, position, "Add the missing '}' to close the expression, or remove the stray '{'.", "Unclosed expression: '{' has no matching '}'");
+		this.name = "UnclosedExpressionError";
+	}
+};
+/**
+* Raised when a `}` appears outside of any expression.
+*
+* Fix: remove the stray `}` or precede it with a matching `{`.
+*/
+var StrayClosingBraceError = class extends TemplateParseError {
+	constructor(template, position) {
+		super(template, position, "Remove this stray '}' or add a matching '{' before it.", "Stray '}' outside of any expression");
+		this.name = "StrayClosingBraceError";
+	}
+};
+/**
+* Raised when a `{` appears inside another expression before that expression
+* is closed.  RFC 6570 expressions cannot nest.
+*
+* Fix: close the outer expression with `}` before opening a new one.
+*/
+var NestedOpeningBraceError = class extends TemplateParseError {
+	constructor(template, position) {
+		super(template, position, "RFC 6570 expressions cannot nest. Close the outer expression with '}' before starting a new one.", "Nested '{' inside an unclosed expression");
+		this.name = "NestedOpeningBraceError";
+	}
+};
+/**
+* Raised when a literal section of the template contains a character that is
+* outside the RFC 6570 `literals` set: CTL, SP, `"`, `'`, lone `%`, `<`, `>`,
+* `\\`, `^`, `` ` ``, `|`.
+*
+* Fix: pct-encode the offending character or remove it.
+*/
+var InvalidLiteralError = class extends TemplateParseError {
+	char;
+	constructor(template, position, char) {
+		super(template, position, `Pct-encode '${char}' (e.g. '%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}') or remove it. Literals may not contain CTL, SP, '\"', '\\'', lone '%', '<', '>', '\\\\', '^', '\`', or '|'.`, `Invalid literal character '${char}'`);
+		this.char = char;
+		this.name = "InvalidLiteralError";
+	}
+};
+/**
+* Raised for `{}` — an expression that contains neither operator nor varspec.
+*
+* Fix: insert at least one varname between the braces, e.g. `{var}`.
+*/
+var EmptyExpressionError = class extends TemplateParseError {
+	constructor(template, position) {
+		super(template, position, "Provide at least one varname inside the braces, e.g. '{var}'.", "Empty expression '{}'");
+		this.name = "EmptyExpressionError";
+	}
+};
+/**
+* Raised when the operator slot holds one of the characters reserved by
+* RFC 6570 §2.2 for future extensions: `=`, `,`, `!`, `@`, `|`.
+*
+* Fix: drop the reserved operator or replace it with one of the implemented
+* operators (`+`, `#`, `.`, `/`, `;`, `?`, `&`).
+*/
+var ReservedOperatorError = class extends TemplateParseError {
+	operator;
+	constructor(template, position, operator) {
+		super(template, position, `Operator '${operator}' is reserved by RFC 6570 §2.2 for future extensions. Use one of '+', '#', '.', '/', ';', '?', '&' instead, or remove the operator.`, `Reserved operator '${operator}'`);
+		this.operator = operator;
+		this.name = "ReservedOperatorError";
+	}
+};
+/**
+* Raised when the operator slot holds a character that is neither a defined
+* RFC 6570 operator nor part of the varname grammar.
+*
+* Fix: use one of the implemented operators (`+`, `#`, `.`, `/`, `;`, `?`,
+* `&`) or remove the character.
+*/
+var UnknownOperatorError = class extends TemplateParseError {
+	operator;
+	constructor(template, position, operator) {
+		super(template, position, `Replace '${operator}' with one of '+', '#', '.', '/', ';', '?', '&' or remove it.`, `Unknown operator '${operator}'`);
+		this.operator = operator;
+		this.name = "UnknownOperatorError";
+	}
+};
+/**
+* Common base for malformed varspec errors so users can `instanceof`-filter.
+*/
+var InvalidVarSpecError = class extends TemplateParseError {
+	varSpec;
+	constructor(template, position, hint, message, varSpec) {
+		super(template, position, hint, message);
+		this.varSpec = varSpec;
+		this.name = "InvalidVarSpecError";
+	}
+};
+/**
+* Raised when a varspec contains no varname (e.g. `{,foo}` or `{foo,}`).
+*/
+var EmptyVarNameError = class extends InvalidVarSpecError {
+	constructor(template, position) {
+		super(template, position, "Remove the stray comma or insert a varname before/after it.", "Empty varname in variable-list", "");
+		this.name = "EmptyVarNameError";
+	}
+};
+/**
+* Raised when a varname contains characters outside the RFC 6570 varchar set
+* (`ALPHA / DIGIT / "_" / pct-encoded`, optionally separated by `.`).
+*/
+var InvalidVarNameError = class extends InvalidVarSpecError {
+	offendingChar;
+	constructor(template, position, varSpec, offendingChar) {
+		super(template, position, `Varnames may only contain ALPHA, DIGIT, '_', '.', or pct-encoded triplets. Replace '${offendingChar}' or pct-encode it.`, `Invalid character '${offendingChar}' in varname`, varSpec);
+		this.offendingChar = offendingChar;
+		this.name = "InvalidVarNameError";
+	}
+};
+/**
+* Raised when a prefix modifier (`:N`) is malformed: missing digits, leading
+* zero, or `N` outside the range `1..9999`.
+*/
+var InvalidPrefixError = class extends InvalidVarSpecError {
+	prefix;
+	constructor(template, position, varSpec, prefix) {
+		super(template, position, "Prefix modifiers must be ':N' where N is a positive integer in 1..9999 with no leading zero (e.g. ':3').", `Invalid prefix modifier ':${prefix}'`, varSpec);
+		this.prefix = prefix;
+		this.name = "InvalidPrefixError";
+	}
+};
+/**
+* Raised when a varspec ends with a trailing comma followed by `}` or end of
+* variable-list (e.g. `{a,b,}`).
+*/
+var TrailingCommaError = class extends InvalidVarSpecError {
+	constructor(template, position) {
+		super(template, position, "Remove the trailing comma, or add a varspec after it.", "Trailing ',' in variable-list", "");
+		this.name = "TrailingCommaError";
+	}
+};
+/**
+* Raised when an unexpected character appears between a varspec and the next
+* separator (`,` or `}`), e.g. `{a b}` or `{a:3x}`.
+*/
+var UnexpectedCharacterError = class extends TemplateParseError {
+	char;
+	constructor(template, position, char) {
+		super(template, position, "Expected ',' or '}' here. Remove the unexpected character or pct-encode it if it belongs in the varname.", `Unexpected character '${char}' in expression`);
+		this.char = char;
+		this.name = "UnexpectedCharacterError";
+	}
+};
+/**
+* Common base class for runtime expansion errors.
+*/
+var TemplateExpansionError = class extends Error {
+	variableName;
+	hint;
+	/**
+	* @param variableName The variable whose resolved value cannot be expanded.
+	* @param hint Short, actionable instruction for the user.
+	* @param message Human-readable summary.
+	*/
+	constructor(variableName, hint, message) {
+		super(`${message} for '${variableName}': ${hint}`);
+		this.variableName = variableName;
+		this.hint = hint;
+		this.name = "TemplateExpansionError";
+	}
+};
+/**
+* Raised when a prefix modifier is applied to a composite value.
+*
+* RFC 6570 §2.4.1 defines prefix modifiers for string values only; lists and
+* associative arrays must use normal or explode expansion instead.
+*/
+var PrefixModifierNotApplicableError = class extends TemplateExpansionError {
+	prefix;
+	valueType;
+	constructor(variableName, prefix, valueType) {
+		super(variableName, "Remove the prefix modifier from this varspec, or provide a string value instead of a composite value.", `Prefix modifier ':${prefix}' is not applicable to ${valueType} values`);
+		this.prefix = prefix;
+		this.valueType = valueType;
+		this.name = "PrefixModifierNotApplicableError";
+	}
+};
+//#endregion
+//#region src/const.ts
+/**
+* Operators implemented by this package, including `""` for simple string
+* expansion with no explicit operator.
+*/
+const OPERATORS = [
+	"",
+	"+",
+	".",
+	"/",
+	";",
+	"?",
+	"&",
+	"#"
+];
+/**
+* RFC 6570 operator behavior table used during expansion.
+* This table is from RFC 6570 Appendix A.
+*
+* |       | `NUL`   | `+`     | `.`     | `/`     | `;`    | `?`    | `&`    | `#`     |
+* | ----- | ------- | ------- | ------- | ------- | ------ | ------ | ------ | ------- |
+* | first | `""`    | `""`    | `"."`   | `"/"`   | `";"`  | `"?"`  | `"&"`  | `"#"`   |
+* | sep   | `","`   | `","`   | `"."`   | `"/"`   | `";"`  | `"&"`  | `"&"`  | `","`   |
+* | named | `false` | `false` | `false` | `false` | `true` | `true` | `true` | `false` |
+* | ifemp | `""`    | `""`    | `""`    | `""`    | `""`   | `"="`  | `"="`  | `""`    |
+* | allow | `U`     | `U+R`   | `U`     | `U`     | `U`    | `U`    | `U`    | `U+R`   |
+*/
+const operatorSpecs = {
+	"": {
+		first: "",
+		sep: ",",
+		named: false,
+		ifEmpty: "",
+		allowReserved: false
+	},
+	"+": {
+		first: "",
+		sep: ",",
+		named: false,
+		ifEmpty: "",
+		allowReserved: true
+	},
+	".": {
+		first: ".",
+		sep: ".",
+		named: false,
+		ifEmpty: "",
+		allowReserved: false
+	},
+	"/": {
+		first: "/",
+		sep: "/",
+		named: false,
+		ifEmpty: "",
+		allowReserved: false
+	},
+	";": {
+		first: ";",
+		sep: ";",
+		named: true,
+		ifEmpty: "",
+		allowReserved: false
+	},
+	"?": {
+		first: "?",
+		sep: "&",
+		named: true,
+		ifEmpty: "=",
+		allowReserved: false
+	},
+	"&": {
+		first: "&",
+		sep: "&",
+		named: true,
+		ifEmpty: "=",
+		allowReserved: false
+	},
+	"#": {
+		first: "#",
+		sep: ",",
+		named: false,
+		ifEmpty: "",
+		allowReserved: true
+	}
+};
+//#endregion
+//#region src/template/encoding.ts
+const textEncoder = new TextEncoder();
+const hexDigits = "0123456789ABCDEF";
+/**
+* Returns whether a character is an RFC 3986 hexadecimal digit.
+*
+* Used by parsers and encoders when recognizing pct-encoded triplets.
+*/
+const isHexDigit = (char) => some(between(48, 57), between(65, 70), between(97, 102))(char.charCodeAt(0));
+/**
+* Returns whether `value[index]` starts a complete pct-encoded triplet.
+*/
+const isPctEncodedAt = (value, index) => value[index] === "%" && index + 2 < value.length && isHexDigit(value[index + 1]) && isHexDigit(value[index + 2]);
+/**
+* Returns the UTF-16 length of an RFC 6570 `varchar` at `index`, or `0` when
+* no varchar starts there.
+*/
+function isVarcharAt(value, index) {
+	const char = value[index];
+	if (char == null) return 0;
+	if (some(isAlpha, isDigit$1, eq("_"))(char)) return 1;
+	return isPctEncodedAt(value, index) ? 3 : 0;
+}
+/**
+* Returns the UTF-16 length of an RFC 6570 literal token at `index`, or `0`
+* when the character is not valid literal syntax.
+*/
+function isLiteralAt(value, index) {
+	if (isPctEncodedAt(value, index)) return 3;
+	const { char, size } = readCodePoint(value, index);
+	return isLiteralChar(char) ? size : 0;
+}
+/**
+* Reads one Unicode code point from a JavaScript string.
+*/
+function readCodePoint(value, index) {
+	const codePoint = value.codePointAt(index);
+	if (codePoint == null) return {
+		char: "",
+		size: 0
+	};
+	const size = codePoint > 65535 ? 2 : 1;
+	return {
+		char: value.slice(index, index + size),
+		size
+	};
+}
+/**
+* Percent-encodes an expanded variable value according to the operator's
+* allowed-character rule.
+*/
+const encodeValue = (allowReserved) => (value) => {
+	let encoded = "";
+	for (let index = 0; index < value.length;) {
+		if (allowReserved && isPctEncodedAt(value, index)) {
+			encoded += value.slice(index, index + 3);
+			index += 3;
+			continue;
+		}
+		const { char, size } = readCodePoint(value, index);
+		encoded += some(isUnreserved, (char) => allowReserved && isReserved(char))(char) ? char : percentEncode(char);
+		index += size;
+	}
+	return encoded;
+};
+/**
+* Percent-encodes a variable name or associative key for named expansions.
+*/
+function encodeName(value) {
+	let encoded = "";
+	for (let index = 0; index < value.length;) {
+		if (isPctEncodedAt(value, index)) {
+			encoded += value.slice(index, index + 3);
+			index += 3;
+			continue;
+		}
+		const { char, size } = readCodePoint(value, index);
+		encoded += isUnreserved(char) ? char : percentEncode(char);
+		index += size;
+	}
+	return encoded;
+}
+/**
+* Returns the first `length` RFC 6570 prefix characters without splitting a
+* Unicode code point or a pct-encoded triplet.
+*/
+function truncateValue(value, length) {
+	let truncated = "";
+	let count = 0;
+	for (let index = 0; index < value.length && count < length; count++) {
+		if (isPctEncodedAt(value, index)) {
+			truncated += value.slice(index, index + 3);
+			index += 3;
+			continue;
+		}
+		const { char, size } = readCodePoint(value, index);
+		truncated += char;
+		index += size;
+	}
+	return truncated;
+}
+const isAlpha = (char) => some(between(65, 90), between(97, 122))(char.charCodeAt(0));
+const isDigit$1 = (char) => between(48, 57)(char.charCodeAt(0));
+const isUnreserved = (char) => some(isAlpha, isDigit$1, (char) => "-._~".includes(char))(char);
+const isReserved = (char) => ":/?#[]@!$&'()*+,;=".includes(char);
+const isLiteralChar = (char) => isLiteralCodePoint(char.codePointAt(0));
+const isLiteralCodePoint = (code) => code != null && some(eq(33), between(35, 36), eq(38), between(40, 59), eq(61), between(63, 91), eq(93), eq(95), between(97, 122), eq(126), isUcsChar, isIPrivate)(code);
+function isUcsChar(code) {
+	if (code < 65536) return some(between(160, 55295), between(63744, 64975), between(65008, 65519))(code);
+	if (code > 983037) return false;
+	const offset = code % 65536;
+	return offset <= 65533 && (code < 917504 || offset >= 4096);
+}
+const isIPrivate = (code) => some(between(57344, 63743), between(983040, 1048573), between(1048576, 1114109))(code);
+const percentEncode = (char) => Array.from(textEncoder.encode(char)).map((byte) => `%${hexDigits[byte >> 4]}${hexDigits[byte & 15]}`).join("");
+const between = (min, max) => (num) => min <= num && num <= max;
+const eq = (a) => (b) => a === b;
+const some = (...preds) => (arg) => preds.some((pred) => pred(arg));
+//#endregion
+//#region src/template/expand.ts
+/**
+* Expands one parsed URI Template expression against the supplied variable
+* context using the operator behavior table from RFC 6570.
+*/
+function expand(tokens, context, options) {
+	return tokens.map((token) => token.kind === "literal" ? token.text : expandExpressions(token.vars, token.operator, context, options)).join("");
+}
+function expandExpressions(vars, operator, context, options) {
+	const spec = operatorSpecs[operator];
+	const parts = vars.flatMap((varSpec) => expandValue(varSpec, context[varSpec.name], spec, options));
+	return parts.length < 1 ? "" : `${spec.first}${parts.join(spec.sep)}`;
+}
+function expandValue(varSpec, value, spec, options) {
+	if (value == null) return [];
+	if (isPrimitiveList(value)) {
+		const encoded = encodeListMembers(value, spec.allowReserved);
+		if (encoded.length < 1) return [];
+		if (!reportPrefixModifierError(varSpec, "list", options)) return [];
+		return expandList(varSpec, encoded, spec);
+	}
+	if (isAssociative$1(value)) {
+		const pairs = encodeAssociativePairs(value, spec.allowReserved);
+		if (pairs.length < 1) return [];
+		if (!reportPrefixModifierError(varSpec, "associative", options)) return [];
+		return expandAssociative(varSpec, pairs, spec);
+	}
+	return expandPrimitive(varSpec, value, spec);
+}
+function expandPrimitive(varSpec, value, spec) {
+	const text = String(value);
+	const prefixed = varSpec.prefix == null ? text : truncateValue(text, varSpec.prefix);
+	const encoded = encodeValue(spec.allowReserved)(prefixed);
+	if (!spec.named) return [encoded];
+	return [expandNamedPair(encodeName(varSpec.name), encoded, spec)];
+}
+function expandList(varSpec, encoded, spec) {
+	const name = encodeName(varSpec.name);
+	if (varSpec.explode) return spec.named ? encoded.map((item) => expandNamedPair(name, item, spec)) : [...encoded];
+	const joined = encoded.join(",");
+	return spec.named ? [expandNamedPair(name, joined, spec)] : [joined];
+}
+function expandAssociative(varSpec, pairs, spec) {
+	if (varSpec.explode) return pairs.map(([key, item]) => expandNamedPair(key, item, spec));
+	const item = pairs.flat(1).join(",");
+	if (!spec.named) return [item];
+	return [expandNamedPair(encodeName(varSpec.name), item, spec)];
+}
+const expandNamedPair = (key, item, spec) => item === "" ? `${key}${spec.ifEmpty}` : `${key}=${item}`;
+const encodeListMembers = (value, allowReserved) => value.filter((item) => item != null).map(String).map(encodeValue(allowReserved));
+const encodeAssociativePairs = (value, allowReserved) => Object.entries(value).map(([key, item]) => [key, normalizePairValue(item)]).filter(([, normalized]) => normalized != null).map((kv) => kv.map(encodeValue(allowReserved)));
+function normalizePairValue(value) {
+	if (value == null) return null;
+	if (!Array.isArray(value)) return String(value);
+	const items = value.filter((item) => item != null).map(String);
+	return items.length < 1 ? null : items.join(",");
+}
+const isAssociative$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPrimitiveList = (value) => Array.isArray(value);
+function reportPrefixModifierError(varSpec, valueType, { report, strict }) {
+	if (varSpec.prefix == null) return true;
+	const error = new PrefixModifierNotApplicableError(varSpec.name, varSpec.prefix, valueType);
+	report(error);
+	if (strict) throw error;
+	return false;
+}
+//#endregion
+//#region src/template/match.ts
+/**
+* Matches a URI against a parsed URI template and extracts variable bindings.
+*
+* The inverse of {@link expand}: given the token stream produced by parsing a
+* template and a concrete URI, recovers an {@link ExpandContext} such that
+* re-expanding the template with that context reproduces the original URI.
+*
+* @param tokens The parsed template tokens to match against.
+* @param uri The concrete URI to decompose.
+* @param options Template options shared with the expansion side.
+* @returns The recovered variable context, or `null` if the URI does not match
+*   the template under any interpretation.
+*/
+function match(tokens, uri, options) {
+	return matchTokens(tokens, uri, options, 0, 0, {});
+}
+/**
+* Walks the token stream and the URI in lockstep, backtracking over every
+* candidate decomposition until one survives roundtrip verification.
+*
+* Literal tokens advance deterministically; expression tokens fan out across
+* all viable end positions and value interpretations. When the token stream is
+* exhausted, the accumulated bindings are accepted only if re-expanding the
+* template with them yields the original URI exactly — this is what filters
+* out the spurious interpretations that the permissive parsing stage admits.
+*
+* @returns The first surviving context, or `null` if every branch fails.
+*/
+function matchTokens(tokens, uri, options, tokenIndex, uriIndex, bindings) {
+	if (tokenIndex >= tokens.length) {
+		if (uriIndex !== uri.length) return null;
+		const context = toExpandContext(bindings);
+		return expand(tokens, context, options) === uri ? context : null;
+	}
+	const token = tokens[tokenIndex];
+	if (token.kind === "literal") return uri.startsWith(token.text, uriIndex) ? matchTokens(tokens, uri, options, tokenIndex + 1, uriIndex + token.text.length, bindings) : null;
+	for (const end of expressionEnds(tokens, uri, tokenIndex, uriIndex)) {
+		const expression = uri.slice(uriIndex, end);
+		for (const expressionBindings of matchExpression(token.vars, token.operator, expression)) {
+			const merged = mergeBindings(bindings, expressionBindings);
+			if (merged == null) continue;
+			const result = matchTokens(tokens, uri, options, tokenIndex + 1, end, merged);
+			if (result != null) return result;
+		}
+	}
+	return null;
+}
+/**
+* Generates candidate end positions in the URI for the expression token at
+* `tokenIndex`, using the next non-empty literal token as a search anchor.
+*
+* If no following literal exists the expression may run to the end of the URI,
+* so every position from the URI end back to `uriIndex` is yielded (longest
+* first, biasing the search toward greedy matches). Otherwise only the offsets
+* where the next literal appears are returned, which prunes the search space
+* dramatically in templates with structural separators.
+*/
+function* expressionEnds(tokens, uri, tokenIndex, uriIndex) {
+	const nextLiteral = tokens.slice(tokenIndex + 1).find((token) => token.kind === "literal" && token.text !== "");
+	if (nextLiteral == null || nextLiteral.kind !== "literal") {
+		yield* range(uri.length, uriIndex);
+		return;
+	}
+	for (let index = uri.indexOf(nextLiteral.text, uriIndex); index >= 0; index = uri.indexOf(nextLiteral.text, index + 1)) yield index;
+}
+function* range(from, to) {
+	for (let value = from; value >= to; value--) yield value;
+}
+/**
+* Decomposes a single expression substring into every plausible binding set.
+*
+* Validates the operator's leading sigil (`?`, `#`, `/`, etc.), strips it, and
+* dispatches to the named or unnamed parser based on the operator spec. The
+* empty-expression case is delegated to {@link matchEmptyExpression}, which
+* decides when an empty expression substring may be read back as an
+* empty-string binding rather than as no binding at all.
+*/
+function* matchExpression(vars, operator, expression) {
+	if (expression === "") {
+		yield* matchEmptyExpression(vars, operator);
+		return;
+	}
+	const spec = operatorSpecs[operator];
+	if (!expression.startsWith(spec.first)) return;
+	const body = expression.slice(spec.first.length);
+	yield* spec.named ? matchNamedExpression(vars, spec, body) : matchUnnamedExpression(vars, spec, body);
+}
+const matchEmptyExpression = (vars, operator) => {
+	if ((operator === "" || operator === "+") && vars.length === 1) return [bindValue(vars[0], "")];
+	return [{}];
+};
+const matchUnnamedExpression = (vars, spec, body) => matchUnnamedFrom(vars, spec, split(body, spec.sep), 0, 0);
+/**
+* Distributes the separator-split parts of an unnamed expression across the
+* remaining variables via backtracking.
+*
+* For each variable, every contiguous slice of parts that respects the
+* `minLength`/`maxLength` budget is tried as that variable's value, and the
+* variable may also be skipped entirely (consuming zero parts) to handle
+* undefined variables in the template. Surviving combinations are yielded for
+* the caller to filter.
+*/
+function* matchUnnamedFrom(vars, spec, parts, varIndex, partIndex) {
+	if (varIndex >= vars.length) {
+		if (partIndex >= parts.length) yield {};
+		return;
+	}
+	const varSpec = vars[varIndex];
+	for (const consumed of consumeUnnamed(varSpec, spec, parts, partIndex)) for (const rest of matchUnnamedFrom(vars, spec, parts, varIndex + 1, consumed.index)) {
+		const merged = mergeBindings(consumed.bindings, rest);
+		if (merged != null) yield merged;
+	}
+	yield* matchUnnamedFrom(vars, spec, parts, varIndex + 1, partIndex);
+}
+/**
+* Enumerates every (binding, next-part-index) pair produced by letting one
+* unnamed variable consume any number of remaining parts.
+*/
+function* consumeUnnamed(varSpec, spec, parts, partIndex) {
+	if (partIndex >= parts.length) return;
+	const maxLength = parts.length - partIndex;
+	for (let length = 1; length <= maxLength; length++) {
+		const slice = parts.slice(partIndex, partIndex + length);
+		for (const bindings of parseUnnamedValue(varSpec, spec, slice)) yield {
+			bindings,
+			index: partIndex + length
+		};
+	}
+}
+/**
+* Yields every binding interpretation of a slice assigned to one unnamed
+* variable: scalar, comma-list, associative, and (for explode) an
+* exploded list or associative reading of the same parts.
+*
+* Prefix-bound variables collapse to the scalar reading only.
+*/
+function* parseUnnamedValue(varSpec, spec, parts) {
+	const nonExploded = parseNonExplodedValue(varSpec, spec, parts.join(spec.sep));
+	if (varSpec.prefix != null) {
+		yield* nonExploded;
+		return;
+	}
+	if (varSpec.explode && parts.length > 0) yield* parseExplodedUnnamed(varSpec, spec, parts);
+	yield* nonExploded;
+}
+function* parseExplodedUnnamed(varSpec, spec, parts) {
+	const decodedList = decodeValues(parts, spec.allowReserved);
+	if (decodedList == null) return;
+	const object = parseExplodedAssociative(parts, spec);
+	if (object != null) yield bindValue(varSpec, object);
+	yield bindValue(varSpec, decodedList);
+}
+const parseExplodedAssociative = (parts, spec) => parseExplodedAssociativeBody(parts.join(spec.sep), spec);
+function parseExplodedAssociativeBody(body, spec) {
+	const entries = [];
+	for (let index = 0; index < body.length;) {
+		const equals = body.indexOf("=", index);
+		if (equals < 0) return null;
+		const valueStart = equals + 1;
+		const valueEnd = findExplodedPairBoundary(body, valueStart, spec.sep);
+		const key = decodeValue(body.slice(index, equals), spec.allowReserved);
+		const value = decodeValue(body.slice(valueStart, valueEnd), spec.allowReserved);
+		if (key == null || value == null) return null;
+		entries.push([key, value]);
+		index = valueEnd + spec.sep.length;
+	}
+	return entries.length < 1 ? null : Object.fromEntries(entries);
+}
+function findExplodedPairBoundary(body, start, separator) {
+	for (let index = start; index < body.length; index++) if (isExplodedPairBoundary(body, index, separator)) return index;
+	return body.length;
+}
+const isExplodedPairBoundary = (body, index, separator) => {
+	if (!body.startsWith(separator, index)) return false;
+	const keyStart = index + separator.length;
+	for (let i = keyStart; i < body.length; i++) {
+		if (body[i] === "=") return i > keyStart;
+		if (body.startsWith(separator, i)) return false;
+	}
+	return false;
+};
+/**
+* Yields candidate readings of a single value string under non-exploded
+* encoding: scalar, comma-separated list, and (when an even element count
+* permits) comma-separated associative array. Some candidates will not
+* round-trip — for instance a comma-bearing scalar gets re-encoded with
+* `%2C` on expansion — and are filtered out by the roundtrip check in
+* {@link matchTokens}.
+*
+* The yielded bindings are ordered from most structured to least, so the
+* surrounding backtracking tries the richer interpretations before the scalar
+* one.
+*/
+function* parseNonExplodedValue(varSpec, spec, value) {
+	const primitive = decodeValue(value, spec.allowReserved);
+	if (primitive == null) return;
+	const primitiveBinding = bindValue(varSpec, primitive);
+	if (varSpec.prefix != null) {
+		yield primitiveBinding;
+		return;
+	}
+	const commaParts = split(value, ",");
+	if (commaParts.length < 2) {
+		yield primitiveBinding;
+		return;
+	}
+	const decodedList = decodeValues(commaParts, spec.allowReserved);
+	if (decodedList == null) {
+		yield primitiveBinding;
+		return;
+	}
+	const associative = commaParts.length % 2 === 0 ? parseAssociative(commaParts, spec.allowReserved) : null;
+	if (associative != null) yield bindValue(varSpec, associative);
+	yield bindValue(varSpec, decodedList);
+	yield primitiveBinding;
+}
+const matchNamedExpression = (vars, spec, body) => matchNamedFrom(vars, spec, split(body, spec.sep).map(splitNamedPart), 0, 0);
+/**
+* Named-expression counterpart of {@link matchUnnamedFrom}: backtracks over
+* `name=value` parts assigning them to declared variables.
+*
+* Like the unnamed variant, each variable may either consume a contiguous run
+* of parts (via {@link consumeNamed}) or be skipped entirely so that variables
+* absent from the URI remain unbound.
+*/
+function* matchNamedFrom(vars, spec, parts, varIndex, partIndex) {
+	if (varIndex >= vars.length) {
+		if (partIndex >= parts.length) yield {};
+		return;
+	}
+	const varSpec = vars[varIndex];
+	for (const consumed of consumeNamed(varSpec, spec, parts, partIndex, vars)) for (const rest of matchNamedFrom(vars, spec, parts, varIndex + 1, consumed.index)) {
+		const merged = mergeBindings(consumed.bindings, rest);
+		if (merged != null) yield merged;
+	}
+	yield* matchNamedFrom(vars, spec, parts, varIndex + 1, partIndex);
+}
+function* consumeNamed(varSpec, spec, parts, partIndex, vars) {
+	if (partIndex >= parts.length) return;
+	if (varSpec.explode && varSpec.prefix == null) {
+		yield* consumeExplodedNamed(varSpec, spec, parts, partIndex, vars);
+		return;
+	}
+	yield* consumeNamedValue(varSpec, spec, parts, partIndex);
+}
+function* consumeNamedValue(varSpec, spec, parts, partIndex) {
+	const part = parts[partIndex];
+	if (part.name !== encodeName(varSpec.name)) return;
+	for (const bindings of parseNonExplodedValue(varSpec, spec, part.value)) yield {
+		bindings,
+		index: partIndex + 1
+	};
+}
+function* consumeExplodedNamed(varSpec, spec, parts, partIndex, vars) {
+	yield* consumeNamedList(varSpec, spec, parts, partIndex);
+	yield* consumeNamedAssociative(varSpec, spec, parts, partIndex, vars);
+}
+/**
+* Reads consecutive parts that share the variable's name, decoding each as a
+* list element. Used for the explode-as-list interpretation of a named
+* variable.
+*/
+function* consumeNamedList(varSpec, spec, parts, partIndex) {
+	const values = [...namedListValues(encodeName(varSpec.name), spec, parts, partIndex)];
+	if (values.length > 0) yield {
+		bindings: bindValue(varSpec, values),
+		index: partIndex + values.length
+	};
+}
+function* namedListValues(name, spec, parts, partIndex) {
+	for (let index = partIndex; index < parts.length && parts[index].name === name; index++) {
+		const value = decodeValue(parts[index].value, spec.allowReserved);
+		if (value == null) return;
+		yield value;
+	}
+}
+/**
+* Reads consecutive parts as `key=value` entries of an associative array under
+* one named exploded variable.
+*
+* After the first part, stops as soon as a part's name matches any declared
+* variable so that those parts remain available for their own variables. The
+* first part is always consumed regardless of name to bootstrap the
+* association.
+*/
+function* consumeNamedAssociative(varSpec, spec, parts, partIndex, vars) {
+	const entries = [...namedAssociativeEntries(spec, parts, partIndex, new Set(vars.map((item) => encodeName(item.name))))];
+	if (entries.length > 0) yield {
+		bindings: bindValue(varSpec, Object.fromEntries(entries)),
+		index: partIndex + entries.length
+	};
+}
+function* namedAssociativeEntries(spec, parts, partIndex, reservedNames) {
+	for (let index = partIndex; index < parts.length; index++) {
+		const part = parts[index];
+		if (index > partIndex && reservedNames.has(part.name)) return;
+		const key = decodeValue(part.name, spec.allowReserved);
+		const value = decodeValue(part.value, spec.allowReserved);
+		if (key == null || value == null) return;
+		yield [key, value];
+	}
+}
+function splitNamedPart(part) {
+	const equals = part.indexOf("=");
+	return equals < 0 ? {
+		name: part,
+		value: ""
+	} : {
+		name: part.slice(0, equals),
+		value: part.slice(equals + 1)
+	};
+}
+function parseAssociative(parts, allowReserved) {
+	const entries = [];
+	for (let index = 0; index < parts.length; index += 2) {
+		const key = decodeValue(parts[index], allowReserved);
+		const value = decodeValue(parts[index + 1], allowReserved);
+		if (key == null || value == null) return null;
+		entries.push([key, value]);
+	}
+	return Object.fromEntries(entries);
+}
+function decodeValues(values, allowReserved) {
+	const decoded = [];
+	for (const value of values) {
+		const item = decodeValue(value, allowReserved);
+		if (item == null) return null;
+		decoded.push(item);
+	}
+	return decoded;
+}
+function decodeValue(value, allowReserved) {
+	if (allowReserved) return value;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return null;
+	}
+}
+const bindValue = ({ name, prefix }, value) => ({ [name]: {
+	value,
+	prefix
+} });
+/**
+* Combines two binding sets, returning `null` if any shared variable receives
+* incompatible values across them.
+*
+* Equality of values and prefix-aware compatibility (one binding being a
+* truncation of the other) are both delegated to {@link mergeBinding}.
+*/
+function mergeBindings(left, right) {
+	const merged = { ...left };
+	for (const [name, binding] of Object.entries(right)) {
+		const existing = merged[name];
+		if (existing == null) {
+			merged[name] = binding;
+			continue;
+		}
+		const next = mergeBinding(existing, binding);
+		if (next == null) return null;
+		merged[name] = next;
+	}
+	return merged;
+}
+const mergeBinding = (left, right) => isPrefixBinding(left) || isPrefixBinding(right) ? mergePrefixBinding(left, right) : equalExpandValue(left.value, right.value) ? left : null;
+/**
+* Reconciles two bindings when at least one carries a prefix limit, by
+* checking that the truncation of the longer (or unrestricted) value matches
+* the shorter prefixed value.
+*
+* Returns the binding that carries the more complete information, or `null`
+* when no consistent reading exists or non-string values are involved.
+*/
+function mergePrefixBinding(left, right) {
+	const leftValue = primitiveString(left.value);
+	const rightValue = primitiveString(right.value);
+	if (leftValue == null || rightValue == null) return null;
+	const isLeftPrefix = isPrefixBinding(left);
+	const isRightPrefix = isPrefixBinding(right);
+	if (!isLeftPrefix && !isRightPrefix) return null;
+	if (isLeftPrefix && !isRightPrefix) return truncateValue(rightValue, left.prefix) === leftValue ? right : null;
+	if (!isLeftPrefix && isRightPrefix) return truncateValue(leftValue, right.prefix) === rightValue ? left : null;
+	const leftPrefix = left.prefix;
+	const rightPrefix = right.prefix;
+	if (leftPrefix <= rightPrefix) return truncateValue(rightValue, leftPrefix) === leftValue ? right : null;
+	return truncateValue(leftValue, rightPrefix) === rightValue ? left : null;
+}
+const isPrefixBinding = (binding) => binding.prefix != null;
+const primitiveString = (value) => typeof value === "string" ? value : null;
+function equalExpandValue(left, right) {
+	if (Array.isArray(left)) return Array.isArray(right) && left.length === right.length && left.every((item, index) => item === right[index]);
+	if (isAssociative(left)) return isAssociative(right) && equalEntries(Object.entries(left), Object.entries(right));
+	return left === right;
+}
+const equalEntries = (left, right) => left.length === right.length && left.every(([key, value], index) => {
+	const [rightKey, rightValue] = right[index];
+	return key === rightKey && value === rightValue;
+});
+const isAssociative = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toExpandContext = (bindings) => Object.fromEntries(Object.entries(bindings).map(([key, binding]) => [key, binding.value]));
+const split = (value, separator) => separator === "" ? [value] : value.split(separator);
+//#endregion
+//#region src/template/expression.ts
+const reservedOperators = [
+	"=",
+	",",
+	"!",
+	"@",
+	"|"
+];
+/**
+* Parses the content between `{` and `}` into one expression token.
+*
+* The tokenizer supplies the original template and offset so errors can point
+* at the original source string.
+*/
+function parseExpression(source, template, position) {
+	const raiseExpressionError = (error) => {
+		throw error;
+	};
+	if (source.length < 1) return raiseExpressionError(new EmptyExpressionError(template, position));
+	const first = source[0];
+	if (isReservedOperator(first)) return raiseExpressionError(new ReservedOperatorError(template, position + 1, first));
+	if (!isOperator(first) && isVarcharAt(source, 0) < 1) return raiseExpressionError(new UnknownOperatorError(template, position + 1, first));
+	const operator = isOperator(first) ? first : "";
+	const varListStart = operator === "" ? 0 : 1;
+	return {
+		kind: "expression",
+		operator,
+		vars: parseVarList(source, template, position + 1, varListStart)
+	};
+}
+function parseVarList(source, template, offset, start) {
+	if (start >= source.length) throw new EmptyVarNameError(template, offset + start);
+	const vars = [];
+	for (let index = start; index < source.length;) {
+		if (source[index] === ",") throw index === source.length - 1 ? new TrailingCommaError(template, offset + index) : new EmptyVarNameError(template, offset + index);
+		const varStart = index;
+		const nameEnd = readVarNameEnd(source, index);
+		if (nameEnd === varStart) throw new EmptyVarNameError(template, offset + index);
+		const name = source.slice(varStart, nameEnd);
+		index = nameEnd;
+		const modifier = readModifier(source, template, offset, index, name);
+		index = modifier.index;
+		if (index < source.length && source[index] !== ",") throw modifier.used ? new UnexpectedCharacterError(template, offset + index, source[index]) : new InvalidVarNameError(template, offset + index, name, source[index]);
+		vars.push({
+			name,
+			explode: modifier.explode,
+			...modifier.prefix == null ? {} : { prefix: modifier.prefix }
+		});
+		if (index < source.length) {
+			index++;
+			if (index >= source.length) throw new TrailingCommaError(template, offset + index - 1);
+		}
+	}
+	return vars;
+}
+function readVarNameEnd(source, start) {
+	let index = start;
+	let expectVarchar = true;
+	while (index < source.length) {
+		const varcharLength = isVarcharAt(source, index);
+		if (varcharLength > 0) {
+			index += varcharLength;
+			expectVarchar = false;
+			continue;
+		}
+		if (source[index] !== ".") break;
+		if (expectVarchar || isVarcharAt(source, index + 1) < 1) break;
+		index++;
+		expectVarchar = true;
+	}
+	return index;
+}
+function readModifier(source, template, offset, index, varSpec) {
+	if (source[index] === "*") return {
+		explode: true,
+		index: index + 1,
+		used: true
+	};
+	if (source[index] !== ":") return {
+		explode: false,
+		index,
+		used: false
+	};
+	const digitsStart = index + 1;
+	let digitsEnd = digitsStart;
+	while (digitsEnd < source.length && isDigit(source[digitsEnd])) digitsEnd++;
+	const prefix = source.slice(digitsStart, digitsEnd);
+	if (!/^[1-9][0-9]{0,3}$/.test(prefix)) throw new InvalidPrefixError(template, offset + index, varSpec, prefix);
+	return {
+		explode: false,
+		index: digitsEnd,
+		prefix: Number(prefix),
+		used: true
+	};
+}
+function isOperator(char) {
+	return OPERATORS.includes(char) && char !== "";
+}
+function isReservedOperator(char) {
+	return reservedOperators.includes(char);
+}
+function isDigit(char) {
+	const code = char.charCodeAt(0);
+	return code >= 48 && code <= 57;
+}
+//#endregion
+//#region src/template/token.ts
+/**
+* Splits a URI Template source string into literal and expression tokens.
+*
+* This module validates RFC 6570 literal syntax and delegates expression
+* parsing to the expression parser.
+*/
+function tokenize(template, options) {
+	const { report } = options;
+	const tokens = [];
+	const appendLiteral = (text) => {
+		const previous = tokens.at(-1);
+		if (previous?.kind === "literal") tokens[tokens.length - 1] = {
+			kind: "literal",
+			text: previous.text + text
+		};
+		else tokens.push({
+			kind: "literal",
+			text
+		});
+	};
+	for (let index = 0; index < template.length;) {
+		const char = template[index];
+		if (char === "{") {
+			const closeIndex = template.indexOf("}", index + 1);
+			if (closeIndex < 0) {
+				report(new UnclosedExpressionError(template, index));
+				appendLiteral(template.slice(index));
+				break;
+			}
+			const nestedIndex = template.indexOf("{", index + 1);
+			if (nestedIndex >= 0 && nestedIndex < closeIndex) {
+				report(new NestedOpeningBraceError(template, nestedIndex));
+				appendLiteral(template.slice(index, closeIndex + 1));
+				index = closeIndex + 1;
+				continue;
+			}
+			const expression = template.slice(index + 1, closeIndex);
+			try {
+				tokens.push(parseExpression(expression, template, index));
+			} catch (error) {
+				report(error instanceof Error ? error : new Error(String(error)));
+				appendLiteral(template.slice(index, closeIndex + 1));
+			}
+			index = closeIndex + 1;
+			continue;
+		}
+		if (char === "}") {
+			report(new StrayClosingBraceError(template, index));
+			appendLiteral(char);
+			index++;
+			continue;
+		}
+		const literalLength = isLiteralAt(template, index);
+		if (literalLength > 0) {
+			appendLiteral(template.slice(index, index + literalLength));
+			index += literalLength;
+			continue;
+		}
+		const { char: invalidChar, size } = readCodePoint(template, index);
+		report(new InvalidLiteralError(template, index, invalidChar));
+		appendLiteral(invalidChar);
+		index += size;
+	}
+	return tokens;
+}
+//#endregion
+//#region src/template/template.ts
+/**
+* Parsed RFC 6570 URI Template that can be expanded repeatedly.
+*
+* This class owns tokenization and delegates expression expansion to the
+* expansion module.  Instances are immutable after construction.
+*/
+var Template = class Template {
+	uriTemplate;
+	options;
+	#tokens;
+	#fullOptions;
+	constructor(uriTemplate, options = {}) {
+		this.uriTemplate = uriTemplate;
+		this.options = options;
+		this.#fullOptions = fillOptions(options);
+		this.#tokens = freezeTokens(tokenize(uriTemplate, this.#fullOptions));
+		Object.freeze(this);
+	}
+	/**
+	* Parses a URI Template using default strict parsing options.
+	*/
+	static parse(uriTemplate, options = {}) {
+		return new Template(uriTemplate, options);
+	}
+	/**
+	* Immutable parsed token stream for diagnostics and router integration.
+	*/
+	get tokens() {
+		return this.#tokens;
+	}
+	/**
+	* Expands this template against a variable context.
+	*/
+	expand = (context) => expand(this.#tokens, context, this.#fullOptions);
+	/**
+	* Matches a URI against this template, returning the variable context if the
+	* URI matches or `null` if it does not.
+	*/
+	match = (uri) => match(this.#tokens, uri, this.#fullOptions);
+	toString = () => this.uriTemplate;
+};
+const freezeTokens = (tokens) => Object.freeze(tokens.map(freezeToken));
+const freezeToken = (token) => token.kind === "literal" ? Object.freeze({
+	kind: "literal",
+	text: token.text
+}) : Object.freeze({
+	kind: "expression",
+	operator: token.operator,
+	vars: Object.freeze(token.vars.map(freezeVarSpec))
+});
+const freezeVarSpec = (varSpec) => Object.freeze({
+	name: varSpec.name,
+	explode: varSpec.explode,
+	...varSpec.prefix == null ? {} : { prefix: varSpec.prefix }
+});
+const defaultReporter = () => void 0;
+const fillOptions = ({ strict, report }) => {
+	report ??= defaultReporter;
+	strict ??= true;
+	report = strict ? strictWrapper(report) : report;
+	return {
+		strict,
+		report
+	};
+};
+const strictWrapper = (reporter) => (error) => {
+	reporter(error);
+	throw error;
+};
+//#endregion
+//#region src/utils.ts
+const isExpression = (token) => token.kind === "expression";
+const isLiteral = (token) => token.kind === "literal";
+/**
+* Reduces `iter` to a single value by applying `step` left-to-right, starting
+* from `init`.
+*/
+const fold = (step, init, iter) => {
+	let acc = init;
+	for (const item of iter) acc = step(acc, item);
+	return acc;
+};
+/**
+* Variant of {@link fold} that stops as soon as `step` yields `null` or
+* `undefined`, returning the last accumulator value that was defined. Useful
+* for descending through a trie where missing children fall back to the
+* deepest reachable node.
+*/
+const foldWhileDefined = (step, init, iter) => {
+	let acc = init;
+	for (const item of iter) {
+		const next = step(acc, item);
+		if (next == null) break;
+		acc = next;
+	}
+	return acc;
+};
+/**
+* Returns whether `path` is a path-shaped URI Template accepted by the
+* router.
+*
+* A path is either an empty string, a literal string starting with `/`, or a
+* path-expansion expression (`{/var}`).
+* Templates that fail to parse — and therefore could never be routed —
+* return `false`.
+*/
+function isPath(path) {
+	if (path === "") return true;
+	try {
+		const [first] = new Template(path).tokens;
+		if (first == null) return false;
+		if (isLiteral(first)) return first.text.startsWith("/");
+		if (first.operator === "/") return true;
+		return false;
+	} catch {
+		return false;
+	}
+}
+function assertPath(path) {
+	if (!isPath(path)) throw new RouterError(`"${path}" is not a router path. It must be empty, start with \`/\`, or start with a expression with slash(\`/\`) like \`{/id}\`.`);
+}
+//#endregion
+//#region src/router/fill.ts
+/**
+* Resolves a partial options input against a path pattern into fully-resolved
+* {@link RouteOptions}.  Mirrors `fillOptions` in *template.ts*: missing
+* fields are filled with their defaults, with `multiple` derived from the
+* variable specification when not given.  Throws when the supplied
+* `variables` keys do not match the template (under `exact`), when the same
+* variable name carries contradictory explode/prefix modifiers, or when a
+* per-field constraint is violated.
+*/
+function fillRouteOptions(options = {}, pattern) {
+	const overrides = options?.variables ?? {};
+	const exact = options?.exact ?? true;
+	if (exact && options?.variables != null) {
+		const unknown = Object.keys(overrides).filter((key) => !pattern.variables.has(key));
+		const missing = [...pattern.variables].filter((name) => !(name in overrides));
+		const mismatched = [...unknown, ...missing];
+		if (mismatched.length > 0) throw new RouteTemplateOptionsNotMatchedError(pattern.path, mismatched);
+	}
+	const operatorsByName = groupVarOperators(pattern.template.tokens);
+	const variables = {};
+	for (const [name, specs] of groupVarSpecs(pattern.template.tokens)) {
+		const override = overrides[name];
+		const hasExplode = specs.some((spec) => spec.explode);
+		const hasPrefix = specs.some((spec) => spec.prefix != null);
+		const hasPlain = specs.some((spec) => !spec.explode && spec.prefix == null);
+		const multiple = override?.multiple;
+		if (hasExplode && (hasPrefix || hasPlain) || hasExplode && multiple === false || hasPrefix && multiple === true) throw new ConflictingVarSpecError(pattern.path, name);
+		variables[name] = {
+			nullable: fillNullable(override?.nullable),
+			multiple: fillMultiple(multiple, hasExplode, hasPrefix),
+			duplicable: fillDuplicable(override?.duplicable, pattern.path, name, specs.length),
+			prefixable: fillPrefixable(override?.prefixable, pattern.path, name, hasPrefix),
+			explodable: fillExplodable(override?.explodable, pattern.path, name, hasExplode),
+			operatables: fillOperatables(override?.operatables, pattern.path, name, operatorsByName.get(name))
+		};
+	}
+	return {
+		variables,
+		exact
+	};
+}
+const fillNullable = (override) => override ?? false;
+const fillMultiple = (requested, hasExplode, hasPrefix) => {
+	if (hasExplode) return true;
+	if (hasPrefix) return false;
+	return requested ?? false;
+};
+const fillDuplicable = (override, template, name, occurrences) => {
+	const duplicable = override ?? false;
+	if (occurrences > 1 && !duplicable) throw new DuplicateRouteVariableError(template, name);
+	return duplicable;
+};
+const fillPrefixable = (override, template, name, hasPrefix) => {
+	const prefixable = override ?? false;
+	if (hasPrefix && !prefixable) throw new DisallowedVarSpecModifierError(template, name, "prefix");
+	return prefixable;
+};
+const fillExplodable = (override, template, name, hasExplode) => {
+	const explodable = override ?? false;
+	if (hasExplode && !explodable) throw new DisallowedVarSpecModifierError(template, name, "explode");
+	return explodable;
+};
+const fillOperatables = (override, template, name, operators) => {
+	const operatables = override ?? [];
+	if (operatables.length > 0 && operators != null) {
+		for (const operator of operators) if (!operatables.includes(operator)) throw new DisallowedOperatorError(template, name, operator);
+	}
+	return operatables;
+};
+const groupVarSpecs = (tokens) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		if (!isExpression(token)) continue;
+		for (const varSpec of token.vars) {
+			const list = grouped.get(varSpec.name);
+			if (list == null) grouped.set(varSpec.name, [varSpec]);
+			else list.push(varSpec);
+		}
+	}
+	return grouped;
+};
+const groupVarOperators = (tokens) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		if (!isExpression(token)) continue;
+		for (const varSpec of token.vars) {
+			const set = grouped.get(varSpec.name);
+			if (set == null) grouped.set(varSpec.name, new Set([token.operator]));
+			else set.add(token.operator);
+		}
+	}
+	return grouped;
+};
+//#endregion
+//#region src/router/trie/priority.ts
+const compareRouteEntries = (left, right) => right.literalLength - left.literalLength || right.initialLiteralPrefix.length - left.initialLiteralPrefix.length || left.variableCount - right.variableCount || left.index - right.index;
+const mergeRouteEntries = (left, right) => {
+	if (left.length < 1) return right;
+	if (right.length < 1) return left;
+	const merged = [];
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length && rightIndex < right.length) if (compareRouteEntries(left[leftIndex], right[rightIndex]) <= 0) merged.push(left[leftIndex++]);
+	else merged.push(right[rightIndex++]);
+	while (leftIndex < left.length) merged.push(left[leftIndex++]);
+	while (rightIndex < right.length) merged.push(right[rightIndex++]);
+	return merged;
+};
+//#endregion
+//#region src/router/trie/node.ts
+/**
+* Base trie node storing entries sorted by route priority.
+*/
+var Node = class {
+	#entries = [];
+	get entries() {
+		return this.#entries;
+	}
+	insert = (entry) => {
+		this.#entries.splice(this.#insertionIndex(entry), 0, entry);
+	};
+	remove = (entry) => {
+		const index = this.#entries.indexOf(entry);
+		if (index < 0) return;
+		this.#entries.splice(index, 1);
+	};
+	#insertionIndex(entry) {
+		let low = 0;
+		let high = this.#entries.length;
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+			if (compareRouteEntries(this.#entries[middle], entry) <= 0) low = middle + 1;
+			else high = middle;
+		}
+		return low;
+	}
+};
+//#endregion
+//#region src/router/trie/fallback/node.ts
+/**
+* Prefix-trie node for routes the main router index cannot handle.
+* Precomputes merged candidates per node so path lookups only read the
+* deepest matching node's {@link candidates}.
+*/
+var FallbackNode = class FallbackNode extends Node {
+	#children = /* @__PURE__ */ new Map();
+	#candidates = [];
+	get candidates() {
+		return this.#candidates;
+	}
+	child = (key) => this.#children.get(key);
+	childOrInsert = (key) => {
+		const existing = this.#children.get(key);
+		if (existing != null) return existing;
+		const inserted = new FallbackNode();
+		this.#children.set(key, inserted);
+		return inserted;
+	};
+	rebuildCandidates = (parentCandidates) => {
+		this.#candidates = mergeRouteEntries(parentCandidates, this.entries);
+		for (const child of this.#children.values()) child.rebuildCandidates(this.#candidates);
+	};
+};
+//#endregion
+//#region src/router/trie/fallback/trie.ts
+/**
+* Prefix trie for route templates that cannot be safely compiled into the
+* token-level state trie.
+*/
+var FallbackTrie = class {
+	#root = new FallbackNode();
+	#dirty = true;
+	insert = (entry) => {
+		fold((n, char) => n.childOrInsert(char), this.#root, entry.initialLiteralPrefix).insert(entry);
+		this.#dirty = true;
+	};
+	remove = (entry) => {
+		foldWhileDefined((node, char) => node.child(char), this.#root, entry.initialLiteralPrefix).remove(entry);
+		this.#dirty = true;
+	};
+	*candidates(path) {
+		if (this.#dirty) this.#rebuildCandidates();
+		yield* this.#deepestNode(path).candidates;
+	}
+	#deepestNode = (path) => foldWhileDefined((n, char) => n.child(char), this.#root, path);
+	#rebuildCandidates = () => {
+		this.#root.rebuildCandidates([]);
+		this.#dirty = false;
+	};
+};
+//#endregion
+//#region src/router/trie/state/node.ts
+var StateNode = class StateNode extends Node {
+	literalEdges = [];
+	expressionEdges = /* @__PURE__ */ new Map();
+	insertLiteral = (text) => {
+		if (text === "") return this;
+		const edge = this.#findCommonLiteralEdge(text);
+		if (edge == null) return this.#appendLiteralEdge(text);
+		const length = commonPrefixLength(edge.text, text);
+		if (length === edge.text.length) return edge.node.insertLiteral(text.slice(length));
+		const intermediate = splitLiteralEdge(edge, length);
+		if (length === text.length) return intermediate;
+		return intermediate.#appendLiteralEdge(text.slice(length));
+	};
+	findLiteral = (text) => {
+		if (text === "") return this;
+		const edge = this.literalEdges.find(({ text: edgeText }) => text.startsWith(edgeText));
+		if (edge == null) return void 0;
+		return edge.node.findLiteral(text.slice(edge.text.length));
+	};
+	childOrInsertExpression = ({ key, operator }) => {
+		const existing = this.expressionEdges.get(key);
+		if (existing != null) return existing.node;
+		const node = new StateNode();
+		this.expressionEdges.set(key, {
+			key,
+			operator,
+			node
+		});
+		return node;
+	};
+	childExpression = (key) => this.expressionEdges.get(key)?.node;
+	#appendLiteralEdge(text) {
+		const child = new StateNode();
+		this.literalEdges.push({
+			text,
+			node: child
+		});
+		return child;
+	}
+	#findCommonLiteralEdge = (text) => this.literalEdges.find((edge) => commonPrefixLength(edge.text, text) > 0);
+};
+const splitLiteralEdge = (edge, length) => {
+	const intermediate = new StateNode();
+	const suffix = edge.text.slice(length);
+	intermediate.literalEdges.push({
+		text: suffix,
+		node: edge.node
+	});
+	edge.text = edge.text.slice(0, length);
+	edge.node = intermediate;
+	return intermediate;
+};
+const commonPrefixLength = (left, right) => {
+	const max = Math.min(left.length, right.length);
+	for (let index = 0; index < max; index++) if (left[index] !== right[index]) return index;
+	return max;
+};
+//#endregion
+//#region src/router/trie/state/trie.ts
+/**
+* Token-level state trie for common path-shaped URI templates.
+*/
+var StateTrie = class {
+	#root = new StateNode();
+	insert = (entry) => fold((node, segment) => isLiteral(segment) ? node.insertLiteral(segment.text) : node.childOrInsertExpression(segment), this.#root, compileSegments(entry.tokens)).insert(entry);
+	remove = (entry) => foldWhileDefined((node, segment) => isLiteral(segment) ? node.findLiteral(segment.text) : node.childExpression(segment.key), this.#root, compileSegments(entry.tokens)).remove(entry);
+	*candidates(path) {
+		yield* stateEntries(this.#root, path, 0);
+	}
+};
+function* compileSegments(tokens) {
+	for (const token of tokens) if (isLiteral(token)) {
+		if (token.text !== "") yield token;
+	} else yield {
+		kind: "expression",
+		key: expressionKey(token),
+		operator: token.operator
+	};
+}
+const expressionKey = ({ operator, vars: [{ explode, prefix }] }) => [
+	operator,
+	explode ? "*" : "",
+	prefix ?? ""
+].join("\0");
+function* stateEntries(node, path, index) {
+	if (index === path.length) yield* node.entries;
+	for (const edge of node.literalEdges) if (path.startsWith(edge.text, index)) yield* stateEntries(edge.node, path, index + edge.text.length);
+	for (const edge of node.expressionEdges.values()) yield* expressionEntries(edge, path, index);
+}
+function* expressionEntries(edge, path, index) {
+	for (const end of expressionEndIndexes(edge.node, path, index)) {
+		const expression = path.slice(index, end);
+		if (!matchesExpressionShape(edge.operator, expression)) continue;
+		yield* stateEntries(edge.node, path, end);
+	}
+}
+function* expressionEndIndexes(node, path, index) {
+	if (node.entries.length > 0) yield path.length;
+	for (const edge of node.literalEdges) for (let found = path.indexOf(edge.text, index); found >= 0; found = path.indexOf(edge.text, found + 1)) yield found;
+}
+const matchesExpressionShape = (operator, expression) => {
+	if (expression === "") return true;
+	if (operator === "") return !expression.includes("/");
+	if (operator === "/") return expression.startsWith("/");
+	return true;
+};
+//#endregion
+//#region src/router/trie/mod.ts
+/**
+* Route candidate trie that delegates to a state trie for indexable templates
+* and a fallback prefix trie for the remaining RFC 6570 shapes.
+*/
+var Trie = class {
+	#state = new StateTrie();
+	#fallback = new FallbackTrie();
+	insert = (entry) => {
+		if (isStateTrieEntry(entry)) this.#state.insert(entry);
+		else this.#fallback.insert(entry);
+	};
+	remove = (entry) => {
+		if (isStateTrieEntry(entry)) this.#state.remove(entry);
+		else this.#fallback.remove(entry);
+	};
+	insertAll = (entries) => {
+		for (const entry of entries) this.insert(entry);
+	};
+	*candidates(path) {
+		yield* Array.from(uniqueMergedEntries(this.#state.candidates(path), this.#fallback.candidates(path))).sort(compareRouteEntries);
+	}
+};
+const isStateTrieEntry = (entry) => isIndexableRoute(entry.tokens);
+const isIndexableRoute = (tokens) => {
+	let previousWasExpression = false;
+	for (const token of tokens) if (isLiteral(token)) previousWasExpression = false;
+	else {
+		if (previousWasExpression) return false;
+		if (!isIndexableExpression(token)) return false;
+		previousWasExpression = true;
+	}
+	return true;
+};
+const isIndexableExpression = ({ vars, operator }) => vars.length === 1 && INDEXABLE_OPERATORS.has(operator);
+const INDEXABLE_OPERATORS = new Set([
+	"",
+	"/",
+	"+"
+]);
+function uniqueMergedEntries(...sources) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const entry of source) seen.add(entry);
+	return seen;
+}
+//#endregion
+//#region src/router/router.ts
+/**
+* Router that resolves URIs against registered RFC 6570 templates.
+*/
+var Router = class Router {
+	#trie;
+	#routesByName;
+	#prevIndex = -1;
+	/**
+	* Whether to ignore trailing slashes when matching paths.
+	*/
+	trailingSlashInsensitive;
+	constructor(routesOrOptions, maybeOptions) {
+		const routes = isRoutesArgument(routesOrOptions) ? routesOrOptions : void 0;
+		const options = isRoutesArgument(routesOrOptions) ? maybeOptions : routesOrOptions;
+		this.#trie = new Trie();
+		this.#routesByName = /* @__PURE__ */ new Map();
+		this.trailingSlashInsensitive = options?.trailingSlashInsensitive ?? false;
+		if (routes != null) this.register(routes);
+	}
+	static from(routesOrOptions, options) {
+		return new Router(routesOrOptions, options);
+	}
+	/**
+	* Compiles a path template without registering it in a router.
+	* @param path The path pattern.
+	* @returns A parsed path pattern.
+	*/
+	static compile(path) {
+		if (!isPath(path)) throw new RouteTemplatePathError(path);
+		const template = Template.parse(path);
+		return Object.freeze({
+			path,
+			template,
+			variables: collectVariables(template.tokens)
+		});
+	}
+	/**
+	* Returns the variable names in a path template without registering it.
+	* @param path The path pattern.
+	* @returns The names of the variables in the path pattern.
+	*/
+	static variables = (path) => new Set(Router.compile(path).variables);
+	/**
+	* Checks if a path name exists in the router.
+	* @param name The name of the path.
+	* @returns `true` if the path name exists, otherwise `false`.
+	*/
+	has = (name) => this.#routesByName.has(name);
+	/**
+	* Adds a new path rule to the router.
+	* @param pathOrPattern The path template, or a pre-parsed
+	*                      {@link RouterPathPattern} produced by
+	*                      {@link Router.compile}.
+	* @param name The name of the path.
+	* @param options Per-route options, including per-variable constraints.
+	*/
+	add = (pathOrPattern, name, options) => {
+		const pattern = resolvePathPattern(pathOrPattern);
+		const previous = this.#routesByName.get(name);
+		if (previous != null) this.#trie.remove(previous);
+		const entry = createRouteEntry({
+			index: this.#index,
+			name,
+			pattern,
+			options: fillRouteOptions(options, pattern)
+		});
+		this.#routesByName.set(name, entry);
+		this.#trie.insert(entry);
+	};
+	/**
+	* Registers multiple path rules at once.
+	* @param routes Iterable of `[pathOrPattern, name]` pairs to register.
+	*/
+	register = (routes) => {
+		const resolved = Iterator.from(routes).map(([pathOrPattern, name, options]) => [
+			resolvePathPattern(pathOrPattern),
+			name,
+			options
+		]).map(([pattern, name, options]) => [name, createRouteEntry({
+			index: this.#index,
+			name,
+			pattern,
+			options: fillRouteOptions(options, pattern)
+		})]);
+		const pending = new Map(resolved);
+		for (const name of pending.keys()) {
+			const committed = this.#routesByName.get(name);
+			if (committed != null) this.#trie.remove(committed);
+		}
+		for (const [name, entry] of pending) this.#routesByName.set(name, entry);
+		this.#trie.insertAll(pending.values());
+	};
+	get #index() {
+		return this.#prevIndex++;
+	}
+	/**
+	* Resolves a path name and values from a URI, if any match.
+	* @param url The URI to resolve.
+	* @returns The name of the path and its values, if any match.  Otherwise,
+	*          `null`.
+	*/
+	route = (url) => this.#route(url) ?? (this.trailingSlashInsensitive ? this.#route(toggleTrailingSlash(url)) : null);
+	#route(url) {
+		for (const entry of this.#trie.candidates(url)) {
+			const context = entry.pattern.template.match(url);
+			if (context == null) continue;
+			const values = resolveValues(context, entry);
+			if (values == null) continue;
+			return {
+				name: entry.name,
+				template: entry.pattern.path,
+				values
+			};
+		}
+		return null;
+	}
+	/**
+	* Constructs a URL/path from a path name and values.
+	* @param name The name of the path.
+	* @param values The values to expand the path with.
+	* @returns The URL/path, if the name exists.  Otherwise, `null`.
+	*/
+	build = (name, values) => this.#routesByName.get(name)?.pattern.template.expand(values) ?? null;
+	/**
+	* Creates a shallow clone of the router.  The clone shares immutable
+	* registered path patterns with the original, but changes to the route set
+	* (adding, removing, or re-registering routes) do not affect the other
+	* router.
+	* @returns A new router with the same routes and options as this one.
+	*/
+	clone = () => new Router(this.#activeEntries(), { trailingSlashInsensitive: this.trailingSlashInsensitive });
+	#activeEntries = () => Array.from(this.#routesByName.values()).sort((left, right) => left.index - right.index).map((entry) => [
+		entry.pattern,
+		entry.name,
+		entry.options
+	]);
+};
+const createRouteEntry = ({ index, name, pattern, options }) => ({
+	index,
+	name,
+	pattern,
+	tokens: pattern.template.tokens,
+	initialLiteralPrefix: getInitialLiteralPrefix(pattern.template.tokens),
+	literalLength: getLiteralLength(pattern.template.tokens),
+	variableCount: pattern.variables.size,
+	options,
+	constraints: new Map(Object.entries(options.variables))
+});
+const resolvePathPattern = (value) => typeof value === "string" ? Router.compile(value) : value;
+const isRoutesArgument = (value) => value != null && typeof value === "object" && Symbol.iterator in value;
+const toggleTrailingSlash = (path) => path.endsWith("/") ? path.replace(/\/+$/, "") : `${path}/`;
+const collectVariables = (tokens) => new ImmutableSet(tokens.filter(isExpression).flatMap((token) => token.vars.map((varSpec) => varSpec.name)));
+var ImmutableSet = class extends Set {
+	constructor(values) {
+		super();
+		if (values != null) for (const value of values) super.add(value);
+	}
+	add(_value) {
+		throw new TypeError("ImmutableSet cannot be mutated.");
+	}
+	delete(_value) {
+		throw new TypeError("ImmutableSet cannot be mutated.");
+	}
+	clear() {
+		throw new TypeError("ImmutableSet cannot be mutated.");
+	}
+};
+const getInitialLiteralPrefix = (tokens) => tokens[0] != null && isLiteral(tokens[0]) ? tokens[0].text : "";
+const getLiteralLength = (tokens) => tokens.reduce((sum, token) => isLiteral(token) ? sum + token.text.length : sum, 0);
+/**
+* Applies the resolved per-variable constraints to a matched context,
+* producing the route values or `null` when a constraint rejects the match
+* (so the caller falls back to the next candidate).
+*/
+const resolveValues = (context, entry) => {
+	const values = {};
+	for (const [name, constraint] of entry.constraints) {
+		const raw = context[name];
+		if (constraint.multiple) {
+			const list = toStringList(raw);
+			if (list == null) return null;
+			if ((list.length < 1 || list.every((item) => item === "")) && !constraint.nullable) return null;
+			values[name] = list;
+			continue;
+		}
+		if (typeof raw === "string") {
+			if (raw === "" && !constraint.nullable) return null;
+			values[name] = raw;
+		} else if (!constraint.nullable) return null;
+		else values[name] = null;
+	}
+	return values;
+};
+const toStringList = (value) => {
+	if (value === void 0) return [];
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.every((item) => typeof item === "string") ? value : null;
+	return null;
+};
+//#endregion
+exports.ConflictingVarSpecError = ConflictingVarSpecError;
+exports.DisallowedOperatorError = DisallowedOperatorError;
+exports.DisallowedVarSpecModifierError = DisallowedVarSpecModifierError;
+exports.DuplicateRouteVariableError = DuplicateRouteVariableError;
+exports.EmptyExpressionError = EmptyExpressionError;
+exports.EmptyVarNameError = EmptyVarNameError;
+exports.InvalidLiteralError = InvalidLiteralError;
+exports.InvalidPrefixError = InvalidPrefixError;
+exports.InvalidVarNameError = InvalidVarNameError;
+exports.InvalidVarSpecError = InvalidVarSpecError;
+exports.NestedOpeningBraceError = NestedOpeningBraceError;
+exports.PrefixModifierNotApplicableError = PrefixModifierNotApplicableError;
+exports.ReservedOperatorError = ReservedOperatorError;
+exports.RouteTemplateOptionsNotMatchedError = RouteTemplateOptionsNotMatchedError;
+exports.RouteTemplatePathError = RouteTemplatePathError;
+exports.Router = Router;
+exports.RouterError = RouterError;
+exports.StrayClosingBraceError = StrayClosingBraceError;
+exports.Template = Template;
+exports.TemplateExpansionError = TemplateExpansionError;
+exports.TemplateParseError = TemplateParseError;
+exports.TrailingCommaError = TrailingCommaError;
+exports.UnclosedExpressionError = UnclosedExpressionError;
+exports.UnexpectedCharacterError = UnexpectedCharacterError;
+exports.UnknownOperatorError = UnknownOperatorError;
+exports.assertPath = assertPath;
+exports.isExpression = isExpression;
+exports.isPath = isPath;