@stll/template-conditions 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { CompareNode, CompareOp, Condition, ConditionNode, ConditionNode as ConditionNode$1, GroupNode, Operand, PredicateNode, PredicateOp, conditionHasFormula, conditionNodeSchema, conditionSchema, emptyCondition } from "@stll/conditions";
-
 //#region src/path.d.ts
 /** Resolve a dotted path like `company.name` against data. */
 declare const resolvePath: (path: string, data: Record<string, unknown>) => unknown;
@@ -25,6 +24,8 @@ declare const parseCondition: (expression: string) => ConditionNode$1 | null;
  * non-numeric variable, division producing a non-finite result) so callers
  * can fall back to leaving the field unfilled rather than emitting `NaN`.
  */
+declare const NUMERIC_FUNCTION_NAMES: readonly ["min", "max", "round", "abs", "floor", "ceil"];
+type NumericFunctionName = (typeof NUMERIC_FUNCTION_NAMES)[number];
 declare const evaluateNumericExpression: (expression: string, data: Record<string, unknown>) => number | undefined;
 //#endregion
 //#region src/field-values.d.ts
@@ -47,11 +48,16 @@ declare const evaluateNumericExpression: (expression: string, data: Record<strin
  * STRUCTURAL shapes so the package stays free of api/web imports; callers pass
  * their own field objects, which structurally satisfy these.
  */
+declare const DATE_FORMAT_STYLES: readonly ["long", "medium", "short", "iso"];
+type DateFormatStyle = (typeof DATE_FORMAT_STYLES)[number];
+/** Stable exemplar for date-format configuration previews. */
+declare const DATE_FORMAT_EXAMPLE_ISO = "2028-06-13";
 /** Locale-aware date rendering config. "iso" leaves the submitted value as-is;
  *  the other styles map to `Intl.DateTimeFormat` `dateStyle`. */
 type FieldDateFormat = {
-  /** BCP-47 language tag of the document, e.g. "cs", "de", "pl". */locale: string;
-  style: "long" | "medium" | "short" | "iso";
+  /** BCP-47 language tag of the document, e.g. "cs", "de", "pl". */
+  locale: string;
+  style: DateFormatStyle;
 };
 /**
  * Format an ISO date (YYYY-MM-DD) per the field's locale + style via
@@ -120,23 +126,15 @@ declare const serializeCondition: (node: ConditionNode$1) => string;
  * shared by the fill pipeline (api), the editor highlighter (folio), and the
  * read-only preview (web).
  *
- * Add a new directive in ONE place: append its `kind` to {@link DIRECTIVE_KINDS},
- * add a `MarkerMeta` member, and teach {@link classifyMarker} to recognize it.
- * Every scanner that uses {@link scanMarkers} / {@link classifyMarker} then sees
- * it automatically, and every exhaustive `switch` over a marker's kind (closed
- * with {@link assertNever}) fails to compile at any consumer that has not yet
- * handled it. That is what makes "added a directive server-side but a recognizer
- * elsewhere silently ignored it" a build error rather than a latent bug.
+ * Add a new directive to `MarkerMeta` and teach {@link classifyMarker} to
+ * recognize it. Compile-time totality checks then require its ordered runtime
+ * value and its block/inline disposition, while exhaustive consumer switches
+ * fail until they handle it.
  *
  * No consumer should define its own `{{...}}` regex. The low-level pattern
  * factories below exist so handlers that mutate raw XML/text reuse the exact
  * same literals; recognizers should prefer the high-level scanner.
  */
-declare const DIRECTIVE_KINDS: readonly ["placeholder", "clause", "num", "ref", "index", "count", "if", "elseif", "else", "endif", "each", "endeach"];
-type DirectiveKind = (typeof DIRECTIVE_KINDS)[number];
-/** Directives that occupy their own paragraph (block-level), opener→closer. */
-declare const BLOCK_DIRECTIVE_KINDS: readonly ["if", "elseif", "else", "endif", "each", "endeach"];
-declare const isBlockDirectiveKind: (kind: DirectiveKind) => boolean;
 type MarkerMeta = {
   kind: "placeholder";
   expr: string;
@@ -170,6 +168,26 @@ type MarkerMeta = {
 } | {
   kind: "endeach";
 };
+type DirectiveKind = MarkerMeta["kind"];
+declare const DIRECTIVE_KINDS: readonly ["placeholder", "clause", "num", "ref", "index", "count", "if", "elseif", "else", "endif", "each", "endeach"];
+declare const DIRECTIVE_PLACEMENT: {
+  readonly placeholder: "inline";
+  readonly clause: "inline";
+  readonly num: "inline";
+  readonly ref: "inline";
+  readonly index: "inline";
+  readonly count: "inline";
+  readonly if: "block";
+  readonly elseif: "block";
+  readonly else: "block";
+  readonly endif: "block";
+  readonly each: "block";
+  readonly endeach: "block";
+};
+type BlockDirectiveKind = { [TKind in DirectiveKind]: (typeof DIRECTIVE_PLACEMENT)[TKind] extends "block" ? TKind : never; }[DirectiveKind];
+/** Directives that occupy their own paragraph, in canonical grammar order. */
+declare const BLOCK_DIRECTIVE_KINDS: readonly ["if", "elseif", "else", "endif", "each", "endeach"];
+declare const isBlockDirectiveKind: (kind: unknown) => kind is BlockDirectiveKind;
 /** Any `{{...}}` marker; group 1 is the inner text (untrimmed — callers trim). */
 declare const markerPattern: () => RegExp;
 /** Inline field / clause / numbering marker (inner allows the directive sigils). */
@@ -193,15 +211,25 @@ declare const blockDirectiveLinePattern: () => RegExp;
 /** Whether `value` is a valid field path per the marker grammar (dotted
  *  segments of letters/digits/underscore/dash — no brackets or spaces). */
 declare const isFieldPath: (value: string) => boolean;
+/** Whether `value` is safe to use as a dotted object path. */
+declare const isSafeFieldPath: (value: string) => boolean;
+/** Whether `value` is a valid name for authoring a `{{@clause:NAME}}` slot:
+ *  the intersection of the clause-slot parse grammar and the fill pipeline's
+ *  placeholder charset, so every accepted name round-trips through fill. */
+declare const isClauseSlotName: (value: string) => boolean;
 /**
  * Classify the inner text of a `{{...}}` marker. Returns `null` when the text is
  * not a recognized directive (so a recognizer can leave stray braces alone).
  */
 declare const classifyMarker: (innerRaw: string) => MarkerMeta | null;
 type ScannedMarker = {
-  /** Offset of `{{` in the source text. */start: number; /** Offset just past `}}`. */
-  end: number; /** The full matched marker, e.g. `{{@num:scope}}`. */
-  raw: string; /** The (untrimmed) inner text. */
+  /** Offset of `{{` in the source text. */
+  start: number;
+  /** Offset just past `}}`. */
+  end: number;
+  /** The full matched marker, e.g. `{{@num:scope}}`. */
+  raw: string;
+  /** The (untrimmed) inner text. */
   inner: string;
   meta: MarkerMeta;
 };
@@ -210,12 +238,33 @@ type ScannedMarker = {
  * offsets and classified metadata. Unrecognized `{{...}}` spans are skipped.
  */
 declare const scanMarkers: (text: string) => ScannedMarker[];
+/** A `{{...}}` span that looks like a marker but classifies to nothing. */
+type InvalidMarker = {
+  /** Offset of `{{` in the source text. */
+  start: number;
+  /** Offset just past `}}`. */
+  end: number;
+  /** The full matched span, e.g. `{{my field}}`. */
+  raw: string;
+  /** The (trimmed) inner text. */
+  inner: string;
+};
+/**
+ * Find every `{{...}}` span whose inner text is NOT a recognized directive —
+ * near-misses an author clearly meant as markers but that every recognizer
+ * skips, so they print literally at fill time (e.g. `{{my field}}` with a
+ * space, `{{@clause:}}` with no name). Offsets and raw text are shaped like
+ * {@link scanMarkers} results, minus the classified `meta`. This is the exact
+ * complement of {@link scanMarkers}: a span is in one list or the other.
+ */
+declare const scanInvalidMarkers: (text: string) => InvalidMarker[];
 /** Exhaustiveness guard — pass the discriminant in a `switch` default branch. */
 declare const assertNever: (value: never) => never;
 //#endregion
 //#region src/index.d.ts
 type NamedCondition = {
-  name: string; /** The `{{#if}}` expression string. Authoritative unless `node` is set. */
+  name: string;
+  /** The `{{#if}}` expression string. Authoritative unless `node` is set. */
   expression: string;
   /**
    * The canonical AST, set when the condition cannot round-trip through the
@@ -245,4 +294,4 @@ declare const MAX_CONDITION_DEPTH = 50;
  */
 declare const evaluateCondition: (expression: string, data: Record<string, unknown>, namedConditions?: readonly NamedCondition[], _resolved?: ReadonlySet<string>, _depth?: number) => boolean;
 //#endregion
-export { BLOCK_DIRECTIVE_KINDS, type CompareNode, type CompareOp, type Condition, type ConditionNode, DIRECTIVE_KINDS, type DeterministicFieldConfig, type DirectiveKind, type FieldDateFormat, type GroupNode, MAX_CONDITION_DEPTH, type MarkerMeta, NamedCondition, type Operand, type PartConfig, type PredicateNode, type PredicateOp, type ScannedMarker, assertNever, blockDirectiveLinePattern, classifyMarker, clauseSlotPattern, conditionHasFormula, conditionNodeSchema, conditionSchema, countPattern, emptyCondition, evaluateCondition, evaluateNumericExpression, formatDate, hasBlockDirectivePattern, hasNumberingPattern, indexPattern, isBlockDirectiveKind, isFieldPath, markerPattern, numPattern, parseCondition, placeholderPattern, refPattern, renderComposite, renderDeterministicFieldValue, resolvePath, scanMarkers, serializeCondition };
+export { BLOCK_DIRECTIVE_KINDS, type BlockDirectiveKind, type CompareNode, type CompareOp, type Condition, type ConditionNode, DATE_FORMAT_EXAMPLE_ISO, DATE_FORMAT_STYLES, DIRECTIVE_KINDS, type DateFormatStyle, type DeterministicFieldConfig, type DirectiveKind, type FieldDateFormat, type GroupNode, type InvalidMarker, MAX_CONDITION_DEPTH, type MarkerMeta, NUMERIC_FUNCTION_NAMES, NamedCondition, type NumericFunctionName, type Operand, type PartConfig, type PredicateNode, type PredicateOp, type ScannedMarker, assertNever, blockDirectiveLinePattern, classifyMarker, clauseSlotPattern, conditionHasFormula, conditionNodeSchema, conditionSchema, countPattern, emptyCondition, evaluateCondition, evaluateNumericExpression, formatDate, hasBlockDirectivePattern, hasNumberingPattern, indexPattern, isBlockDirectiveKind, isClauseSlotName, isFieldPath, isSafeFieldPath, markerPattern, numPattern, parseCondition, placeholderPattern, refPattern, renderComposite, renderDeterministicFieldValue, resolvePath, scanInvalidMarkers, scanMarkers, serializeCondition };

package/dist/index.js

@@ -38,7 +38,16 @@ const resolvePath = (path, data) => {
 * non-numeric variable, division producing a non-finite result) so callers
 * can fall back to leaving the field unfilled rather than emitting `NaN`.
 */
-const TOKEN_RE$1 = /(?<numeric>[0-9][0-9_]*(?:\.[0-9]+)?)|(?<ident>[\p{L}_][\p{L}\p{N}_.]*(?:-[\p{L}\p{N}_.]+)*)|(?<punct>[+\-*/%(),])|(?<invalid>\S)/gu;
+const NUMERIC_FUNCTION_NAMES = Object.freeze([
+	"min",
+	"max",
+	"round",
+	"abs",
+	"floor",
+	"ceil"
+]);
+const isNumericFunctionName = (name) => NUMERIC_FUNCTION_NAMES.some((candidate) => candidate === name);
+const TOKEN_RE = /(?<numeric>[0-9][0-9_]*(?:\.[0-9]+)?)|(?<ident>[\p{L}_][\p{L}\p{N}_.]*(?:-[\p{L}\p{N}_.]+)*)|(?<punct>[+\-*/%(),])|(?<invalid>\S)/gu;
 const PRECEDENCE = {
 	"+": 1,
 	"-": 1,
@@ -48,7 +57,7 @@ const PRECEDENCE = {
 };
 const tokenize$1 = (expression) => {
 	const tokens = [];
-	for (const match of expression.matchAll(TOKEN_RE$1)) {
+	for (const match of expression.matchAll(TOKEN_RE)) {
 		const { numeric, ident, punct, invalid } = match.groups ?? {};
 		if (invalid !== void 0) throw new Error(`Unexpected token: ${invalid}`);
 		if (numeric !== void 0) tokens.push({
@@ -79,6 +88,7 @@ const applyOp = (op, a, b) => {
 	}
 };
 const callFunction = (name, args) => {
+	if (!isNumericFunctionName(name)) throw new Error(`Unknown function: ${name}`);
 	switch (name) {
 		case "min": return Math.min(...args);
 		case "max": return Math.max(...args);
@@ -91,7 +101,7 @@ const callFunction = (name, args) => {
 			const factor = 10 ** Math.trunc(digits);
 			return Math.round(value * factor) / factor;
 		}
-		default: throw new Error(`Unknown function: ${name}`);
+		default: return name;
 	}
 };
 const evaluateNumericExpression = (expression, data) => {
@@ -165,8 +175,6 @@ const evaluateNumericExpression = (expression, data) => {
 };
 //#endregion
 //#region src/parse.ts
-const TOKEN_RE = /(?<token>"[^"\\]*(?:\\.[^"\\]*)*"|==|!=|>=|<=|>|<|!(?!=)|and\b|or\b|contains\b|[()]|-?\d[\p{N}_.]*|[\p{L}\p{N}_.]+(?:-[\p{L}\p{N}_.]+)*)/gu;
-const STARTS_WITH_DIGIT_RE = /^-?\d/u;
 const COMPARE_SYMBOL_TO_OP = {
 	"==": "eq",
 	"!=": "neq",
@@ -175,27 +183,71 @@ const COMPARE_SYMBOL_TO_OP = {
 	">=": "gte",
 	"<=": "lte"
 };
+const escapeRegexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+const COMPARE_SYMBOL_PATTERN = Object.keys(COMPARE_SYMBOL_TO_OP).sort((left, right) => right.length - left.length).map(escapeRegexLiteral).join("|");
+const NON_STRING_TOKEN_RE = new RegExp(String.raw`(?<token>${COMPARE_SYMBOL_PATTERN}|!(?!=)|and\b|or\b|contains\b|[()]|-?\d[\p{N}_.]*|[\p{L}\p{N}_.]+(?:-[\p{L}\p{N}_.]+)*)`, "uy");
+const STARTS_WITH_DIGIT_RE = /^-?\d/u;
+const isCompareSymbol = (raw) => Object.hasOwn(COMPARE_SYMBOL_TO_OP, raw);
+/**
+* Scan a `"..."` literal starting at `expr[start]` (the opening quote),
+* honoring `\\`-escapes without interpreting them. A single linear pass:
+* each character is visited at most once, so this is safe on adversarial
+* input regardless of how many `"` or `\\` characters it contains.
+*
+* A closing quote is not required, consistent with the module's
+* degrade-gracefully policy for an unmatched `(`, a literal missing its
+* closing quote simply closes at end of input.
+*/
+const scanString = (expr, start) => {
+	let i = start + 1;
+	while (i < expr.length) {
+		if (expr[i] === "\"") return {
+			content: expr.slice(start + 1, i),
+			end: i + 1
+		};
+		i += expr[i] === "\\" && i + 1 < expr.length ? 2 : 1;
+	}
+	return {
+		content: expr.slice(start + 1),
+		end: expr.length
+	};
+};
+const classifyNonString = (raw) => {
+	if (raw === "and") return { type: "and" };
+	if (raw === "or") return { type: "or" };
+	if (raw === "!") return { type: "not" };
+	if (raw === "contains" || isCompareSymbol(raw)) return {
+		type: "op",
+		raw
+	};
+	if (raw === "(") return { type: "lparen" };
+	if (raw === ")") return { type: "rparen" };
+	return {
+		type: "value",
+		raw
+	};
+};
 const tokenize = (expr) => {
 	const tokens = [];
-	for (const m of expr.matchAll(TOKEN_RE)) {
-		const raw = m.groups?.["token"] ?? m[0];
-		if (raw === "and") tokens.push({ type: "and" });
-		else if (raw === "or") tokens.push({ type: "or" });
-		else if (raw === "!") tokens.push({ type: "not" });
-		else if (raw === "==" || raw === "!=" || raw === ">" || raw === "<" || raw === ">=" || raw === "<=" || raw === "contains") tokens.push({
-			type: "op",
-			raw
-		});
-		else if (raw === "(") tokens.push({ type: "lparen" });
-		else if (raw === ")") tokens.push({ type: "rparen" });
-		else if (raw.startsWith("\"")) tokens.push({
-			type: "string",
-			raw: raw.slice(1, -1).replace(/\\"/gu, "\"")
-		});
-		else tokens.push({
-			type: "value",
-			raw
-		});
+	let pos = 0;
+	while (pos < expr.length) {
+		if (expr[pos] === "\"") {
+			const { content, end } = scanString(expr, pos);
+			tokens.push({
+				type: "string",
+				raw: content.replace(/\\"/gu, "\"")
+			});
+			pos = end;
+			continue;
+		}
+		NON_STRING_TOKEN_RE.lastIndex = pos;
+		const m = NON_STRING_TOKEN_RE.exec(expr);
+		if (!m) {
+			pos += 1;
+			continue;
+		}
+		tokens.push(classifyNonString(m.groups?.["token"] ?? m[0]));
+		pos = NON_STRING_TOKEN_RE.lastIndex;
 	}
 	return tokens;
 };
@@ -322,31 +374,12 @@ const parseCondition = (expression) => {
 		return {
 			type: "compare",
 			left,
-			op: COMPARE_SYMBOL_TO_OP[opTok.raw] ?? "eq",
+			op: COMPARE_SYMBOL_TO_OP[opTok.raw],
 			right: operandFromToken(rightTok)
 		};
 	};
 	return parseOr();
 };
-//#endregion
-//#region src/markers.ts
-/**
-* Canonical grammar for `{{...}}` template markers — the single source of truth
-* shared by the fill pipeline (api), the editor highlighter (folio), and the
-* read-only preview (web).
-*
-* Add a new directive in ONE place: append its `kind` to {@link DIRECTIVE_KINDS},
-* add a `MarkerMeta` member, and teach {@link classifyMarker} to recognize it.
-* Every scanner that uses {@link scanMarkers} / {@link classifyMarker} then sees
-* it automatically, and every exhaustive `switch` over a marker's kind (closed
-* with {@link assertNever}) fails to compile at any consumer that has not yet
-* handled it. That is what makes "added a directive server-side but a recognizer
-* elsewhere silently ignored it" a build error rather than a latent bug.
-*
-* No consumer should define its own `{{...}}` regex. The low-level pattern
-* factories below exist so handlers that mutate raw XML/text reuse the exact
-* same literals; recognizers should prefer the high-level scanner.
-*/
 const DIRECTIVE_KINDS = [
 	"placeholder",
 	"clause",
@@ -361,7 +394,7 @@ const DIRECTIVE_KINDS = [
 	"each",
 	"endeach"
 ];
-/** Directives that occupy their own paragraph (block-level), opener→closer. */
+/** Directives that occupy their own paragraph, in canonical grammar order. */
 const BLOCK_DIRECTIVE_KINDS = [
 	"if",
 	"elseif",
@@ -370,8 +403,7 @@ const BLOCK_DIRECTIVE_KINDS = [
 	"each",
 	"endeach"
 ];
-const BLOCK_KIND_SET = new Set(BLOCK_DIRECTIVE_KINDS);
-const isBlockDirectiveKind = (kind) => BLOCK_KIND_SET.has(kind);
+const isBlockDirectiveKind = (kind) => typeof kind === "string" && BLOCK_DIRECTIVE_KINDS.some((blockKind) => blockKind === kind);
 /** Any `{{...}}` marker; group 1 is the inner text (untrimmed — callers trim). */
 const markerPattern = () => /\{\{(?<inner>[^{}]*)\}\}/gu;
 /** Inline field / clause / numbering marker (inner allows the directive sigils). */
@@ -393,9 +425,21 @@ const hasBlockDirectivePattern = () => /\{\{\s*[#/]/u;
 /** A whole line that is a single block directive — `tag` and `expr` groups. */
 const blockDirectiveLinePattern = () => /^\s*\{\{\s*(?<tag>#if|#elseif|#else|#each|\/if|\/each)\b(?<expr>[^{}]*)\}\}\s*$/u;
 const FIELD_PATH_RE = /^[\p{L}\p{N}_.-]+$/u;
+const UNSAFE_FIELD_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 /** Whether `value` is a valid field path per the marker grammar (dotted
 *  segments of letters/digits/underscore/dash — no brackets or spaces). */
 const isFieldPath = (value) => FIELD_PATH_RE.test(value);
+/** Whether `value` is safe to use as a dotted object path. */
+const isSafeFieldPath = (value) => isFieldPath(value) && value.split(".").every((segment) => !UNSAFE_FIELD_PATH_SEGMENTS.has(segment));
+const CLAUSE_SLOT_NAME_RE = /^[\p{L}\p{N}_.-]+$/u;
+/** Whether `value` is a valid name for authoring a `{{@clause:NAME}}` slot:
+*  the intersection of the clause-slot parse grammar and the fill pipeline's
+*  placeholder charset, so every accepted name round-trips through fill. */
+const isClauseSlotName = (value) => CLAUSE_SLOT_NAME_RE.test(value);
 const CLAUSE_INNER_RE = /^@clause:(?<name>[^:}\s]+)(?::(?<version>[^}\s]+))?$/u;
 const NUM_INNER_RE = /^@num:(?<key>[\p{L}\p{N}_.-]+)$/u;
 const REF_INNER_RE = /^@ref:(?<key>[\p{L}\p{N}_.-]+)$/u;
@@ -474,6 +518,30 @@ const scanMarkers = (text) => {
 	}
 	return out;
 };
+/**
+* Find every `{{...}}` span whose inner text is NOT a recognized directive —
+* near-misses an author clearly meant as markers but that every recognizer
+* skips, so they print literally at fill time (e.g. `{{my field}}` with a
+* space, `{{@clause:}}` with no name). Offsets and raw text are shaped like
+* {@link scanMarkers} results, minus the classified `meta`. This is the exact
+* complement of {@link scanMarkers}: a span is in one list or the other.
+*/
+const scanInvalidMarkers = (text) => {
+	const re = markerPattern();
+	const out = [];
+	let match = re.exec(text);
+	while (match !== null) {
+		const inner = (match[1] ?? "").trim();
+		if (classifyMarker(inner) === null) out.push({
+			start: match.index,
+			end: match.index + match[0].length,
+			raw: match[0],
+			inner
+		});
+		match = re.exec(text);
+	}
+	return out;
+};
 /** Exhaustiveness guard — pass the discriminant in a `switch` default branch. */
 const assertNever = (value) => panic(`Unhandled template directive: ${JSON.stringify(value)}`);
 //#endregion
@@ -497,12 +565,34 @@ const assertNever = (value) => panic(`Unhandled template directive: ${JSON.strin
 * STRUCTURAL shapes so the package stays free of api/web imports; callers pass
 * their own field objects, which structurally satisfy these.
 */
+const DATE_FORMAT_STYLES = [
+	"long",
+	"medium",
+	"short",
+	"iso"
+];
+/** Stable exemplar for date-format configuration previews. */
+const DATE_FORMAT_EXAMPLE_ISO = "2028-06-13";
 const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 const STYLE_OPTIONS = {
 	long: { dateStyle: "long" },
 	medium: { dateStyle: "medium" },
 	short: { dateStyle: "short" }
 };
+const dateFormatters = /* @__PURE__ */ new Map();
+/** `Intl.DateTimeFormat` for a locale + style pair, cached per pair so it
+*  isn't rebuilt on every {@link formatDate} call. */
+const getDateFormatter = (locale, style) => {
+	const key = `${locale}:${style}`;
+	const cached = dateFormatters.get(key);
+	if (cached) return cached;
+	const formatter = new Intl.DateTimeFormat(locale, {
+		...STYLE_OPTIONS[style],
+		timeZone: "UTC"
+	});
+	dateFormatters.set(key, formatter);
+	return formatter;
+};
 /**
 * Parse a strict YYYY-MM-DD calendar date; null when malformed or not a real
 * date. UTC-anchored so the rendered day never shifts with the timezone.
@@ -526,10 +616,7 @@ const formatDate = (value, dateFormat) => {
 	const date = parseIsoDate(value);
 	if (date === null) return null;
 	if (dateFormat.style === "iso") return value;
-	return new Intl.DateTimeFormat(dateFormat.locale, {
-		...STYLE_OPTIONS[dateFormat.style],
-		timeZone: "UTC"
-	}).format(date);
+	return getDateFormatter(dateFormat.locale, dateFormat.style).format(date);
 };
 /**
 * Render a `{{key}}` format over part values. Markers whose key has no part
@@ -616,11 +703,18 @@ const serializeOperand = (operand) => {
 const serializeCompare = (node) => `${serializeOperand(node.left)} ${COMPARE_OP_TO_SYMBOL[node.op]} ${serializeOperand(node.right)}`;
 const serializePredicate = (node) => {
 	const operand = serializeOperand(node.operand);
-	if (node.op === "contains") return `${operand} contains ${serializeLiteral(Array.isArray(node.value) ? node.value.join(",") : node.value ?? "")}`;
+	if (node.op === "contains") {
+		const value = Array.isArray(node.value) ? node.value.join(",") : node.value ?? "";
+		return `${operand} contains ${serializeLiteral(value)}`;
+	}
 	return operand;
 };
 const serializeGroup = (group, top) => {
-	const parts = group.children.map((child) => serializeNode(child, false)).filter((part) => part.length > 0);
+	const parts = [];
+	for (const child of group.children) {
+		const part = serializeNode(child, false);
+		if (part.length > 0) parts.push(part);
+	}
 	if (parts.length === 0) return "";
 	const body = parts.length === 1 ? parts[0] ?? "" : parts.join(group.combinator === "and" ? " and " : " or ");
 	if (group.negated) return `!(${body})`;
@@ -712,4 +806,4 @@ const evaluateCondition = (expression, data, namedConditions, _resolved = /* @__
 	return evaluateCondition$1(node, makeResolver(data, namedConditions, _resolved, _depth));
 };
 //#endregion
-export { BLOCK_DIRECTIVE_KINDS, DIRECTIVE_KINDS, MAX_CONDITION_DEPTH, assertNever, blockDirectiveLinePattern, classifyMarker, clauseSlotPattern, conditionHasFormula, conditionNodeSchema, conditionSchema, countPattern, emptyCondition, evaluateCondition, evaluateNumericExpression, formatDate, hasBlockDirectivePattern, hasNumberingPattern, indexPattern, isBlockDirectiveKind, isFieldPath, markerPattern, numPattern, parseCondition, placeholderPattern, refPattern, renderComposite, renderDeterministicFieldValue, resolvePath, scanMarkers, serializeCondition };
+export { BLOCK_DIRECTIVE_KINDS, DATE_FORMAT_EXAMPLE_ISO, DATE_FORMAT_STYLES, DIRECTIVE_KINDS, MAX_CONDITION_DEPTH, NUMERIC_FUNCTION_NAMES, assertNever, blockDirectiveLinePattern, classifyMarker, clauseSlotPattern, conditionHasFormula, conditionNodeSchema, conditionSchema, countPattern, emptyCondition, evaluateCondition, evaluateNumericExpression, formatDate, hasBlockDirectivePattern, hasNumberingPattern, indexPattern, isBlockDirectiveKind, isClauseSlotName, isFieldPath, isSafeFieldPath, markerPattern, numPattern, parseCondition, placeholderPattern, refPattern, renderComposite, renderDeterministicFieldValue, resolvePath, scanInvalidMarkers, scanMarkers, serializeCondition };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/template-conditions",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A document-template marker and condition engine: {{...}} marker grammar, parse, compute, serialize, field values.",
   "keywords": [
     "condition",
@@ -41,23 +41,23 @@
     "build": "tsdown",
     "pack:dry-run": "bun pm pack --dry-run",
     "test": "bun test",
-    "test:property": "bun test $(grep -rlF 'fc.assert' src --include='*.test.ts')",
-    "typecheck": "tsgo --noEmit",
+    "test:property": "bun test --preload @stll/property-testing/preload $(grep -rlF 'fc.assert' src --include='*.test.ts')",
+    "typecheck": "bun ../../packages/scripts/src/tsc-native.ts --noEmit",
     "lint": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --report-unused-disable-directives-severity=error --deny-warnings --type-aware packages/template-conditions",
     "lint:fix": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --type-aware --fix packages/template-conditions",
     "format": "oxfmt .",
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@stll/conditions": "^0.1.0",
-    "better-result": "2.9.2"
+    "@stll/conditions": "^0.3.0",
+    "better-result": "3.0.0"
   },
   "devDependencies": {
     "@stll/property-testing": "0.0.0",
     "@stll/typescript-config": "0.0.0",
-    "@types/bun": "1.3.14",
-    "fast-check": "^4.8.0",
-    "tsdown": "0.22.3"
+    "bun-types": "1.4.0",
+    "fast-check": "^4.9.0",
+    "tsdown": "0.22.14"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"