@soundor/expression 0.0.0-stage → 0.17.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dmitrii Balakin and Egor Smirnov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/check-DMbokSSO.d.mts

@@ -0,0 +1,185 @@
+/**
+ * The types of the expression language. They say what a value is (a 32-bit
+ * float, a 16-bit unsigned integer), not what one language calls it, so the
+ * same expression means the same thing in every language it compiles to.
+ */
+/** Fixed-width integers. Up to 32 bits a JavaScript number, 64 bits a bigint. */
+declare const INTEGER_TYPES: readonly ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64'];
+/** IEEE 754 binary32 and binary64. */
+declare const FLOAT_TYPES: readonly ['float32', 'float64'];
+declare const NUMERIC_TYPES: readonly ["int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "float32", "float64"];
+declare const SCALAR_TYPES: readonly ["int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "float32", "float64", "boolean", "string"];
+type IntegerType = (typeof INTEGER_TYPES)[number];
+type FloatType = (typeof FLOAT_TYPES)[number];
+type NumericType = (typeof NUMERIC_TYPES)[number];
+/** The integers JavaScript holds as a bigint. */
+type BigIntType = 'int64' | 'uint64';
+type ScalarType = (typeof SCALAR_TYPES)[number];
+/** A number or `null`: what parsing text gives. */
+type NullableType = `${NumericType}?`;
+/** The type of an expression's value. */
+type ExpressionType = ScalarType | NullableType;
+/** `float32` of `float32?`; a non-nullable type stays as it is. */
+type BaseType<T extends ExpressionType> = T extends `${infer B}?` ? B & NumericType : T;
+/** The JavaScript value of a type: what compiled JavaScript computes. */
+type JsValue<T extends ExpressionType> = T extends BigIntType ? bigint : T extends NumericType ? number : T extends 'boolean' ? boolean : T extends 'string' ? string : T extends `${infer B}?` ? JsValue<B & NumericType> | null : never;
+/** What a literal of a type is written as in the builder. */
+type LiteralValue<T extends ExpressionType> = T extends BigIntType ? bigint : T extends NumericType ? number : T extends 'boolean' ? boolean : T extends 'string' ? string : never;
+interface IntegerInfo {
+  readonly bits: 8 | 16 | 32 | 64;
+  readonly signed: boolean;
+  readonly min: bigint;
+  readonly max: bigint;
+}
+/** Width, signedness and bounds of every integer type. */
+declare const INTEGERS: Readonly<Record<IntegerType, IntegerInfo>>;
+declare function isIntegerType(type: string): type is IntegerType;
+declare function isFloatType(type: string): type is FloatType;
+declare function isNumericType(type: string): type is NumericType;
+declare function isBigIntType(type: string): type is BigIntType;
+declare function isNullableType(type: string): type is NullableType;
+declare function isExpressionType(type: unknown): type is ExpressionType;
+/** The base type of a nullable type, or the type itself. */
+declare function baseType(type: ExpressionType): ScalarType;
+/** Operators of one operand. */
+declare const UNARY_OPERATORS: readonly ['neg', 'abs', 'sqrt', 'exp', 'log', 'floor', 'ceil', 'round', 'not', 'trim', 'lower'];
+/** Operators of two operands. */
+declare const BINARY_OPERATORS: readonly ['add', 'sub', 'mul', 'div', 'min', 'max', 'pow', 'eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'and', 'or', 'endsWith', 'removeSuffix'];
+type UnaryOperator = (typeof UNARY_OPERATORS)[number];
+type BinaryOperator = (typeof BINARY_OPERATORS)[number];
+/**
+ * A literal. Numbers of up to 32 bits and floats are JSON numbers (finite);
+ * 64-bit integers are decimal strings, so a tree survives JSON. `null` only
+ * for a nullable type.
+ */
+interface LiteralNode {
+  readonly kind: 'literal';
+  readonly type: ExpressionType;
+  readonly value: number | string | boolean | null;
+}
+/** A value the expression is evaluated with, bound by its context. */
+interface InputNode {
+  readonly kind: 'input';
+  readonly type: ExpressionType;
+  readonly name: string;
+}
+/** The value a `map` binds. */
+interface VariableNode {
+  readonly kind: 'variable';
+  readonly type: ExpressionType;
+  readonly name: string;
+}
+interface UnaryNode {
+  readonly kind: 'unary';
+  readonly type: ExpressionType;
+  readonly operator: UnaryOperator;
+  readonly operand: ExpressionNode;
+}
+interface BinaryNode {
+  readonly kind: 'binary';
+  readonly type: ExpressionType;
+  readonly operator: BinaryOperator;
+  readonly left: ExpressionNode;
+  readonly right: ExpressionNode;
+}
+interface IfNode {
+  readonly kind: 'if';
+  readonly type: ExpressionType;
+  readonly condition: ExpressionNode;
+  readonly then: ExpressionNode;
+  readonly else: ExpressionNode;
+}
+/** A numeric value as another numeric type. */
+interface ConvertNode {
+  readonly kind: 'convert';
+  readonly type: NumericType;
+  readonly operand: ExpressionNode;
+}
+/** A number in decimal notation with a fixed number of decimals. */
+interface FixedNode {
+  readonly kind: 'fixed';
+  readonly type: 'string';
+  readonly operand: ExpressionNode;
+  readonly digits: number;
+}
+interface ConcatNode {
+  readonly kind: 'concat';
+  readonly type: 'string';
+  readonly operands: readonly ExpressionNode[];
+}
+/** Text read as a number of `type`'s base type, or `null`. */
+interface ParseNode {
+  readonly kind: 'parse';
+  readonly type: NullableType;
+  readonly operand: ExpressionNode;
+}
+/** A nullable's value, or `fallback` when it is null. */
+interface CoalesceNode {
+  readonly kind: 'coalesce';
+  readonly type: ExpressionType;
+  readonly operand: ExpressionNode;
+  readonly fallback: ExpressionNode;
+}
+interface IsNullNode {
+  readonly kind: 'isNull';
+  readonly type: 'boolean';
+  readonly operand: ExpressionNode;
+}
+/**
+ * `null` when `operand` is null; otherwise `body`, in which `variable` is
+ * the operand's value.
+ */
+interface MapNode {
+  readonly kind: 'map';
+  readonly type: NullableType;
+  readonly operand: ExpressionNode;
+  readonly variable: string;
+  readonly body: ExpressionNode;
+}
+/** `body`, in which `variable` is the value of `value` (computed once). */
+interface LetNode {
+  readonly kind: 'let';
+  readonly type: ExpressionType;
+  readonly value: ExpressionNode;
+  readonly variable: string;
+  readonly body: ExpressionNode;
+}
+type ExpressionNode = LiteralNode | InputNode | VariableNode | UnaryNode | BinaryNode | IfNode | ConvertNode | FixedNode | ConcatNode | ParseNode | CoalesceNode | IsNullNode | MapNode | LetNode;
+/**
+ * An expression whose value is of type `T`. Its `type` keeps expressions of
+ * different types apart even where both are a JavaScript `number`.
+ */
+type Expression<T extends ExpressionType = ExpressionType> = ExpressionNode & {
+  readonly type: T;
+};
+type ExpressionKind = ExpressionNode['kind'];
+/** Whether `value` looks like an expression node (its shape is checked by `checkExpression`). */
+declare function isExpression(value: unknown): value is Expression;
+/** A problem in a tree, at a path such as `left.operand`. */
+interface ExpressionIssue {
+  readonly path: string;
+  readonly message: string;
+}
+/** Thrown by compilers for a tree that fails {@link checkExpression}. */
+declare class ExpressionError extends Error {
+  readonly issues: readonly ExpressionIssue[];
+  constructor(message: string, issues: readonly ExpressionIssue[]);
+}
+/** The inputs an expression is evaluated with, by name. */
+type ExpressionInputs = Readonly<Record<string, ExpressionType>>;
+interface CheckOptions {
+  /** The type the expression must have. */
+  readonly expected?: ExpressionType;
+}
+/** The deepest tree accepted; compilers recurse. */
+declare const MAX_DEPTH = 128;
+/** The most nodes in one tree. */
+declare const MAX_NODES = 10000;
+/** The most decimals `fixed` writes. */
+declare const MAX_FIXED_DIGITS = 15;
+/** Every problem in `node`, evaluated with `inputs`; empty when it is valid. */
+declare function checkExpression(node: unknown, inputs: ExpressionInputs, options?: CheckOptions): ExpressionIssue[];
+/** Throws {@link ExpressionError} when `node` is not valid. */
+declare function assertExpression(node: unknown, inputs: ExpressionInputs, options?: CheckOptions): asserts node is ExpressionNode;
+export { isNullableType as $, VariableNode as A, IntegerType as B, LetNode as C, UNARY_OPERATORS as D, ParseNode as E, FLOAT_TYPES as F, NumericType as G, LiteralValue as H, FloatType as I, baseType as J, SCALAR_TYPES as K, INTEGERS as L, BaseType as M, BigIntType as N, UnaryNode as O, ExpressionType as P, isIntegerType as Q, INTEGER_TYPES as R, IsNullNode as S, MapNode as T, NUMERIC_TYPES as U, JsValue as V, NullableType as W, isExpressionType as X, isBigIntType as Y, isFloatType as Z, ExpressionKind as _, MAX_DEPTH as a, IfNode as b, assertExpression as c, BinaryNode as d, isNumericType as et, BinaryOperator as f, Expression as g, ConvertNode as h, ExpressionIssue as i, isExpression as j, UnaryOperator as k, checkExpression as l, ConcatNode as m, ExpressionError as n, MAX_FIXED_DIGITS as o, CoalesceNode as p, ScalarType as q, ExpressionInputs as r, MAX_NODES as s, CheckOptions as t, BINARY_OPERATORS as u, ExpressionNode as v, LiteralNode as w, InputNode as x, FixedNode as y, IntegerInfo as z };
+//# sourceMappingURL=check-DMbokSSO.d.mts.map

package/dist/check-DMbokSSO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-DMbokSSO.d.mts","names":[],"sources":["../src/types.ts","../src/ast.ts","../src/check.ts"],"mappings":";;;;;;cAOa;;cAYA;cAEA;cAEA;KAED,sBAAsB;KACtB,oBAAoB;KACpB,sBAAsB;;KAEtB;KACA,qBAAqB;;KAErB,kBAAkB;;KAElB,iBAAiB,aAAa;;KAG9B,SAAS,UAAU,kBAAkB,mBAAmB,OAChE,IAAI,cACJ;;KAGQ,QAAQ,UAAU,kBAAkB,UAAU,sBAEtD,UAAU,uBAER,gCAEE,8BAEE,mBAAmB,OACjB,QAAQ,IAAI;;KAIZ,aAAa,UAAU,kBAAkB,UAAU,sBAE3D,UAAU,uBAER,gCAEE;UAIS;WACN;WACA;WACA;WACA;;;cAgBE,UAAU,SAAS,OAAO,aAAa;iBAWpC,cAAc,eAAe,QAAQ;iBAIrC,YAAY,eAAe,QAAQ;iBAInC,cAAc,eAAe,QAAQ;iBAIrC,aAAa,eAAe,QAAQ;iBAIpC,eAAe,eAAe,QAAQ;iBAItC,iBAAiB,gBAAgB,QAAQ;;iBAQzC,SAAS,MAAM,iBAAiB;;cC9GnC;;cAeA;KAoBD,wBAAwB;KACxB,yBAAyB;;;;;;UAOpB;WACN;WACA,MAAM;WACN;;;UAIM;WACN;WACA,MAAM;WACN;;;UAIM;WACN;WACA,MAAM;WACN;;UAGM;WACN;WACA,MAAM;WACN,UAAU;WACV,SAAS;;UAGH;WACN;WACA,MAAM;WACN,UAAU;WACV,MAAM;WACN,OAAO;;UAGD;WACN;WACA,MAAM;WACN,WAAW;WACX,MAAM;WACN,MAAM;;;UAIA;WACN;WACA,MAAM;WACN,SAAS;;;UAIH;WACN;WACA;WACA,SAAS;WACT;;UAGM;WACN;WACA;WACA,mBAAmB;;;UAIb;WACN;WACA,MAAM;WACN,SAAS;;;UAIH;WACN;WACA,MAAM;WACN,SAAS;WACT,UAAU;;UAGJ;WACN;WACA;WACA,SAAS;;;;;;UAOH;WACN;WACA,MAAM;WACN,SAAS;WACT;WACA,MAAM;;;UAIA;WACN;WACA,MAAM;WACN,OAAO;WACP;WACA,MAAM;;KAGL,iBACR,cACA,YACA,eACA,YACA,aACA,SACA,cACA,YACA,aACA,YACA,eACA,aACA,UACA;;;;;KAMQ,WAAW,UAAU,iBAAiB,kBAChD;WAA4B,MAAM;;KAExB,iBAAiB;;iBAGb,aAAa,iBAAiB,SAAS;;UCxKtC;WACN;WACA;;;cAIE,wBAAwB;WAC1B,iBAAiB;EAE1B,YAAY,iBAAiB,iBAAiB;;;KAUpC,mBAAmB,SAAS,eAAe;UAEtC;;WAEN,WAAW;;;cAIT;;cAEA;;cAEA;;iBAGG,gBACd,eACA,QAAQ,kBACR,UAAS,eACR;;iBAkBa,iBACd,eACA,QAAQ,kBACR,UAAS,uBACA,QAAQ"}

package/dist/check-Db6XRMc8.mjs

@@ -0,0 +1,395 @@
+// src/ast.ts
+/** Operators of one operand. */
+const UNARY_OPERATORS = [
+	"neg",
+	"abs",
+	"sqrt",
+	"exp",
+	"log",
+	"floor",
+	"ceil",
+	"round",
+	"not",
+	"trim",
+	"lower"
+];
+/** Operators of two operands. */
+const BINARY_OPERATORS = [
+	"add",
+	"sub",
+	"mul",
+	"div",
+	"min",
+	"max",
+	"pow",
+	"eq",
+	"ne",
+	"lt",
+	"lte",
+	"gt",
+	"gte",
+	"and",
+	"or",
+	"endsWith",
+	"removeSuffix"
+];
+/** Whether `value` looks like an expression node (its shape is checked by `checkExpression`). */
+function isExpression(value) {
+	return typeof value === "object" && value !== null && typeof value.kind === "string" && typeof value.type === "string";
+}
+// src/types.ts
+/**
+* The types of the expression language. They say what a value is (a 32-bit
+* float, a 16-bit unsigned integer), not what one language calls it, so the
+* same expression means the same thing in every language it compiles to.
+*/
+/** Fixed-width integers. Up to 32 bits a JavaScript number, 64 bits a bigint. */
+const INTEGER_TYPES = [
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64"
+];
+/** IEEE 754 binary32 and binary64. */
+const FLOAT_TYPES = ["float32", "float64"];
+const NUMERIC_TYPES = [...INTEGER_TYPES, ...FLOAT_TYPES];
+const SCALAR_TYPES = [
+	...NUMERIC_TYPES,
+	"boolean",
+	"string"
+];
+function integer(bits, signed) {
+	const width = BigInt(bits);
+	return signed ? {
+		bits,
+		signed,
+		min: -(1n << width - 1n),
+		max: (1n << width - 1n) - 1n
+	} : {
+		bits,
+		signed,
+		min: 0n,
+		max: (1n << width) - 1n
+	};
+}
+/** Width, signedness and bounds of every integer type. */
+const INTEGERS = {
+	int8: integer(8, true),
+	uint8: integer(8, false),
+	int16: integer(16, true),
+	uint16: integer(16, false),
+	int32: integer(32, true),
+	uint32: integer(32, false),
+	int64: integer(64, true),
+	uint64: integer(64, false)
+};
+function isIntegerType(type) {
+	return INTEGER_TYPES.includes(type);
+}
+function isFloatType(type) {
+	return type === "float32" || type === "float64";
+}
+function isNumericType(type) {
+	return isIntegerType(type) || isFloatType(type);
+}
+function isBigIntType(type) {
+	return type === "int64" || type === "uint64";
+}
+function isNullableType(type) {
+	return type.endsWith("?") && isNumericType(type.slice(0, -1));
+}
+function isExpressionType(type) {
+	return typeof type === "string" && (SCALAR_TYPES.includes(type) || isNullableType(type));
+}
+/** The base type of a nullable type, or the type itself. */
+function baseType(type) {
+	return isNullableType(type) ? type.slice(0, -1) : type;
+}
+// src/check.ts
+/**
+* Build-time validation of an expression tree. TypeScript keeps the builder's
+* output well typed, but a tree can also come from JSON or be built by hand,
+* so compilers check every tree they are given: its shape, every node's type,
+* literals within their type, inputs and variables that exist.
+*/
+/** Thrown by compilers for a tree that fails {@link checkExpression}. */
+var ExpressionError = class extends Error {
+	issues;
+	constructor(message, issues) {
+		super(`${message}\n${issues.map((issue) => `  ${issue.path || "(root)"}: ${issue.message}`).join("\n")}`);
+		this.name = "ExpressionError";
+		this.issues = issues;
+	}
+};
+/** The deepest tree accepted; compilers recurse. */
+const MAX_DEPTH = 128;
+/** The most nodes in one tree. */
+const MAX_NODES = 1e4;
+/** The most decimals `fixed` writes. */
+const MAX_FIXED_DIGITS = 15;
+/** Every problem in `node`, evaluated with `inputs`; empty when it is valid. */
+function checkExpression(node, inputs, options = {}) {
+	const issues = [];
+	const type = visit(node, "", 0, inputs, /* @__PURE__ */ new Map(), issues, { nodes: 0 });
+	if (type !== void 0 && options.expected !== void 0 && type !== options.expected) issues.push({
+		path: "",
+		message: `expected an expression of type '${options.expected}', got '${type}'`
+	});
+	return issues;
+}
+/** Throws {@link ExpressionError} when `node` is not valid. */
+function assertExpression(node, inputs, options = {}) {
+	const issues = checkExpression(node, inputs, options);
+	if (issues.length > 0) throw new ExpressionError("Invalid expression.", issues);
+}
+const join = (path, key) => path === "" ? key : `${path}.${key}`;
+function visit(value, path, depth, inputs, scope, issues, state) {
+	const fail = (message, at = path) => {
+		issues.push({
+			path: at,
+			message
+		});
+	};
+	if (++state.nodes > 1e4) {
+		if (state.nodes === 10001) return fail(`an expression has at most ${MAX_NODES} nodes`);
+		return;
+	}
+	if (depth > 128) return fail(`an expression nests at most 128 levels deep`);
+	if (typeof value !== "object" || value === null) return fail("expected an expression node");
+	const node = value;
+	const type = node["type"];
+	if (!isExpressionType(type)) return fail(`unknown expression type ${JSON.stringify(type)}`);
+	const child = (key) => visit(node[key], join(path, key), depth + 1, inputs, scope, issues, state);
+	const expect = (actual, message) => {
+		if (actual !== type) fail(`${message}: the node says '${type}', its value is '${actual}'`);
+	};
+	switch (node.kind) {
+		case "literal": return checkLiteral(type, node["value"], path, issues);
+		case "input":
+		case "variable": {
+			const name = node["name"];
+			if (typeof name !== "string") return fail("expected a name");
+			const declared = node.kind === "input" ? inputs[name] : scope.get(name);
+			if (declared === void 0) return fail(node.kind === "input" ? `unknown input '${name}'; this expression has ${Object.keys(inputs).length === 0 ? "no inputs" : Object.keys(inputs).map((input) => `'${input}'`).join(", ")}` : `variable '${name}' is not bound by an enclosing let or map`);
+			if (declared !== type) return fail(`'${name}' is '${declared}', not '${type}'`);
+			return type;
+		}
+		case "unary": {
+			const operator = node["operator"];
+			if (!UNARY_OPERATORS.includes(operator)) return fail(`unknown unary operator ${JSON.stringify(operator)}`);
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			let result;
+			switch (operator) {
+				case "neg":
+				case "abs":
+					if (isNumericType(operand)) result = operand;
+					break;
+				case "sqrt":
+				case "exp":
+				case "log":
+				case "floor":
+				case "ceil":
+				case "round":
+					if (isFloatType(operand)) result = operand;
+					break;
+				case "not":
+					if (operand === "boolean") result = operand;
+					break;
+				case "trim":
+				case "lower": if (operand === "string") result = operand;
+			}
+			if (result === void 0) return fail(`'${String(operator)}' does not take a '${operand}'`);
+			expect(result, `'${String(operator)}'`);
+			return type;
+		}
+		case "binary": {
+			const operator = node["operator"];
+			if (!BINARY_OPERATORS.includes(operator)) return fail(`unknown binary operator ${JSON.stringify(operator)}`);
+			const left = child("left");
+			const right = child("right");
+			if (left === void 0 || right === void 0) return void 0;
+			if (left !== right) return fail(`'${String(operator)}' takes two operands of one type, got '${left}' and '${right}'; convert one explicitly`);
+			let result;
+			switch (operator) {
+				case "add":
+				case "sub":
+				case "mul":
+				case "div":
+				case "min":
+				case "max":
+					if (isNumericType(left)) result = left;
+					break;
+				case "pow":
+					if (isFloatType(left)) result = left;
+					break;
+				case "eq":
+				case "ne":
+					if (!isNullableType(left)) result = "boolean";
+					break;
+				case "lt":
+				case "lte":
+				case "gt":
+				case "gte":
+					if (isNumericType(left)) result = "boolean";
+					break;
+				case "and":
+				case "or":
+					if (left === "boolean") result = "boolean";
+					break;
+				case "endsWith":
+					if (left === "string") result = "boolean";
+					break;
+				case "removeSuffix": if (left === "string") result = "string";
+			}
+			if (result === void 0) return fail(`'${String(operator)}' does not take '${left}' operands`);
+			expect(result, `'${String(operator)}'`);
+			return type;
+		}
+		case "if": {
+			const condition = child("condition");
+			const then = child("then");
+			const otherwise = child("else");
+			if (condition === void 0 || then === void 0 || otherwise === void 0) return void 0;
+			if (condition !== "boolean") return fail(`a condition is 'boolean', got '${condition}'`, join(path, "condition"));
+			const joined = joinTypes(then, otherwise);
+			if (joined === void 0) return fail(`the branches have different types, '${then}' and '${otherwise}'`);
+			expect(joined, "if");
+			return type;
+		}
+		case "convert": {
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			if (!isNumericType(operand) || !isNumericType(type)) return fail(`convert turns a number into another number, not '${operand}' into '${type}'`);
+			return type;
+		}
+		case "fixed": {
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			const digits = node["digits"];
+			if (typeof digits !== "number" || !Number.isInteger(digits) || digits < 0 || digits > 15) return fail(`fixed writes 0 to 15 decimals, got ${JSON.stringify(digits)}`, join(path, "digits"));
+			if (!isNumericType(operand)) return fail(`fixed formats a number, not a '${operand}'`);
+			expect("string", "fixed");
+			return type;
+		}
+		case "concat": {
+			const operands = node["operands"];
+			if (!Array.isArray(operands) || operands.length === 0) return fail("concat takes at least one string");
+			let ok = true;
+			operands.forEach((operand, index) => {
+				const at = join(path, `operands[${index}]`);
+				const operandType = visit(operand, at, depth + 1, inputs, scope, issues, state);
+				if (operandType === void 0) ok = false;
+				else if (operandType !== "string") {
+					ok = false;
+					fail(`concat takes strings, got '${operandType}'; format numbers with fixed`, at);
+				}
+			});
+			if (!ok) return void 0;
+			expect("string", "concat");
+			return type;
+		}
+		case "parse": {
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			if (operand !== "string") return fail(`parse reads a string, not a '${operand}'`);
+			if (!isNullableType(type)) return fail(`parse gives a nullable number, not '${type}'`);
+			return type;
+		}
+		case "coalesce": {
+			const operand = child("operand");
+			const fallback = child("fallback");
+			if (operand === void 0 || fallback === void 0) return void 0;
+			if (!isNullableType(operand)) return fail(`coalesce takes a nullable value, not a '${operand}'`);
+			if (fallback !== baseType(operand)) return fail(`the fallback of a '${operand}' is a '${baseType(operand)}', not a '${fallback}'`);
+			expect(fallback, "coalesce");
+			return type;
+		}
+		case "isNull": {
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			if (!isNullableType(operand)) return fail(`isNull takes a nullable value, not a '${operand}'`);
+			expect("boolean", "isNull");
+			return type;
+		}
+		case "map": {
+			const operand = child("operand");
+			if (operand === void 0) return void 0;
+			const variable = node["variable"];
+			if (typeof variable !== "string" || variable === "") return fail("a map names its variable", join(path, "variable"));
+			if (scope.has(variable)) return fail(`variable '${variable}' is already bound`, join(path, "variable"));
+			if (!isNullableType(operand)) return fail(`map takes a nullable value, not a '${operand}'`);
+			const inner = new Map(scope).set(variable, baseType(operand));
+			const body = visit(node["body"], join(path, "body"), depth + 1, inputs, inner, issues, state);
+			if (body === void 0) return void 0;
+			if (!isNumericType(body) && !isNullableType(body)) return fail(`a map gives a number, not a '${body}'`, join(path, "body"));
+			expect(isNullableType(body) ? body : `${body}?`, "map");
+			return type;
+		}
+		case "let": {
+			const value = child("value");
+			if (value === void 0) return void 0;
+			const variable = node["variable"];
+			if (typeof variable !== "string" || variable === "") return fail("a let names its variable", join(path, "variable"));
+			if (scope.has(variable)) return fail(`variable '${variable}' is already bound`, join(path, "variable"));
+			const inner = new Map(scope).set(variable, value);
+			const body = visit(node["body"], join(path, "body"), depth + 1, inputs, inner, issues, state);
+			if (body === void 0) return void 0;
+			expect(body, "let");
+			return type;
+		}
+		default: return fail(`unknown expression kind ${JSON.stringify(node.kind)}`);
+	}
+}
+/** The type of `if (c) a else b`: equal types, or a number and its nullable. */
+function joinTypes(a, b) {
+	if (a === b) return a;
+	if (baseType(a) === baseType(b) && isNumericType(baseType(a))) return `${baseType(a)}?`;
+}
+function checkLiteral(type, value, path, issues) {
+	const problem = literalProblem(type, value);
+	if (problem !== void 0) {
+		issues.push({
+			path,
+			message: problem
+		});
+		return;
+	}
+	return type;
+}
+/** Why `value` is not a literal of `type`, or undefined when it is. */
+function literalProblem(type, value) {
+	if (isNullableType(type)) return value === null ? void 0 : literalProblem(baseType(type), value);
+	if (type === "boolean") return typeof value === "boolean" ? void 0 : `expected a boolean, got ${describe(value)}`;
+	if (type === "string") return typeof value === "string" ? void 0 : `expected a string, got ${describe(value)}`;
+	if (isFloatType(type)) {
+		if (typeof value !== "number" || !Number.isFinite(value)) return `a '${type}' literal is a finite number, got ${describe(value)}`;
+		return;
+	}
+	if (isIntegerType(type)) {
+		const { min, max } = INTEGERS[type];
+		let integer;
+		if (isBigIntType(type)) {
+			if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(value)) return `a '${type}' literal is a decimal string, got ${describe(value)}`;
+			integer = BigInt(value);
+		} else {
+			if (typeof value !== "number" || !Number.isInteger(value) || Object.is(value, -0)) return `a '${type}' literal is an integer, got ${describe(value)}`;
+			integer = BigInt(value);
+		}
+		if (integer < min || integer > max) return `${String(integer)} is outside '${type}' (${min} to ${max})`;
+		return;
+	}
+	return `no literal of type '${type}'`;
+}
+function describe(value) {
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "number" && Object.is(value, -0)) return "-0";
+	return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+export { isExpression as C, UNARY_OPERATORS as S, isFloatType as _, assertExpression as a, isNumericType as b, literalProblem as c, INTEGER_TYPES as d, NUMERIC_TYPES as f, isExpressionType as g, isBigIntType as h, MAX_NODES as i, FLOAT_TYPES as l, baseType as m, MAX_DEPTH as n, checkExpression as o, SCALAR_TYPES as p, MAX_FIXED_DIGITS as r, joinTypes as s, ExpressionError as t, INTEGERS as u, isIntegerType as v, BINARY_OPERATORS as x, isNullableType as y };
+
+//# sourceMappingURL=check-Db6XRMc8.mjs.map